* Re: [rfa] struct dictionary [not found] <ro1k7dbwprh.fsf@jackfruit.Stanford.EDU> @ 2003-05-01 3:37 ` Eli Zaretskii 2003-05-01 21:15 ` David Carlton 2003-05-20 3:58 ` David Carlton 2003-06-09 22:39 ` Elena Zannoni 2 siblings, 1 reply; 15+ messages in thread From: Eli Zaretskii @ 2003-05-01 3:37 UTC (permalink / raw) To: carlton; +Cc: gdb-patches, ezannoni, jimb > From: David Carlton <carlton@math.stanford.edu> > Date: 30 Apr 2003 16:04:50 -0700 > > As promised in > <http://sources.redhat.com/ml/gdb/2003-04/msg00177.html>, here's the > 'struct dictionary' patch. Are we going to have some docs about this in gdbint.texinfo? ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-05-01 3:37 ` [rfa] struct dictionary Eli Zaretskii @ 2003-05-01 21:15 ` David Carlton 0 siblings, 0 replies; 15+ messages in thread From: David Carlton @ 2003-05-01 21:15 UTC (permalink / raw) To: Eli Zaretskii; +Cc: gdb-patches, ezannoni, jimb On Thu, 01 May 2003 06:34:07 +0300, "Eli Zaretskii" <eliz@elta.co.il> said: >> From: David Carlton <carlton@math.stanford.edu> >> As promised in >> <http://sources.redhat.com/ml/gdb/2003-04/msg00177.html>, here's the >> 'struct dictionary' patch. > Are we going to have some docs about this in gdbint.texinfo? It's a refactoring of 'struct block', which isn't currently mentioned in gdbint.texinfo. So it seems to me that doing so isn't urgent. David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary [not found] <ro1k7dbwprh.fsf@jackfruit.Stanford.EDU> 2003-05-01 3:37 ` [rfa] struct dictionary Eli Zaretskii @ 2003-05-20 3:58 ` David Carlton 2003-06-09 22:39 ` Elena Zannoni 2 siblings, 0 replies; 15+ messages in thread From: David Carlton @ 2003-05-20 3:58 UTC (permalink / raw) To: gdb-patches; +Cc: Elena Zannoni, Jim Blandy On 30 Apr 2003 16:04:50 -0700, David Carlton <carlton@math.stanford.edu> said: > As promised in > <http://sources.redhat.com/ml/gdb/2003-04/msg00177.html>, here's the > 'struct dictionary' patch. Ping? My next namespace patch will depend on this. David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary [not found] <ro1k7dbwprh.fsf@jackfruit.Stanford.EDU> 2003-05-01 3:37 ` [rfa] struct dictionary Eli Zaretskii 2003-05-20 3:58 ` David Carlton @ 2003-06-09 22:39 ` Elena Zannoni 2003-06-09 22:55 ` Daniel Jacobowitz 2003-06-10 16:43 ` David Carlton 2 siblings, 2 replies; 15+ messages in thread From: Elena Zannoni @ 2003-06-09 22:39 UTC (permalink / raw) To: David Carlton; +Cc: gdb-patches, Elena Zannoni, Jim Blandy David Carlton writes: > As promised in > <http://sources.redhat.com/ml/gdb/2003-04/msg00177.html>, here's the > 'struct dictionary' patch. > > I've tested this on GCC 3.2, DWARF 2, i686-pc-linux-gnu, and have been > using it on my branch for months. Most of the work is generic; the > two special cases are jv-lang.c and mdebugread.c. I'm fairly sure I > got the former right; the mdebugread.c changes are big enough that I > could easily have slipped up somewhere. (Though I have tested the > data structures that are used by mdebugread.c but not by buildsym.c.) > So obviously somebody should test this on a machine using > mdebugread.c; any volunteers? Does anybody have a setup for testing mdebug? Daniel? > > This is orthogonal to my current namespace patch awaiting review, but > I will use these mechanisms in my next namespace patch. > > David Carlton > carlton@math.stanford.edu > > 2003-04-28 David Carlton <carlton@bactrian.org> > > * dictionary.h: New. > * dictionary.c: New. > * block.h: Add opaque declaration for struct dictionary. > (struct block): Add 'dict' member; delete 'hashtable', 'nsyms', > 'sym' members. > (BLOCK_DICT): New macro. > Delete macros BLOCK_HASHTABLE, BLOCK_NSYMS, BLOCK_SYM, > BLOCK_BUCKETS, BLOCK_BUCKET, BLOCK_HASHTABLE_SIZE, > BLOCK_SHOULD_SORT. > (ALL_BLOCK_SYMBOLS): Update definition. > * Makefile.in (SFILES): Add dictionary.c. > (dictionary_h): New. > (COMMON_OBS): Add dictionary.o. > (dictionary.o): New. > (ada-lang.o): Depend on dictionary_h. > (buildsym.o, coffread.o, jv-lang.o, mdebugread.o, objfiles.o) > (printcmd.o, stack.o, symmisc.o, symtab.o, tracepoint.o) > (valops.o, mi-cmd-stack.o): Ditto. > (gdbtk-cmds.o): Update dependencies. > (gdbtk-stack.o): Ditto. > * ada-lang.c: Include dictionary.h. > (symtab_for_sym): Update uses of ALL_BLOCK_SYMBOLS. > (fill_in_ada_prototype, debug_print_block): Ditto. > (ada_add_block_symbols): Update uses of ALL_BLOCK_SYMBOLS; replace > explicit iteration by use of ALL_BLOCK_SYMBOLS. Delete variable > 'is_sorted'. > * mdebugread.c: Include dictionary.h. > (struct parse_stack): Delete 'maxsyms' member. > (parse_symbol): Update calls to new_block. Delete calls to > shrink_block. Use dictionary methods. > (psymtab_to_symtab_1): Delete calls to sort_symtab_syms. > Update calls to new_symtab. Don't maintain maxsyms data. > (mylookup_symbol): Update use of ALL_BLOCK_SYMBOLS. > (add_symbol): Just call dict_add_symbol. > (new_symtab): Delete 'maxsyms' argument. > (new_symtab): Update calls to new_block. > (new_block): Delete 'maxsyms' argument; add 'function' argument. > (shrink_block): Delete function. > (fixup_sigtramp): Update call to new_block. Add symbol via > dict_add_symbol. > * jv-lang.c: Include dictionary.h. > (get_java_class_symtab): Set the BLOCK_DICT of the blocks > appropriately. Set class_symtab->free_func. Make sure the > blockvector is big enough to hold two blocks. > (add_class_symtab_symbol): Use dictionary methods. > (free_class_block): New function. > (type_from_class): Replace explicit iteration by > ALL_BLOCK_SYMBOLS. > * symtab.h (struct symtab): Replace 'free_ptr' method by > 'free_func'. > * dwarf2read.c (psymtab_to_symtab_1): Delete call to > sort_symtab_syms. > * dwarfread.c (psymtab_to_symtab_1): Delete call to > sort_symtab_syms. > * coffread.c (coff_symfile_read): Delete call to sort_symtab_syms. > Include dictionary.h. > (patch_opaque_types): Update use of ALL_BLOCK_SYMBOLS. > * dbxread.c (dbx_psymtab_to_symtab_1): Delete call to > sort_symtab_syms. > * objfiles.c: Include dictionary.h. > (objfile_relocate): Update use of ALL_BLOCK_SYMBOLS. > * buildsym.c: Include dictionary.h. > (finish_block): Use dictionary methods. > (end_symtab): Set free_func to NULL, not free_ptr. > * tracepoint.c: Include dictionary.h. > (add_local_symbols): Update use of ALL_BLOCK_SYMBOLS. > (scope_info): Ditto. > * stack.c: Include dictionary.h. > (print_block_frame_locals): Update use of ALL_BLOCK_SYMBOLS. > (print_block_frame_labels, print_frame_arg_vars): Ditto. > * symmisc.c (free_symtab_block): Use dictionary methods. > (dump_symtab): Comment out part where we print size of block and > update use of ALL_BLOCK_SYMBOLS. > (free_symtab): Replace use of 'free_ptr' by 'free_func'. > Include dictionary.h. > * symfile.h: Delete declarations of sort_block_syms, > sort_symtab_syms. > * symfile.c (sort_block_syms): Delete. > (sort_symtab_syms): Delete. > * symtab.c: Include dictionary.h. > (lookup_block_symbol): Use dictionary iterators. > (find_pc_sect_symtab): Update use of ALL_BLOCK_SYMBOLS. > (search_symbols, make_symbol_completion_list): Ditto. > (make_symbol_overload_list): Ditto. > * printcmd.c (print_frame_args): Update use of ALL_BLOCK_SYMBOLS. > Include dictionary.h. > * valops.c (value_of_local): Use dict_empty. > Include dictionary.h. > > 2003-04-28 David Carlton <carlton@bactrian.org> > > * mi-cmd-stack.c: Include dictionary.h. > (list_args_or_locals): Update use of ALL_BLOCK_SYMBOLS. > > 2003-04-28 David Carlton <carlton@bactrian.org> > > * generic/gdbtk-stack.c: Include dictionary.h. > (gdb_block_vars): Update use of ALL_BLOCK_SYMBOLS. > (gdb_get_blocks, gdb_get_vars_command): Ditto. > * generic/gdbtk-cmds.c: Include dictionary.h. > (gdb_listfuncs): Update use of ALL_BLOCK_SYMBOLS. > As usual, some comments. Could you check in the removal of the sorting as one patch, and the dictionary as another? See below for some things, but in general it's ok. I don't feel too comfortable with the Java stuff, are there any tests that use that particular code? It sure looks safe to me though. elena > --- /dev/null 2002-08-30 16:31:37.000000000 -0700 > +++ dictionary.h 2003-04-30 16:01:20.000000000 -0700 > @@ -0,0 +1,152 @@ > +/* Routines for name->symbol lookups in GDB. > + > + Copyright 2003 Free Software Foundation, Inc. > + > + Contributed by David Carlton <carlton@bactrian.org> and by Kealia, > + 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 (at > + your option) any later version. > + > + This program is distributed in the hope that it will be useful, but > + WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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. */ > + > +#ifndef DICTIONARY_H > +#define DICTIONARY_H > + > +/* An opaque type for dictionaries; only dictionary.c should know > + about its innards. */ > + > +struct dictionary; > + > +/* Other types needed for declarations. */ > + > +struct symbol; > +struct obstack; > +struct pending; > + > + > +/* The creation functions for various implementations of > + dictionaries. */ > + > +/* Create a dictionary 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, > + const struct pending > + *symbol_list); > + > +/* Create a dictionary 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. */ > + > +extern struct dictionary *dict_create_hashed_expandable (void); > + > +/* Create a dictionary 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, > + const struct pending > + *symbol_list); > + > +/* Create a dictionary 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. */ > + > +extern struct dictionary *dict_create_linear_expandable (void); > + > + > +/* 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. */ > + > +/* Free the memory used by a dictionary that's not on an obstack. (If > + any.) */ > + > +extern void dict_free (struct dictionary *dict); > + > +/* Add a symbol to an expandable dictionary. */ > + > +extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym); > + > +/* Is the dictionary empty? */ > + > +extern int dict_empty (struct dictionary *dict); > + > +/* 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 > + be opaque if we didn't need to be able to allocate it on the > + stack. */ > + > +struct dict_iterator > +{ > + /* The dictionary that this iterator is associated to. */ > + const struct dictionary *dict; > + /* The next two members are data that is used in a way that depends > + on DICT's implementation type. */ > + int index; > + struct symbol *current; > +}; > + > +/* Initialize ITERATOR to point at the first symbol in DICT, and > + return that first symbol, or NULL if DICT is empty. */ > + > +extern struct symbol *dict_iterator_first (const struct dictionary *dict, > + struct dict_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 dict_iterator_first or dict_iterator_next on this > + iteration. */ > + > +extern struct symbol *dict_iterator_next (struct dict_iterator *iterator); > + > +/* Initialize ITERATOR to point at the first symbol in DICT whose > + SYMBOL_BEST_NAME is NAME (as tested using strcmp_iw), and return > + that first symbol, or NULL if there are no such symbols. */ > + > +extern struct symbol *dict_iter_name_first (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator); > + > +/* Advance ITERATOR to point at the next symbol in DICT whose > + SYMBOL_BEST_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 dict_iterator_first or > + dict_iterator_next on this iteration. And don't call it unless > + ITERATOR was created by a previous call to dict_iter_name_first > + with the same NAME. */ > + > +extern struct symbol *dict_iter_name_next (const char *name, > + struct dict_iterator *iterator); > + > + > +/* Macro to loop through all symbols in a dictionary DICT, in no > + particular order. ITER is a struct dict_iterator (NOTE: __not__ a > + struct dict_iterator *), and SYM points to the current symbol. > + > + It's implemented as a single loop, so you can terminate the loop > + early by a break if you desire. */ > + > +#define ALL_DICT_SYMBOLS(dict, iter, sym) \ > + for ((sym) = dict_iterator_first ((dict), &(iter)); \ > + (sym); \ > + (sym) = dict_iterator_next (&(iter))) > + > +#endif /* DICTIONARY_H */ > --- /dev/null 2002-08-30 16:31:37.000000000 -0700 > +++ dictionary.c 2003-04-28 11:00:23.000000000 -0700 > @@ -0,0 +1,785 @@ > +/* Routines for name->symbol lookups in GDB. > + > + Copyright 2003 Free Software Foundation, Inc. > + > + Contributed by David Carlton <carlton@bactrian.org> and by Kealia, > + 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 (at > + your option) any later version. > + > + This program is distributed in the hope that it will be useful, but > + WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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. */ > + > +#include "defs.h" > +#include "gdb_obstack.h" > +#include "symtab.h" > +#include "buildsym.h" > +#include "gdb_assert.h" > +#include "dictionary.h" > + > +/* This file implements dictionaries, which are tables that associate > + symbols to names. They are represented by an opaque type 'struct > + dictionary'. That type has various internal implementations, which > + you can choose between depending on what properties you need > + (e.g. fast lookup, order-preserving, expandable). > + > + Each dictionary starts with a 'virtual function table' that > + contains the functions that actually implement the various > + operations that dictionaries provide. (Note, however, that, for > + the sake of client code, we also provide some functions that can be > + implemented generically in terms of the functions in the vtable.) > + > + To add a new dictionary implementation <impl>, what you should do > + is: > + > + * Add a new element DICT_<IMPL> to dict_type. > + > + * Create a new structure dictionary_<impl>. If your new > + implementation is a variant of an existing one, make sure that > + their structs have the same initial data members. Define accessor > + macros for your new data members. > + > + * Implement all the functions in dict_vtbl as static functions, > + whose name is the same as the corresponding member of dict_vtbl > + plus _<impl>. You don't have to do this for those members where > + you can reuse existing generic functions > + (e.g. add_symbol_nonexpandable, free_obstack) or in the case where > + your new implementation is a variant of an existing implementation > + and where the variant doesn't affect the member function in > + question. > + > + * Define a static const struct dict_vtbl dict_<impl>_vtbl. > + > + * Define a function dict_create_<impl> to create these > + gizmos. Add its declaration to dictionary.h. > + > + To add a new operation <op> on all existing implementations, what > + you should do is: > + > + * Add a new member <op> to struct dict_vtbl. > + > + * If there is useful generic behavior <op>, define a static > + function <op>_something_informative that implements that behavior. > + (E.g. add_symbol_nonexpandable, free_obstack.) > + > + * For every implementation <impl> that should have its own specific > + behavior for <op>, define a static function <op>_<impl> > + implementing it. > + > + * Modify all existing dict_vtbl_<impl>'s to include the appropriate > + member. > + > + * Define a function dict_<op> that looks up <op> in the dict_vtbl > + and calls the appropriate function. Add a declaration for > + dict_<op> to dictionary.h. > + > +*/ > + > +/* An enum representing the various implementations of dictionaries. > + Used only for debugging. */ > + > +enum dict_type > + { > + /* Symbols are stored in a fixed-size hash table. */ > + DICT_HASHED, > + /* Symbols are stored in an expandable hash table. */ > + DICT_HASHED_EXPANDABLE, > + /* Symbols are stored in a fixed-size array. */ > + DICT_LINEAR, > + /* Symbols are stored in an expandable array. */ > + DICT_LINEAR_EXPANDABLE, > + }; > + > +/* The virtual function table. */ > + > +struct dict_vtbl > +{ > + /* The type of the dictionary. This is only here to make debugging > + a bit easier; it's not actually used. */ > + enum dict_type type; > + /* The function to free a dictionary. */ > + void (*free) (struct dictionary *dict); > + /* Add a symbol to a dictionary, if possible. */ > + void (*add_symbol) (struct dictionary *dict, struct symbol *sym); > + /* Iterator functions. */ > + struct symbol *(*iterator_first) (const struct dictionary *dict, > + struct dict_iterator *iterator); > + struct symbol *(*iterator_next) (struct dict_iterator *iterator); > + /* Functions to iterate over symbols with a given name. */ > + struct symbol *(*iter_name_first) (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator); > + struct symbol *(*iter_name_next) (const char *name, > + struct dict_iterator *iterator); > +}; > + > +/* Now comes the structs used to store the data for different > + implementations. If two implementations have data in common, put > + the common data at the top of their structs, ordered in the same > + way. */ > + > +struct dictionary_hashed > +{ > + int nbuckets; > + struct symbol **buckets; > +}; > + > +struct dictionary_hashed_expandable > +{ > + /* How many buckets we currently have. */ > + int nbuckets; > + struct symbol **buckets; > + /* How many syms we currently have; we need this so we will know > + when to add more buckets. */ > + int nsyms; > +}; > + > +struct dictionary_linear > +{ > + int nsyms; > + struct symbol **syms; > +}; > + > +struct dictionary_linear_expandable > +{ > + /* How many symbols we currently have. */ > + int nsyms; > + struct symbol **syms; > + /* How many symbols we can store before needing to reallocate. */ > + int capacity; > +}; > + > +/* And now, the star of our show. */ > + > +struct dictionary > +{ > + const struct dict_vtbl *vtbl; > + union > + { > + struct dictionary_hashed hashed; > + struct dictionary_hashed_expandable hashed_expandable; > + struct dictionary_linear linear; > + struct dictionary_linear_expandable linear_expandable; > + } > + data; > +}; > + > +/* Accessor macros. */ > + > +#define DICT_VTBL(d) (d)->vtbl > + > +/* These can be used for DICT_HASHED_EXPANDABLE, too. */ > + > +#define DICT_HASHED_NBUCKETS(d) (d)->data.hashed.nbuckets > +#define DICT_HASHED_BUCKETS(d) (d)->data.hashed.buckets > +#define DICT_HASHED_BUCKET(d,i) DICT_HASHED_BUCKETS (d) [i] > + > +#define DICT_HASHED_EXPANDABLE_NSYMS(d) (d)->data.hashed_expandable.nsyms > + > +/* These can be used for DICT_LINEAR_EXPANDABLEs, too. */ > + > +#define DICT_LINEAR_NSYMS(d) (d)->data.linear.nsyms > +#define DICT_LINEAR_SYMS(d) (d)->data.linear.syms > +#define DICT_LINEAR_SYM(d,i) DICT_LINEAR_SYMS (d) [i] > + > +#define DICT_LINEAR_EXPANDABLE_CAPACITY(d) \ > + (d)->data.linear_expandable.capacity > + > +/* The initial size of a DICT_*_EXPANDABLE dictionary. */ > + > +#define DICT_EXPANDABLE_INITIAL_CAPACITY 10 > + > +/* This calculates the number of buckets we'll use in a hashtable, > + given the number of symbols that it will contain. */ > + > +#define DICT_HASHTABLE_SIZE(n) ((n)/5 + 1) > + > +/* Accessor macros for dict_iterators; they're here rather than > + dictionary.h because code elsewhere should treat dict_iterators as > + opaque. */ > + > +/* The dictionary that the iterator is associated to. */ > +#define DICT_ITERATOR_DICT(iter) (iter)->dict > +/* For linear dictionaries, the index of the last symbol returned; for > + hashed dictionaries, the bucket of the last symbol returned. */ > +#define DICT_ITERATOR_INDEX(iter) (iter)->index > +/* For hashed dictionaries, this points to the last symbol returned; > + otherwise, this is unused. */ > +#define DICT_ITERATOR_CURRENT(iter) (iter)->current > + > +/* Declarations of functions for vtbls. */ > + > +/* Functions that might work across a range of dictionary types. */ > + > +static void add_symbol_nonexpandable (struct dictionary *dict, > + struct symbol *sym); > + > +static void free_obstack (struct dictionary *dict); > + > +/* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE > + dictionaries. */ > + > +static struct symbol *iterator_first_hashed (const struct dictionary *dict, > + struct dict_iterator *iterator); > + > +static struct symbol *iterator_next_hashed (struct dict_iterator *iterator); > + > +static struct symbol *iter_name_first_hashed (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator); > + > +static struct symbol *iter_name_next_hashed (const char *name, > + struct dict_iterator *iterator); > + > +/* Functions only for DICT_HASHED_EXPANDABLE. */ > + > +static void free_hashed_expandable (struct dictionary *dict); > + > +static void add_symbol_hashed_expandable (struct dictionary *dict, > + struct symbol *sym); > + > +/* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE > + dictionaries. */ > + > +static struct symbol *iterator_first_linear (const struct dictionary *dict, > + struct dict_iterator *iterator); > + > +static struct symbol *iterator_next_linear (struct dict_iterator *iterator); > + > +static struct symbol *iter_name_first_linear (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator); > + > +static struct symbol *iter_name_next_linear (const char *name, > + struct dict_iterator *iterator); > + > + > +/* Functions only for DICT_LINEAR_EXPANDABLE. */ > + > +static void free_linear_expandable (struct dictionary *dict); > + > +static void add_symbol_linear_expandable (struct dictionary *dict, > + struct symbol *sym); > + > +/* Various vtbls that we'll actually use. */ > + > +static const struct dict_vtbl dict_hashed_vtbl = > + { > + DICT_HASHED, free_obstack, add_symbol_nonexpandable, > + iterator_first_hashed, iterator_next_hashed, > + iter_name_first_hashed, iter_name_next_hashed, > + }; > + Could you do these one per line and put a comment with the field name next to it (for easy grepping)? I am not too fond of the use of vtable terminology, could you use 'vector' or something else? > +static const struct dict_vtbl dict_hashed_expandable_vtbl = > + { > + DICT_HASHED_EXPANDABLE, free_hashed_expandable, > + add_symbol_hashed_expandable, > + iterator_first_hashed, iterator_next_hashed, > + iter_name_first_hashed, iter_name_next_hashed, > + }; > + > +static const struct dict_vtbl dict_linear_vtbl = > + { > + DICT_LINEAR, free_obstack, add_symbol_nonexpandable, > + iterator_first_linear, iterator_next_linear, > + iter_name_first_linear, iter_name_next_linear, > + }; > + > +static const struct dict_vtbl dict_linear_expandable_vtbl = > + { > + DICT_LINEAR_EXPANDABLE, free_linear_expandable, > + add_symbol_linear_expandable, > + iterator_first_linear, iterator_next_linear, > + iter_name_first_linear, iter_name_next_linear, > + }; > + > +/* Declarations of helper functions (i.e. ones that don't go into > + vtbls). */ > + > +static struct symbol *iterator_hashed_advance (struct dict_iterator *iter); > + > +static void insert_symbol_hashed (struct dictionary *dict, > + struct symbol *sym); > + > +static void expand_hashtable (struct dictionary *dict); > + > +/* The creation functions. */ > + > +/* Create a dictionary implemented via a fixed-size hashtable. All > + memory it uses is allocated on OBSTACK; the environment is > + initialized from SYMBOL_LIST. */ > + > +struct dictionary * > +dict_create_hashed (struct obstack *obstack, > + const struct pending *symbol_list) > +{ > + struct dictionary *retval; > + int nsyms = 0, nbuckets, i; > + struct symbol **buckets; > + const struct pending *list_counter; > + > + retval = obstack_alloc (obstack, sizeof (struct dictionary)); > + DICT_VTBL (retval) = &dict_hashed_vtbl; > + > + /* Calculate the number of symbols, and allocate space for them. */ > + for (list_counter = symbol_list; > + list_counter != NULL; > + list_counter = list_counter->next) > + { > + nsyms += list_counter->nsyms; > + } > + nbuckets = DICT_HASHTABLE_SIZE (nsyms); > + DICT_HASHED_NBUCKETS (retval) = nbuckets; > + buckets = obstack_alloc (obstack, nbuckets * sizeof (struct symbol *)); > + memset (buckets, 0, nbuckets * sizeof (struct symbol *)); > + DICT_HASHED_BUCKETS (retval) = buckets; > + > + /* Now fill the buckets. */ > + for (list_counter = symbol_list; > + list_counter != NULL; > + list_counter = list_counter->next) > + { > + for (i = list_counter->nsyms - 1; i >= 0; --i) > + { > + insert_symbol_hashed (retval, list_counter->symbol[i]); > + } > + } > + > + return retval; > +} > + > +/* Create a dictionary 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. */ > + > +extern struct dictionary * > +dict_create_hashed_expandable (void) > +{ > + struct dictionary *retval; > + > + retval = xmalloc (sizeof (struct dictionary)); > + DICT_VTBL (retval) = &dict_hashed_expandable_vtbl; > + DICT_HASHED_NBUCKETS (retval) = DICT_EXPANDABLE_INITIAL_CAPACITY; > + DICT_HASHED_BUCKETS (retval) = xcalloc (DICT_EXPANDABLE_INITIAL_CAPACITY, > + sizeof (struct symbol *)); > + DICT_HASHED_EXPANDABLE_NSYMS (retval) = 0; > + > + return retval; > +} > + > +/* Create a dictionary 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. */ > + > +struct dictionary * > +dict_create_linear (struct obstack *obstack, > + const struct pending *symbol_list) > +{ > + struct dictionary *retval; > + int nsyms = 0, i, j; > + struct symbol **syms; > + const struct pending *list_counter; > + > + retval = obstack_alloc (obstack, sizeof (struct dictionary)); > + DICT_VTBL (retval) = &dict_linear_vtbl; > + > + /* Calculate the number of symbols, and allocate space for them. */ > + for (list_counter = symbol_list; > + list_counter != NULL; > + list_counter = list_counter->next) > + { > + nsyms += list_counter->nsyms; > + } > + DICT_LINEAR_NSYMS (retval) = nsyms; > + syms = obstack_alloc (obstack, nsyms * sizeof (struct symbol *)); > + DICT_LINEAR_SYMS (retval) = syms; > + > + /* Now fill in the symbols. Start filling in from the back, so as > + to preserve the original order of the symbols. */ > + for (list_counter = symbol_list, j = nsyms - 1; > + list_counter != NULL; > + list_counter = list_counter->next) > + { > + for (i = list_counter->nsyms - 1; > + i >= 0; > + --i, --j) > + { > + syms[j] = list_counter->symbol[i]; > + } > + } > + > + return retval; > +} > + > +/* Create a dictionary 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. */ > + > +struct dictionary * > +dict_create_linear_expandable (void) > +{ > + struct dictionary *retval; > + > + retval = xmalloc (sizeof (struct dictionary)); > + DICT_VTBL (retval) = &dict_linear_expandable_vtbl; > + DICT_LINEAR_NSYMS (retval) = 0; > + DICT_LINEAR_EXPANDABLE_CAPACITY (retval) > + = DICT_EXPANDABLE_INITIAL_CAPACITY; > + DICT_LINEAR_SYMS (retval) > + = xmalloc (DICT_LINEAR_EXPANDABLE_CAPACITY (retval) > + * sizeof (struct symbol *)); > + > + return retval; > +} > + > +/* The functions providing the dictionary interface. */ > + > +/* Free the memory used by a dictionary that's not on an obstack. (If > + any.) */ > + > +void > +dict_free (struct dictionary *dict) > +{ > + (DICT_VTBL (dict))->free (dict); > +} > + > +/* Add SYM to DICT. DICT had better be expandable. */ > + > +void > +dict_add_symbol (struct dictionary *dict, struct symbol *sym) > +{ > + (DICT_VTBL (dict))->add_symbol (dict, sym); > +} > + > +/* Initialize ITERATOR to point at the first symbol in DICT, and > + return that first symbol, or NULL if DICT is empty. */ > + > +struct symbol * > +dict_iterator_first (const struct dictionary *dict, > + struct dict_iterator *iterator) > +{ > + return (DICT_VTBL (dict))->iterator_first (dict, iterator); > +} > + > +/* Advance ITERATOR, and return the next symbol, or NULL if there are > + no more symbols. */ > + > +struct symbol * > +dict_iterator_next (struct dict_iterator *iterator) > +{ > + return (DICT_VTBL (DICT_ITERATOR_DICT (iterator))) > + ->iterator_next (iterator); > +} > + > +struct symbol * > +dict_iter_name_first (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator) > +{ > + return (DICT_VTBL (dict))->iter_name_first (dict, name, iterator); > +} > + > +struct symbol * > +dict_iter_name_next (const char *name, struct dict_iterator *iterator) > +{ > + return (DICT_VTBL (DICT_ITERATOR_DICT (iterator))) > + ->iter_name_next (name, iterator); > +} > + > +/* Now come functions (well, one function, currently) that are > + implemented generically by means of the vtable. Typically, they're > + rarely used. */ > + > +/* Test to see if DICT is empty. */ > + > +int > +dict_empty (struct dictionary *dict) > +{ > + struct dict_iterator iter; > + > + return (dict_iterator_first (dict, &iter) == NULL); > +} > + > + > +/* The functions implementing the dictionary interface. */ > + > +/* Generic functions, where appropriate. */ > + > +static void > +free_obstack (struct dictionary *dict) > +{ > + /* Do nothing! */ > +} > + > +static void > +add_symbol_nonexpandable (struct dictionary *dict, struct symbol *sym) > +{ > + internal_error (__FILE__, __LINE__, > + "dict_add_symbol: non-expandable dictionary"); > +} > + > +/* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE. */ > + > +static struct symbol * > +iterator_first_hashed (const struct dictionary *dict, > + struct dict_iterator *iterator) > +{ > + DICT_ITERATOR_DICT (iterator) = dict; > + DICT_ITERATOR_INDEX (iterator) = -1; > + return iterator_hashed_advance (iterator); > +} > + > +static struct symbol * > +iterator_next_hashed (struct dict_iterator *iterator) > +{ > + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); > + struct symbol *next; > + > + next = DICT_ITERATOR_CURRENT (iterator)->hash_next; > + > + if (next == NULL) > + return iterator_hashed_advance (iterator); > + else > + { > + DICT_ITERATOR_CURRENT (iterator) = next; > + return next; > + } > +} > + > +static struct symbol * > +iterator_hashed_advance (struct dict_iterator *iterator) > +{ > + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); > + int nbuckets = DICT_HASHED_NBUCKETS (dict); > + int i; > + > + for (i = DICT_ITERATOR_INDEX (iterator) + 1; i < nbuckets; ++i) > + { > + struct symbol *sym = DICT_HASHED_BUCKET (dict, i); > + > + if (sym != NULL) > + { > + DICT_ITERATOR_INDEX (iterator) = i; > + DICT_ITERATOR_CURRENT (iterator) = sym; > + return sym; > + } > + } > + > + return NULL; > +} > + > +static struct symbol * > +iter_name_first_hashed (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator) > +{ > + unsigned int hash_index > + = msymbol_hash_iw (name) % DICT_HASHED_NBUCKETS (dict); > + struct symbol *sym; > + > + DICT_ITERATOR_DICT (iterator) = dict; > + > + /* Loop through the symbols in the given bucket, breaking when SYM > + first matches. If SYM never matches, it will be set to NULL; > + either way, we have the right return value. */ > + > + for (sym = DICT_HASHED_BUCKET (dict, hash_index); > + sym != NULL; > + sym = sym->hash_next) > + { > + /* Warning: the order of arguments to strcmp_iw matters! */ > + if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0) > + { > + break; > + } > + > + } > + > + DICT_ITERATOR_CURRENT (iterator) = sym; > + return sym; > +} > + > +static struct symbol * > +iter_name_next_hashed (const char *name, struct dict_iterator *iterator) > +{ > + struct symbol *next; > + > + for (next = DICT_ITERATOR_CURRENT (iterator)->hash_next; > + next != NULL; > + next = next->hash_next) > + { > + if (strcmp_iw (SYMBOL_NATURAL_NAME (next), name) == 0) > + break; > + } > + > + DICT_ITERATOR_CURRENT (iterator) = next; > + > + return next; > +} > + > +/* Insert SYM into DICT. */ > + > +static void > +insert_symbol_hashed (struct dictionary *dict, > + struct symbol *sym) > +{ > + unsigned int hash_index; > + struct symbol **buckets = DICT_HASHED_BUCKETS (dict); > + > + hash_index = (msymbol_hash_iw (SYMBOL_NATURAL_NAME (sym)) > + % DICT_HASHED_NBUCKETS (dict)); > + sym->hash_next = buckets[hash_index]; > + buckets[hash_index] = sym; > +} > + > +/* Functions only for DICT_HASHED_EXPANDABLE. */ > + > +static void > +free_hashed_expandable (struct dictionary *dict) > +{ > + xfree (DICT_HASHED_BUCKETS (dict)); > + xfree (dict); > +} > + > +static void > +add_symbol_hashed_expandable (struct dictionary *dict, > + struct symbol *sym) > +{ > + int nsyms = ++DICT_HASHED_EXPANDABLE_NSYMS (dict); > + > + if (DICT_HASHTABLE_SIZE (nsyms) > DICT_HASHED_NBUCKETS (dict)) > + expand_hashtable (dict); > + > + insert_symbol_hashed (dict, sym); > + DICT_HASHED_EXPANDABLE_NSYMS (dict) = nsyms; > +} > + > +static void > +expand_hashtable (struct dictionary *dict) > +{ > + int old_nbuckets = DICT_HASHED_NBUCKETS (dict); > + struct symbol **old_buckets = DICT_HASHED_BUCKETS (dict); > + int new_nbuckets = 2*old_nbuckets + 1; > + struct symbol **new_buckets = xcalloc (new_nbuckets, > + sizeof (struct symbol *)); > + int i; > + > + DICT_HASHED_NBUCKETS (dict) = new_nbuckets; > + DICT_HASHED_BUCKETS (dict) = new_buckets; > + > + for (i = 0; i < old_nbuckets; ++i) { > + struct symbol *sym, *next_sym; > + > + sym = old_buckets[i]; > + if (sym != NULL) { > + for (next_sym = sym->hash_next; > + next_sym != NULL; > + next_sym = sym->hash_next) { > + insert_symbol_hashed (dict, sym); > + sym = next_sym; > + } > + > + insert_symbol_hashed (dict, sym); > + } > + } > + > + xfree (old_buckets); > +} > + > +/* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE. */ > + > +static struct symbol * > +iterator_first_linear (const struct dictionary *dict, > + struct dict_iterator *iterator) > +{ > + DICT_ITERATOR_DICT (iterator) = dict; > + DICT_ITERATOR_INDEX (iterator) = 0; > + return DICT_LINEAR_NSYMS (dict) ? DICT_LINEAR_SYM (dict, 0) : NULL; > +} > + > +static struct symbol * > +iterator_next_linear (struct dict_iterator *iterator) > +{ > + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); > + > + if (++DICT_ITERATOR_INDEX (iterator) >= DICT_LINEAR_NSYMS (dict)) > + return NULL; > + else > + return DICT_LINEAR_SYM (dict, DICT_ITERATOR_INDEX (iterator)); > +} > + > +static struct symbol * > +iter_name_first_linear (const struct dictionary *dict, > + const char *name, > + struct dict_iterator *iterator) > +{ > + DICT_ITERATOR_DICT (iterator) = dict; > + DICT_ITERATOR_INDEX (iterator) = -1; > + > + return iter_name_next_linear (name, iterator); > +} > + > +static struct symbol * > +iter_name_next_linear (const char *name, struct dict_iterator *iterator) > +{ > + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); > + int i, nsyms = DICT_LINEAR_NSYMS (dict); > + struct symbol *sym, *retval = NULL; > + > + for (i = DICT_ITERATOR_INDEX (iterator) + 1; i < nsyms; ++i) > + { > + sym = DICT_LINEAR_SYM (dict, i); > + if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0) > + { > + retval = sym; > + break; > + } > + } > + > + DICT_ITERATOR_INDEX (iterator) = i; > + > + return retval; > +} > + > +/* Functions only for DICT_LINEAR_EXPANDABLE. */ > + > +static void > +free_linear_expandable (struct dictionary *dict) > +{ > + xfree (DICT_LINEAR_SYMS (dict)); > + xfree (dict); > +} > + > + > +static void > +add_symbol_linear_expandable (struct dictionary *dict, > + struct symbol *sym) > +{ > + int nsyms = ++DICT_LINEAR_NSYMS (dict); > + > + /* Do we have enough room? If not, grow it. */ > + if (nsyms > DICT_LINEAR_EXPANDABLE_CAPACITY (dict)) { > + DICT_LINEAR_EXPANDABLE_CAPACITY (dict) *= 2; > + DICT_LINEAR_SYMS (dict) > + = xrealloc (DICT_LINEAR_SYMS (dict), > + DICT_LINEAR_EXPANDABLE_CAPACITY (dict) > + * sizeof (struct symbol *)); > + } > + > + DICT_LINEAR_SYM (dict, nsyms - 1) = sym; > +} > Index: Makefile.in > =================================================================== > RCS file: /cvs/src/src/gdb/Makefile.in,v > retrieving revision 1.366 > diff -u -p -r1.366 Makefile.in > --- Makefile.in 25 Apr 2003 03:30:16 -0000 1.366 > +++ Makefile.in 30 Apr 2003 22:45:30 -0000 > @@ -513,7 +513,7 @@ SFILES = ada-exp.y ada-lang.c ada-typepr > charset.c cli-out.c coffread.c coff-pe-read.c \ > complaints.c completer.c corefile.c \ > cp-abi.c cp-support.c cp-namespace.c cp-valprint.c \ > - dbxread.c demangle.c disasm.c doublest.c \ > + dbxread.c demangle.c dictionary.c disasm.c doublest.c \ > dummy-frame.c dwarfread.c dwarf2expr.c dwarf2loc.c dwarf2read.c \ > elfread.c environ.c eval.c event-loop.c event-top.c expprint.c \ > f-exp.y f-lang.c f-typeprint.c f-valprint.c findvar.c frame.c \ > @@ -631,6 +631,7 @@ dcache_h = dcache.h > defs_h = defs.h $(config_h) $(gdb_locale_h) $(gdb_signals_h) $(ansidecl_h) \ > $(libiberty_h) $(progress_h) $(bfd_h) $(tui_h) $(ui_file_h) $(xm_h) \ > $(nm_h) $(tm_h) $(fopen_same_h) $(gdbarch_h) $(arch_utils_h) > +dictionary_h = dictionary.h > disasm_h = disasm.h > doublest_h = doublest.h $(floatformat_h) > dst_h = dst.h > @@ -837,7 +838,7 @@ TAGFILES_WITH_SRCDIR = $(HFILES_WITH_SRC > COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \ > charset.o disasm.o dummy-frame.o \ > source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \ > - block.o symtab.o symfile.o symmisc.o linespec.o \ > + block.o symtab.o symfile.o symmisc.o linespec.o dictionary.o \ > infcall.o \ > infcmd.o infrun.o \ > expprint.o environ.o stack.o thread.o \ > @@ -1494,7 +1495,7 @@ ada-lang.o: ada-lang.c $(gdb_string_h) $ > $(gdbtypes_h) $(gdbcmd_h) $(expression_h) $(parser_defs_h) \ > $(language_h) $(c_lang_h) $(inferior_h) $(symfile_h) $(objfiles_h) \ > $(breakpoint_h) $(gdbcore_h) $(ada_lang_h) $(ui_out_h) $(block_h) \ > - $(infcall_h) > + $(infcall_h) $(dictionary.h) dictionary_h > ada-tasks.o: ada-tasks.c $(defs_h) $(command_h) $(value_h) $(language_h) \ > $(inferior_h) $(symtab_h) $(target_h) $(gdbcore_h) $(gregset_h) \ > $(ada_lang_h) > @@ -1575,7 +1576,7 @@ buildsym.o: buildsym.c $(defs_h) $(bfd_h > $(symfile_h) $(objfiles_h) $(gdbtypes_h) $(gdb_assert_h) \ > $(complaints_h) $(gdb_string_h) $(expression_h) $(language_h) \ > $(bcache_h) $(filenames_h) $(macrotab_h) $(demangle_h) $(buildsym_h) \ > - $(stabsread_h) $(block_h) $(cp_support_h) > + $(stabsread_h) $(block_h) $(cp_support_h) $(dictionary_h) > builtin-regs.o: builtin-regs.c $(defs_h) $(builtin_regs_h) $(gdbtypes_h) \ > $(gdb_string_h) $(gdb_assert_h) > c-lang.o: c-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \ > @@ -1599,7 +1600,8 @@ coffread.o: coffread.c $(defs_h) $(symta > $(breakpoint_h) $(bfd_h) $(gdb_obstack_h) $(gdb_string_h) \ > $(coff_internal_h) $(libcoff_h) $(symfile_h) $(objfiles_h) \ > $(buildsym_h) $(gdb_stabs_h) $(stabsread_h) $(complaints_h) \ > - $(target_h) $(gdb_assert_h) $(block_h) $(coff_pe_read_h) > + $(target_h) $(gdb_assert_h) $(block_h) $(dictionary_h) \ > + $(coff_pe_read_h) > coff-pe-read.o: coff-pe-read.c $(bfd_h) $(defs_h) $(symtab_h) \ > $(gdbtypes_h) $(symfile_h) $(objfiles_h) $(coff_pe_read_h) > complaints.o: complaints.c $(defs_h) $(complaints_h) $(gdb_assert_h) \ > @@ -1653,6 +1655,8 @@ dcache.o: dcache.c $(defs_h) $(dcache_h) > delta68-nat.o: delta68-nat.c $(defs_h) > demangle.o: demangle.c $(defs_h) $(command_h) $(gdbcmd_h) $(demangle_h) \ > $(gdb_string_h) > +dictionary.o: dictionary.c $(defs_h) $(gdb_obstack_h) $(symtab_h) \ > + $(buildsym_h) $(gdb_assert_h) $(dictionary_h) > dink32-rom.o: dink32-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \ > $(serial_h) $(symfile_h) $(inferior_h) $(regcache_h) > disasm.o: disasm.c $(defs_h) $(gdb_string_h) $(target_h) $(value_h) \ > @@ -1869,7 +1873,7 @@ irix5-nat.o: irix5-nat.c $(defs_h) $(inf > jv-lang.o: jv-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \ > $(parser_defs_h) $(language_h) $(gdbtypes_h) $(symtab_h) \ > $(symfile_h) $(objfiles_h) $(gdb_string_h) $(value_h) $(c_lang_h) \ > - $(jv_lang_h) $(gdbcore_h) $(block_h) $(demangle_h) > + $(jv_lang_h) $(gdbcore_h) $(block_h) $(demangle_h) $(dictionary_h) > jv-typeprint.o: jv-typeprint.c $(defs_h) $(symtab_h) $(gdbtypes_h) \ > $(value_h) $(demangle_h) $(jv_lang_h) $(gdb_string_h) $(typeprint_h) \ > $(c_lang_h) $(cp_abi_h) > @@ -1949,7 +1953,7 @@ mcore-tdep.o: mcore-tdep.c $(defs_h) $(f > mdebugread.o: mdebugread.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \ > $(symfile_h) $(objfiles_h) $(gdb_obstack_h) $(buildsym_h) \ > $(stabsread_h) $(complaints_h) $(demangle_h) $(gdb_assert_h) \ > - $(block_h) \ > + $(block_h) $(dictionary_h) \ > $(coff_sym_h) $(coff_symconst_h) $(gdb_stat_h) $(gdb_string_h) \ > $(bfd_h) $(coff_ecoff_h) $(libaout_h) $(aout_aout64_h) \ > $(aout_stab_gnu_h) $(expression_h) $(language_h) > @@ -2010,7 +2014,7 @@ objc-lang.o: objc-lang.c $(defs_h) $(sym > objfiles.o: objfiles.c $(defs_h) $(bfd_h) $(symtab_h) $(symfile_h) \ > $(objfiles_h) $(gdb_stabs_h) $(target_h) $(bcache_h) $(gdb_stat_h) \ > $(gdb_obstack_h) $(gdb_string_h) $(breakpoint_h) $(mmalloc_h) \ > - $(block_h) > + $(block_h) $(dictionary_h) > observer.o: observer.c $(observer_h) $(defs_h) > ocd.o: ocd.c $(defs_h) $(gdbcore_h) $(gdb_string_h) $(frame_h) $(inferior_h) \ > $(bfd_h) $(symfile_h) $(target_h) $(gdbcmd_h) $(objfiles_h) \ > @@ -2061,7 +2065,7 @@ printcmd.o: printcmd.c $(defs_h) $(gdb_s > $(gdbtypes_h) $(value_h) $(language_h) $(expression_h) $(gdbcore_h) \ > $(gdbcmd_h) $(target_h) $(breakpoint_h) $(demangle_h) $(valprint_h) \ > $(annotate_h) $(symfile_h) $(objfiles_h) $(completer_h) $(ui_out_h) \ > - $(gdb_assert_h) $(block_h) > + $(gdb_assert_h) $(block_h) $(dictionary_h) > proc-api.o: proc-api.c $(defs_h) $(gdbcmd_h) $(completer_h) $(gdb_wait_h) \ > $(proc_utils_h) > proc-events.o: proc-events.c $(defs_h) > @@ -2248,7 +2252,7 @@ stabsread.o: stabsread.c $(defs_h) $(gdb > stack.o: stack.c $(defs_h) $(gdb_string_h) $(value_h) $(symtab_h) \ > $(gdbtypes_h) $(expression_h) $(language_h) $(frame_h) $(gdbcmd_h) \ > $(gdbcore_h) $(target_h) $(breakpoint_h) $(demangle_h) $(inferior_h) \ > - $(annotate_h) $(ui_out_h) $(source_h) $(block_h) > + $(annotate_h) $(ui_out_h) $(source_h) $(block_h) $(dictionary_h) > standalone.o: standalone.c $(gdb_stat_h) $(defs_h) $(symtab_h) $(frame_h) \ > $(inferior_h) $(gdb_wait_h) > std-regs.o: std-regs.c $(defs_h) $(builtin_regs_h) $(frame_h) $(gdbtypes_h) \ > @@ -2269,13 +2273,13 @@ symm-tdep.o: symm-tdep.c $(defs_h) $(fra > symmisc.o: symmisc.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(bfd_h) \ > $(symfile_h) $(objfiles_h) $(breakpoint_h) $(command_h) \ > $(gdb_obstack_h) $(language_h) $(bcache_h) $(gdb_string_h) \ > - $(readline_h) $(block_h) $(gdb_regex_h) > + $(readline_h) $(block_h) $(gdb_regex_h) $(dictionary_h) > symtab.o: symtab.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \ > $(frame_h) $(target_h) $(value_h) $(symfile_h) $(objfiles_h) \ > $(gdbcmd_h) $(call_cmds_h) $(gdb_regex_h) $(expression_h) \ > $(language_h) $(demangle_h) $(inferior_h) $(linespec_h) \ > $(filenames_h) $(gdb_obstack_h) $(gdb_string_h) $(gdb_stat_h) \ > - $(cp_abi_h) $(source_h) $(block_h) > + $(cp_abi_h) $(source_h) $(block_h) $(dictionary_h) > target.o: target.c $(defs_h) $(gdb_string_h) $(target_h) $(gdbcmd_h) \ > $(symtab_h) $(inferior_h) $(bfd_h) $(symfile_h) $(objfiles_h) \ > $(gdb_wait_h) $(dcache_h) $(regcache_h) > @@ -2296,7 +2300,7 @@ tracepoint.o: tracepoint.c $(defs_h) $(s > $(expression_h) $(gdbcmd_h) $(value_h) $(target_h) $(language_h) \ > $(gdb_string_h) $(inferior_h) $(tracepoint_h) $(remote_h) \ > $(linespec_h) $(regcache_h) $(completer_h) $(gdb_events_h) \ > - $(block_h) $(ax_h) $(ax_gdb_h) $(readline_h) > + $(block_h) $(dictionary_h) $(ax_h) $(ax_gdb_h) $(readline_h) > typeprint.o: typeprint.c $(defs_h) $(gdb_obstack_h) $(bfd_h) $(symtab_h) \ > $(gdbtypes_h) $(expression_h) $(value_h) $(gdbcore_h) $(command_h) \ > $(gdbcmd_h) $(target_h) $(language_h) $(cp_abi_h) $(gdb_string_h) > @@ -2321,7 +2325,7 @@ valarith.o: valarith.c $(defs_h) $(value > valops.o: valops.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(value_h) $(frame_h) \ > $(inferior_h) $(gdbcore_h) $(target_h) $(demangle_h) $(language_h) \ > $(gdbcmd_h) $(regcache_h) $(cp_abi_h) $(gdb_string_h) \ > - $(gdb_assert_h) $(block_h) > + $(gdb_assert_h) $(block_h) $(dictionary_h) > valprint.o: valprint.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \ > $(value_h) $(gdbcore_h) $(gdbcmd_h) $(target_h) $(language_h) \ > $(annotate_h) $(valprint_h) $(floatformat_h) $(doublest_h) > @@ -2488,9 +2492,10 @@ gdbtk-bp.o: $(srcdir)/gdbtk/generic/gdbt > > gdbtk-cmds.o: $(srcdir)/gdbtk/generic/gdbtk-cmds.c \ > $(srcdir)/gdbtk/generic/gdbtk.h $(srcdir)/gdbtk/generic/gdbtk-cmds.h \ > - $(defs_h) $(symtab_h) $(inferior_h) \ > - $(command_h) $(bfd_h) $(top_h) $(symfile_h) $(objfiles_h) $(target_h) \ > - $(gdb_string_h) $(tracepoint_h) $(source_h) $(regcache_h) > + $(defs_h) $(inferior_h) $(source_h) $(symfile_h) $(objfiles_h) \ > + $(gdbcore_h) $(demangle_h) $(linespec_h) $(tui_file_h) $(top_h) \ > + $(annotate_h) $(block_h) $(dictionary_h) $(gdb_string_h) \ > + $(dis_asm_h) $(gdbcmd_h) > $(CC) -c $(INTERNAL_CFLAGS) $(IDE_CFLAGS) $(ITCL_CFLAGS) \ > $(TCL_CFLAGS) $(TK_CFLAGS) $(X11_CFLAGS) \ > $(GDBTK_CFLAGS) $(srcdir)/gdbtk/generic/gdbtk-cmds.c \ > @@ -2531,8 +2536,8 @@ gdbtk-register.o: $(srcdir)/gdbtk/generi > gdbtk-stack.o: $(srcdir)/gdbtk/generic/gdbtk-stack.c \ > $(srcdir)/gdbtk/generic/gdbtk.h $(srcdir)/gdbtk/generic/gdbtk-cmds.h \ > $(srcdir)/gdbtk/generic/gdbtk-wrapper.h \ > - $(defs_h) $(frame_h) $(value_h) $(target_h) $(breakpoint_h) \ > - $(linespec_h) > + $(defs_h) $(target_h) $(breakpoint_h) $(linespec_h) \ > + $(block_h) $(dictionary_h) > $(CC) -c $(INTERNAL_CFLAGS) $(IDE_CFLAGS) $(ITCL_CFLAGS) \ > $(TCL_CFLAGS) $(TK_CFLAGS) $(X11_CFLAGS) \ > $(GDBTK_CFLAGS) $(srcdir)/gdbtk/generic/gdbtk-stack.c \ > @@ -2573,7 +2578,8 @@ mi-cmd-env.o: $(srcdir)/mi/mi-cmd-env.c > $(environ_h) $(command_h) $(ui_out_h) $(top_h) $(gdb_string_h) > $(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-env.c > mi-cmd-stack.o: $(srcdir)/mi/mi-cmd-stack.c $(defs_h) $(target_h) $(frame_h) \ > - $(value_h) $(mi_cmds_h) $(ui_out_h) $(symtab_h) $(block_h) > + $(value_h) $(mi_cmds_h) $(ui_out_h) $(symtab_h) $(block_h) \ > + $(dictionary_h) > $(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-stack.c > mi-cmd-var.o: $(srcdir)/mi/mi-cmd-var.c $(defs_h) $(mi_cmds_h) $(ui_out_h) \ > $(mi_out_h) $(varobj_h) $(value_h) $(gdb_string_h) > Index: ada-lang.c > =================================================================== > RCS file: /cvs/src/src/gdb/ada-lang.c,v > retrieving revision 1.24 > diff -u -p -r1.24 ada-lang.c > --- ada-lang.c 21 Apr 2003 16:48:37 -0000 1.24 > +++ ada-lang.c 30 Apr 2003 22:45:38 -0000 > @@ -40,6 +40,7 @@ Foundation, Inc., 675 Mass Ave, Cambridg > #include "ui-out.h" > #include "block.h" > #include "infcall.h" > +#include "dictionary.h" > > struct cleanup *unresolved_names; > > @@ -3434,7 +3435,8 @@ symtab_for_sym (struct symbol *sym) > struct objfile *objfile; > struct block *b; > struct symbol *tmp_sym; > - int i, j; > + struct dict_iterator iter; > + int j; > > ALL_SYMTABS (objfile, s) > { > @@ -3448,10 +3450,10 @@ symtab_for_sym (struct symbol *sym) > case LOC_BLOCK: > case LOC_CONST_BYTES: > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) > + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) > return s; > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) > + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) > return s; > break; > default: > @@ -3475,7 +3477,7 @@ symtab_for_sym (struct symbol *sym) > j < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s)); j += 1) > { > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), j); > - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) > + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) > return s; > } > break; > @@ -3948,13 +3950,12 @@ ada_add_block_symbols (struct block *blo > namespace_enum namespace, struct objfile *objfile, > int wild) > { > - int i; > + struct dict_iterator iter; > int name_len = strlen (name); > /* A matching argument symbol, if any. */ > struct symbol *arg_sym; > /* Set true when we find a matching non-argument symbol */ > int found_sym; > - int is_sorted = BLOCK_SHOULD_SORT (block); > struct symbol *sym; > > arg_sym = NULL; > @@ -3962,7 +3963,7 @@ ada_add_block_symbols (struct block *blo > if (wild) > { > struct symbol *sym; > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > if (SYMBOL_NAMESPACE (sym) == namespace && > wild_match (name, name_len, DEPRECATED_SYMBOL_NAME (sym))) > @@ -3991,45 +3992,15 @@ ada_add_block_symbols (struct block *blo > } > else > { > - if (is_sorted) > - { > - int U; > - i = 0; > - U = BLOCK_NSYMS (block) - 1; > - while (U - i > 4) > - { > - int M = (U + i) >> 1; > - struct symbol *sym = BLOCK_SYM (block, M); > - if (DEPRECATED_SYMBOL_NAME (sym)[0] < name[0]) > - i = M + 1; > - else if (DEPRECATED_SYMBOL_NAME (sym)[0] > name[0]) > - U = M - 1; > - else if (strcmp (DEPRECATED_SYMBOL_NAME (sym), name) < 0) > - i = M + 1; > - else > - U = M; > - } > - } > - else > - i = 0; > - > - for (; i < BLOCK_BUCKETS (block); i += 1) > - for (sym = BLOCK_BUCKET (block, i); sym != NULL; sym = sym->hash_next) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > if (SYMBOL_NAMESPACE (sym) == namespace) > { > int cmp = strncmp (name, DEPRECATED_SYMBOL_NAME (sym), name_len); > > - if (cmp < 0) > - { > - if (is_sorted) > - { > - i = BLOCK_BUCKETS (block); > - break; > - } > - } > - else if (cmp == 0 > - && is_name_suffix (DEPRECATED_SYMBOL_NAME (sym) + name_len)) > + > + if (cmp == 0 > + && is_name_suffix (DEPRECATED_SYMBOL_NAME (sym) + name_len)) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -4066,33 +4037,9 @@ ada_add_block_symbols (struct block *blo > { > arg_sym = NULL; > found_sym = 0; > - if (is_sorted) > - { > - int U; > - i = 0; > - U = BLOCK_NSYMS (block) - 1; > - while (U - i > 4) > - { > - int M = (U + i) >> 1; > - struct symbol *sym = BLOCK_SYM (block, M); > - if (DEPRECATED_SYMBOL_NAME (sym)[0] < '_') > - i = M + 1; > - else if (DEPRECATED_SYMBOL_NAME (sym)[0] > '_') > - U = M - 1; > - else if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "_ada_") < 0) > - i = M + 1; > - else > - U = M; > - } > - } > - else > - i = 0; > > - for (; i < BLOCK_BUCKETS (block); i += 1) > - for (sym = BLOCK_BUCKET (block, i); sym != NULL; sym = sym->hash_next) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > - struct symbol *sym = BLOCK_SYM (block, i); > - > if (SYMBOL_NAMESPACE (sym) == namespace) > { > int cmp; > @@ -4105,16 +4052,8 @@ ada_add_block_symbols (struct block *blo > cmp = strncmp (name, DEPRECATED_SYMBOL_NAME (sym) + 5, name_len); > } > > - if (cmp < 0) > - { > - if (is_sorted) > - { > - i = BLOCK_BUCKETS (block); > - break; > - } > - } > - else if (cmp == 0 > - && is_name_suffix (DEPRECATED_SYMBOL_NAME (sym) + name_len + 5)) > + if (cmp == 0 > + && is_name_suffix (DEPRECATED_SYMBOL_NAME (sym) + name_len + 5)) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -4161,7 +4100,7 @@ fill_in_ada_prototype (struct symbol *fu > { > struct block *b; > int nargs, nsyms; > - int i; > + struct dict_iterator iter; > struct type *ftype; > struct type *rtype; > size_t max_fields; > @@ -4187,7 +4126,7 @@ fill_in_ada_prototype (struct symbol *fu > max_fields = 8; > TYPE_FIELDS (ftype) = > (struct field *) xmalloc (sizeof (struct field) * max_fields); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > GROW_VECT (TYPE_FIELDS (ftype), max_fields, nargs + 1); > > @@ -4760,8 +4699,8 @@ debug_print_lines (struct linetable *lt) > static void > debug_print_block (struct block *b) > { > - int i; > - struct symbol *i; > + struct dict_iterator iter; > + struct symbol *sym; > > fprintf (stderr, "Block: %p; [0x%lx, 0x%lx]", > b, BLOCK_START (b), BLOCK_END (b)); > @@ -4770,10 +4709,8 @@ debug_print_block (struct block *b) > fprintf (stderr, "\n"); > fprintf (stderr, "\t Superblock: %p\n", BLOCK_SUPERBLOCK (b)); > fprintf (stderr, "\t Symbols:"); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > - if (i > 0 && i % 4 == 0) > - fprintf (stderr, "\n\t\t "); > fprintf (stderr, " %s", DEPRECATED_SYMBOL_NAME (sym)); > } > fprintf (stderr, "\n"); > Index: block.h > =================================================================== > RCS file: /cvs/src/src/gdb/block.h,v > retrieving revision 1.3 > diff -u -p -r1.3 block.h > --- block.h 15 Apr 2003 23:07:11 -0000 1.3 > +++ block.h 30 Apr 2003 22:45:38 -0000 > @@ -29,6 +29,7 @@ struct symtab; > struct block_namespace_info; > struct using_direct; > struct obstack; > +struct dictionary; > > /* All of the name-scope contours of the program > are represented by `struct block' objects. > @@ -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 > @@ -104,34 +109,6 @@ struct block > 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; > - > - /* Number of local symbols. */ > - > - int nsyms; > - > - /* The symbols. If some of them are arguments, then they must be > - in the order in which we would like to print them. */ > - > - struct symbol *sym[1]; > }; > > #define BLOCK_START(bl) (bl)->startaddr > @@ -139,36 +116,15 @@ struct block > #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. */ > +/* 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 BLOCK_SHOULD_SORT(bl) (! BLOCK_HASHTABLE (bl) \ > - && BLOCK_FUNCTION (bl) == NULL) > +#define ALL_BLOCK_SYMBOLS(block, iter, sym) \ > + ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym) > > struct blockvector > { > Index: buildsym.c > =================================================================== > RCS file: /cvs/src/src/gdb/buildsym.c,v > retrieving revision 1.32 > diff -u -p -r1.32 buildsym.c > --- buildsym.c 15 Apr 2003 23:07:11 -0000 1.32 > +++ buildsym.c 30 Apr 2003 22:45:39 -0000 > @@ -45,6 +45,7 @@ > #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ > #include "block.h" > #include "cp-support.h" > +#include "dictionary.h" > > /* Ask buildsym.h to define the vars it normally declares `extern'. */ > #define EXTERN > @@ -229,62 +230,22 @@ finish_block (struct symbol *symbol, str > register struct block *block; > register struct pending_block *pblock; > struct pending_block *opblock; > - register int i; > - register int j; > - > - /* Count the length of the list of symbols. */ > - > - for (next = *listhead, i = 0; > - next; > - i += next->nsyms, next = next->next) > - { > - /* EMPTY */ ; > - } > > - /* Copy the symbols into the block. */ > + /* Initialize the block's dictionary. */ > > if (symbol) > { > block = (struct block *) > - obstack_alloc (&objfile->symbol_obstack, > - (sizeof (struct block) + > - ((i - 1) * sizeof (struct symbol *)))); > - BLOCK_NSYMS (block) = i; > - for (next = *listhead; next; next = next->next) > - for (j = next->nsyms - 1; j >= 0; j--) > - { > - BLOCK_SYM (block, --i) = next->symbol[j]; > - } > + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); > + BLOCK_DICT (block) = dict_create_linear (&objfile->symbol_obstack, > + *listhead); > } > else > { > - int htab_size = BLOCK_HASHTABLE_SIZE (i); > - > block = (struct block *) > - obstack_alloc (&objfile->symbol_obstack, > - (sizeof (struct block) + > - ((htab_size - 1) * sizeof (struct symbol *)))); > - for (j = 0; j < htab_size; j++) > - { > - BLOCK_BUCKET (block, j) = 0; > - } > - BLOCK_BUCKETS (block) = htab_size; > - for (next = *listhead; next; next = next->next) > - { > - for (j = next->nsyms - 1; j >= 0; j--) > - { > - struct symbol *sym; > - unsigned int hash_index; > - const char *name = SYMBOL_DEMANGLED_NAME (next->symbol[j]); > - if (name == NULL) > - name = DEPRECATED_SYMBOL_NAME (next->symbol[j]); > - hash_index = msymbol_hash_iw (name); > - hash_index = hash_index % BLOCK_BUCKETS (block); > - sym = BLOCK_BUCKET (block, hash_index); > - BLOCK_BUCKET (block, hash_index) = next->symbol[j]; > - next->symbol[j]->hash_next = sym; > - } > - } > + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); > + BLOCK_DICT (block) = dict_create_hashed (&objfile->symbol_obstack, > + *listhead); > } > > BLOCK_START (block) = start; > @@ -300,9 +261,9 @@ finish_block (struct symbol *symbol, str > if (symbol) > { > struct type *ftype = SYMBOL_TYPE (symbol); > + struct dict_iterator iter; > SYMBOL_BLOCK_VALUE (symbol) = block; > BLOCK_FUNCTION (block) = symbol; > - BLOCK_HASHTABLE (block) = 0; > > if (TYPE_NFIELDS (ftype) <= 0) > { > @@ -311,7 +272,7 @@ finish_block (struct symbol *symbol, str > parameter symbols. */ > int nparams = 0, iparams; > struct symbol *sym; > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -348,9 +309,11 @@ finish_block (struct symbol *symbol, str > TYPE_FIELDS (ftype) = (struct field *) > TYPE_ALLOC (ftype, nparams * sizeof (struct field)); > > - for (i = iparams = 0; iparams < nparams; i++) > + for (sym = dict_iterator_first (BLOCK_DICT (block), &iter), > + iparams = 0; > + iparams < nparams; > + sym = dict_iterator_next (&iter)) could you use the macro ALL_BLOCK_SYMBOLS here? and move the check for iparams inside the loop body? > { > - sym = BLOCK_SYM (block, i); > switch (SYMBOL_CLASS (sym)) > { > case LOC_ARG: > @@ -394,7 +357,6 @@ finish_block (struct symbol *symbol, str > else > { > BLOCK_FUNCTION (block) = NULL; > - BLOCK_HASHTABLE (block) = 1; > } > > /* Now "free" the links of the list, and empty the list. */ > @@ -1031,7 +993,7 @@ end_symtab (CORE_ADDR end_addr, struct o > symtab->dirname = NULL; > } > symtab->free_code = free_linetable; > - symtab->free_ptr = NULL; > + symtab->free_func = NULL; > > /* Use whatever language we have been using for this > subfile, not the one that was deduced in allocate_symtab > Index: coffread.c > =================================================================== > RCS file: /cvs/src/src/gdb/coffread.c,v > retrieving revision 1.37 > diff -u -p -r1.37 coffread.c > --- coffread.c 25 Feb 2003 21:36:17 -0000 1.37 > +++ coffread.c 30 Apr 2003 22:45:42 -0000 > @@ -45,6 +45,7 @@ > #include "target.h" > #include "gdb_assert.h" > #include "block.h" > +#include "dictionary.h" > > #include "coff-pe-read.h" > > @@ -605,15 +606,6 @@ coff_symfile_read (struct objfile *objfi > > coff_symtab_read ((long) symtab_offset, num_symbols, objfile); > > - /* Sort symbols alphabetically within each block. */ > - > - { > - struct symtab *s; > - > - for (s = objfile->symtabs; s != NULL; s = s->next) > - sort_symtab_syms (s); > - } > - > /* Install any minimal symbols that have been collected as the current > minimal symbols for this objfile. */ > > @@ -1413,12 +1405,12 @@ static void > patch_opaque_types (struct symtab *s) > { > register struct block *b; > - register int i; > + struct dict_iterator iter; > register struct symbol *real_sym; > > /* Go through the per-file symbols only */ > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, real_sym) > + ALL_BLOCK_SYMBOLS (b, iter, real_sym) > { > /* Find completed typedefs to use to fix opaque ones. > Remove syms from the chain when their types are stored, > Index: dbxread.c > =================================================================== > RCS file: /cvs/src/src/gdb/dbxread.c,v > retrieving revision 1.45 > diff -u -p -r1.45 dbxread.c > --- dbxread.c 26 Feb 2003 21:41:18 -0000 1.45 > +++ dbxread.c 30 Apr 2003 22:45:46 -0000 > @@ -2484,7 +2484,6 @@ dbx_psymtab_to_symtab_1 (struct partial_ > /* Read in this file's symbols */ > bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET); > read_ofile_symtab (pst); > - sort_symtab_syms (pst->symtab); > > do_cleanups (old_chain); > } > Index: dwarf2read.c > =================================================================== > RCS file: /cvs/src/src/gdb/dwarf2read.c,v > retrieving revision 1.90 > diff -u -p -r1.90 dwarf2read.c > --- dwarf2read.c 15 Apr 2003 23:07:11 -0000 1.90 > +++ dwarf2read.c 30 Apr 2003 22:45:53 -0000 > @@ -1740,7 +1740,6 @@ psymtab_to_symtab_1 (struct partial_symt > } > pst->symtab = symtab; > pst->readin = 1; > - sort_symtab_syms (pst->symtab); > > do_cleanups (back_to); > } > Index: dwarfread.c > =================================================================== > RCS file: /cvs/src/src/gdb/dwarfread.c,v > retrieving revision 1.24 > diff -u -p -r1.24 dwarfread.c > --- dwarfread.c 25 Feb 2003 21:36:17 -0000 1.24 > +++ dwarfread.c 30 Apr 2003 22:45:57 -0000 > @@ -2338,7 +2338,6 @@ psymtab_to_symtab_1 (struct partial_symt > wrap_here (""); > gdb_flush (gdb_stdout); > } > - sort_symtab_syms (pst->symtab); > do_cleanups (old_chain); > } > pst->readin = 1; > Index: jv-lang.c > =================================================================== > RCS file: /cvs/src/src/gdb/jv-lang.c,v > retrieving revision 1.18 > diff -u -p -r1.18 jv-lang.c > --- jv-lang.c 15 Apr 2003 23:07:11 -0000 1.18 > +++ jv-lang.c 30 Apr 2003 22:45:58 -0000 > @@ -35,6 +35,7 @@ > #include "gdbcore.h" > #include "block.h" > #include "demangle.h" > +#include "dictionary.h" > #include <ctype.h> > > struct type *java_int_type; > @@ -91,9 +92,7 @@ get_dynamics_objfile (void) > > static struct symtab *class_symtab = NULL; > > -/* Maximum number of class in class_symtab before relocation is needed. */ > - > -static int class_symtab_space; > +static void free_class_block (struct symtab *symtab); > > static struct symtab * > get_java_class_symtab (void) > @@ -106,15 +105,16 @@ get_java_class_symtab (void) > class_symtab = allocate_symtab ("<java-classes>", objfile); > class_symtab->language = language_java; > bv = (struct blockvector *) > - obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector)); > + obstack_alloc (&objfile->symbol_obstack, > + sizeof (struct blockvector) + sizeof (struct block *)); > BLOCKVECTOR_NBLOCKS (bv) = 1; > BLOCKVECTOR (class_symtab) = bv; > > /* Allocate dummy STATIC_BLOCK. */ > bl = (struct block *) > obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); > - BLOCK_NSYMS (bl) = 0; > - BLOCK_HASHTABLE (bl) = 0; > + BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack, > + NULL); > BLOCK_START (bl) = 0; > BLOCK_END (bl) = 0; > BLOCK_FUNCTION (bl) = NULL; > @@ -124,13 +124,12 @@ get_java_class_symtab (void) > BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl; > > /* Allocate GLOBAL_BLOCK. This has to be relocatable. */ > - class_symtab_space = 128; > - bl = xmmalloc (objfile->md, > - sizeof (struct block) > - + ((class_symtab_space - 1) * sizeof (struct symbol *))); > + bl = (struct block *) > + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); > *bl = *BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); > + BLOCK_DICT (bl) = dict_create_hashed_expandable (); > BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl; > - class_symtab->free_ptr = (char *) bl; > + class_symtab->free_func = free_class_block; > } > return class_symtab; > } > @@ -140,20 +139,7 @@ add_class_symtab_symbol (struct symbol * > { > struct symtab *symtab = get_java_class_symtab (); > struct blockvector *bv = BLOCKVECTOR (symtab); > - struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); > - if (BLOCK_NSYMS (bl) >= class_symtab_space) > - { > - /* Need to re-allocate. */ > - class_symtab_space *= 2; > - bl = xmrealloc (symtab->objfile->md, bl, > - sizeof (struct block) > - + ((class_symtab_space - 1) * sizeof (struct symbol *))); > - class_symtab->free_ptr = (char *) bl; > - BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl; > - } > - > - BLOCK_SYM (bl, BLOCK_NSYMS (bl)) = sym; > - BLOCK_NSYMS (bl) = BLOCK_NSYMS (bl) + 1; > + dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym); > } > > static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr); > @@ -174,6 +160,16 @@ add_class_symbol (struct type *type, COR > SYMBOL_VALUE_ADDRESS (sym) = addr; > return sym; > } > + > +/* Free the dynamic symbols block. */ > +static void > +free_class_block (struct symtab *symtab) > +{ > + struct blockvector *bv = BLOCKVECTOR (symtab); > + struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); > + > + dict_free (BLOCK_DICT (bl)); > +} > #endif > > struct type * > @@ -268,7 +264,7 @@ type_from_class (struct value *clas) > char *nptr; > CORE_ADDR addr; > struct block *bl; > - int i; > + struct dict_iterator iter; > int is_array = 0; > > type = check_typedef (VALUE_TYPE (clas)); > @@ -283,9 +279,8 @@ type_from_class (struct value *clas) > #if 0 > get_java_class_symtab (); > bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK); > - for (i = BLOCK_NSYMS (bl); --i >= 0;) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > - struct symbol *sym = BLOCK_SYM (bl, i); > if (SYMBOL_VALUE_ADDRESS (sym) == addr) > return SYMBOL_TYPE (sym); > } > Index: mdebugread.c > =================================================================== > RCS file: /cvs/src/src/gdb/mdebugread.c,v > retrieving revision 1.44 > diff -u -p -r1.44 mdebugread.c > --- mdebugread.c 19 Mar 2003 19:45:49 -0000 1.44 > +++ mdebugread.c 30 Apr 2003 22:46:03 -0000 > @@ -54,6 +54,7 @@ > #include "demangle.h" > #include "gdb_assert.h" > #include "block.h" > +#include "dictionary.h" > > /* These are needed if the tm.h file does not contain the necessary > mips specific definitions. */ > @@ -284,9 +285,9 @@ static struct symbol *new_symbol (char * > > static struct type *new_type (char *); > > -static struct block *new_block (int); > +static struct block *new_block (int function); can this take an enum parameter with some meaningful names? > > -static struct symtab *new_symtab (char *, int, int, struct objfile *); > +static struct symtab *new_symtab (char *, int, struct objfile *); > > static struct linetable *new_linetable (int); > > @@ -298,8 +299,6 @@ static struct type *parse_type (int, uni > static struct symbol *mylookup_symbol (char *, struct block *, namespace_enum, > enum address_class); > > -static struct block *shrink_block (struct block *, struct symtab *); > - > static void sort_blocks (struct symtab *); > > static struct partial_symtab *new_psymtab (char *, struct objfile *); > @@ -483,7 +482,6 @@ static struct parse_stack > > int blocktype; > > - int maxsyms; /* Max symbols in this block. */ > struct type *cur_type; /* Type we parse fields for. */ > int cur_field; /* Field number in cur_type. */ > CORE_ADDR procadr; /* Start addres of this procedure */ > @@ -834,7 +832,7 @@ parse_symbol (SYMR *sh, union aux_ext *a > TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED; > > /* Create and enter a new lexical context */ > - b = new_block (top_stack->maxsyms); > + b = new_block (1); > SYMBOL_BLOCK_VALUE (s) = b; > BLOCK_FUNCTION (b) = s; > BLOCK_START (b) = BLOCK_END (b) = sh->value; > @@ -1169,7 +1167,7 @@ parse_symbol (SYMR *sh, union aux_ext *a > } > > top_stack->blocktype = stBlock; > - b = new_block (top_stack->maxsyms); > + b = new_block (0); > BLOCK_START (b) = sh->value + top_stack->procadr; > BLOCK_SUPERBLOCK (b) = top_stack->cur_block; > top_stack->cur_block = b; > @@ -1189,7 +1187,7 @@ parse_symbol (SYMR *sh, union aux_ext *a > /* Finished with procedure */ > struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); > struct mips_extra_func_info *e; > - struct block *b; > + struct block *b = top_stack->cur_block; > struct type *ftype = top_stack->cur_type; > int i; > > @@ -1209,9 +1207,6 @@ parse_symbol (SYMR *sh, union aux_ext *a > e->pdr.framereg = -1; > add_symbol (s, top_stack->cur_block); > > - /* Reallocate symbols, saving memory */ > - b = shrink_block (top_stack->cur_block, top_stack->cur_st); > - > /* f77 emits proc-level with address bounds==[0,0], > So look for such child blocks, and patch them. */ > for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) > @@ -1236,13 +1231,16 @@ parse_symbol (SYMR *sh, union aux_ext *a > > if (nparams > 0) > { > + struct dict_iterator iter; > TYPE_NFIELDS (ftype) = nparams; > TYPE_FIELDS (ftype) = (struct field *) > TYPE_ALLOC (ftype, nparams * sizeof (struct field)); > > - for (i = iparams = 0; iparams < nparams; i++) > + for (sym = dict_iterator_first (BLOCK_DICT (b), &iter), > + iparams = 0; > + iparams < nparams; > + sym = dict_iterator_next (&iter)) could you still use the macro here ALL_BLOCK_SYMBOLS and add an if (iparams == nparams) break; inside the loop? > { > - sym = BLOCK_SYM (b, i); > switch (SYMBOL_CLASS (sym)) > { > case LOC_ARG: > @@ -1266,7 +1264,6 @@ parse_symbol (SYMR *sh, union aux_ext *a > displacement from the procedure`s start address of the > end of this block. */ > BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr; > - shrink_block (top_stack->cur_block, top_stack->cur_st); > } > else if (sh->sc == scText && top_stack->blocktype == stNil) > { > @@ -4008,10 +4005,6 @@ psymtab_to_symtab_1 (struct partial_symt > end_stabs (); > } > > - /* Sort the symbol table now, we are done adding symbols to it. > - We must do this before parse_procedure calls lookup_symbol. */ > - sort_symtab_syms (st); > - > /* There used to be a call to sort_blocks here, but this should not > be necessary for stabs symtabs. And as sort_blocks modifies the > start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, > @@ -4065,19 +4058,15 @@ psymtab_to_symtab_1 (struct partial_symt > int maxlines; > EXTR *ext_ptr; > > - /* How many symbols will we need */ > - /* FIXME, this does not count enum values. */ > - f_max = pst->n_global_syms + pst->n_static_syms; > if (fh == 0) > { > maxlines = 0; > - st = new_symtab ("unknown", f_max, 0, pst->objfile); > + st = new_symtab ("unknown", 0, pst->objfile); > } > else > { > - f_max += fh->csym + fh->cpd; > maxlines = 2 * fh->cline; > - st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile); > + st = new_symtab (pst->filename, maxlines, pst->objfile); > > /* The proper language was already determined when building > the psymtab, use it. */ > @@ -4097,7 +4086,6 @@ psymtab_to_symtab_1 (struct partial_symt > BLOCK_START (top_stack->cur_block) = pst->textlow; > BLOCK_END (top_stack->cur_block) = 0; > top_stack->blocktype = stFile; > - top_stack->maxsyms = 2 * f_max; > top_stack->cur_type = 0; > top_stack->procadr = 0; > top_stack->numargs = 0; > @@ -4181,10 +4169,6 @@ psymtab_to_symtab_1 (struct partial_symt > top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), > GLOBAL_BLOCK); > top_stack->blocktype = stFile; > - top_stack->maxsyms > - = (debug_info->symbolic_header.isymMax > - + debug_info->symbolic_header.ipdMax > - + debug_info->symbolic_header.iextMax); > > ext_ptr = PST_PRIVATE (pst)->extern_tab; > for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++) > @@ -4206,9 +4190,6 @@ psymtab_to_symtab_1 (struct partial_symt > > st->primary = 1; > > - /* Sort the symbol table now, we are done adding symbols to it. */ > - sort_symtab_syms (st); > - > sort_blocks (st); > } > > @@ -4457,11 +4438,12 @@ static struct symbol * > mylookup_symbol (char *name, register struct block *block, > namespace_enum namespace, enum address_class class) > { > - int i, inc; > + struct dict_iterator iter; > + int inc; > struct symbol *sym; > > inc = name[0]; > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc > && SYMBOL_NAMESPACE (sym) == namespace > @@ -4477,41 +4459,12 @@ mylookup_symbol (char *name, register st > } > > > -/* Add a new symbol S to a block B. > - Infrequently, we will need to reallocate the block to make it bigger. > - We only detect this case when adding to top_stack->cur_block, since > - that's the only time we know how big the block is. FIXME. */ > +/* Add a new symbol S to a block B. */ > > static void > add_symbol (struct symbol *s, struct block *b) > { > - int nsyms = BLOCK_NSYMS (b)++; > - struct block *origb; > - struct parse_stack *stackp; > - > - if (b == top_stack->cur_block && > - nsyms >= top_stack->maxsyms) > - { > - complaint (&symfile_complaints, "block containing %s overfilled", > - DEPRECATED_SYMBOL_NAME (s)); > - /* In this case shrink_block is actually grow_block, since > - BLOCK_NSYMS(b) is larger than its current size. */ > - origb = b; > - b = shrink_block (top_stack->cur_block, top_stack->cur_st); > - > - /* Now run through the stack replacing pointers to the > - original block. shrink_block has already done this > - for the blockvector and BLOCK_FUNCTION. */ > - for (stackp = top_stack; stackp; stackp = stackp->next) > - { > - if (stackp->cur_block == origb) > - { > - stackp->cur_block = b; > - stackp->maxsyms = BLOCK_NSYMS (b); > - } > - } > - } > - BLOCK_SYM (b, nsyms) = s; > + dict_add_symbol (BLOCK_DICT (b), s); > } > > /* Add a new block B to a symtab S */ > @@ -4633,11 +4586,11 @@ sort_blocks (struct symtab *s) > > /* Constructor/restructor/destructor procedures */ > > -/* Allocate a new symtab for NAME. Needs an estimate of how many symbols > - MAXSYMS and linenumbers MAXLINES we'll put in it */ > +/* Allocate a new symtab for NAME. Needs an estimate of how many > + linenumbers MAXLINES we'll put in it */ > > static struct symtab * > -new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile) > +new_symtab (char *name, int maxlines, struct objfile *objfile) > { > struct symtab *s = allocate_symtab (name, objfile); > > @@ -4645,8 +4598,8 @@ new_symtab (char *name, int maxsyms, int > > /* All symtabs must have at least two blocks */ > BLOCKVECTOR (s) = new_bvect (2); > - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms); > - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms); > + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (0); > + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (0); > BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) = > BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); > > @@ -4730,48 +4683,22 @@ new_bvect (int nblocks) > return bv; > } > > -/* Allocate and zero a new block of MAXSYMS symbols */ > +/* Allocate and zero a new block, and set its BLOCK_DICT. 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. */ > > static struct block * > -new_block (int maxsyms) > +new_block (int function) > { > - int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *); > + struct block *retval = xzalloc (sizeof (struct block)); > > - return (struct block *) xzalloc (size); > -} > - > -/* Ooops, too big. Shrink block B in symtab S to its minimal size. > - Shrink_block can also be used by add_symbol to grow a block. */ > - > -static struct block * > -shrink_block (struct block *b, struct symtab *s) > -{ > - struct block *new; > - struct blockvector *bv = BLOCKVECTOR (s); > - int i; > - > - /* Just reallocate it and fix references to the old one */ > + if (function) > + BLOCK_DICT (retval) = dict_create_linear_expandable (); > + else > + BLOCK_DICT (retval) = dict_create_hashed_expandable (); > > - new = (struct block *) xrealloc ((void *) b, > - (sizeof (struct block) > - + ((BLOCK_NSYMS (b) - 1) > - * sizeof (struct symbol *)))); > - > - /* FIXME: Not worth hashing this block as it's built. */ > - /* All callers should have created the block with new_block (), which > - would mean it was not previously hashed. Make sure. */ > - gdb_assert (BLOCK_HASHTABLE (new) == 0); > - > - /* Should chase pointers to old one. Fortunately, that`s just > - the block`s function and inferior blocks */ > - if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b) > - SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new; > - for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) > - if (BLOCKVECTOR_BLOCK (bv, i) == b) > - BLOCKVECTOR_BLOCK (bv, i) = new; > - else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b) > - BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new; > - return new; > + return retval; > } > > /* Create a new symbol with printname NAME */ > @@ -4908,7 +4835,7 @@ fixup_sigtramp (void) > TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void; > > /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */ > - b = new_block (1); > + b = new_block (0); > SYMBOL_BLOCK_VALUE (s) = b; > BLOCK_START (b) = sigtramp_address; > BLOCK_END (b) = sigtramp_end; > @@ -4951,7 +4878,7 @@ fixup_sigtramp (void) > current_objfile = NULL; > } > > - BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s; > + dict_add_symbol (BLOCK_DICT (b), s); > } > > #endif /* TM_MIPS_H */ > Index: objfiles.c > =================================================================== > RCS file: /cvs/src/src/gdb/objfiles.c,v > retrieving revision 1.29 > diff -u -p -r1.29 objfiles.c > --- objfiles.c 25 Feb 2003 21:36:18 -0000 1.29 > +++ objfiles.c 30 Apr 2003 22:46:05 -0000 > @@ -43,6 +43,7 @@ > > #include "breakpoint.h" > #include "block.h" > +#include "dictionary.h" > > /* Prototypes for local functions */ > > @@ -656,13 +657,13 @@ objfile_relocate (struct objfile *objfil > { > struct block *b; > struct symbol *sym; > - int j; > + struct dict_iterator iter; > > b = BLOCKVECTOR_BLOCK (bv, i); > BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); > BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); > > - ALL_BLOCK_SYMBOLS (b, j, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > fixup_symbol_section (sym, objfile); > > Index: printcmd.c > =================================================================== > RCS file: /cvs/src/src/gdb/printcmd.c,v > retrieving revision 1.59 > diff -u -p -r1.59 printcmd.c > --- printcmd.c 1 Apr 2003 23:51:17 -0000 1.59 > +++ printcmd.c 30 Apr 2003 22:46:07 -0000 > @@ -42,6 +42,7 @@ > #include "ui-out.h" > #include "gdb_assert.h" > #include "block.h" > +#include "dictionary.h" > > extern int asm_demangle; /* Whether to demangle syms in asm printouts */ > extern int addressprint; /* Whether to print hex addresses in HLL " */ > @@ -1760,7 +1761,7 @@ print_frame_args (struct symbol *func, s > { > struct block *b = NULL; > int first = 1; > - register int i; > + struct dict_iterator iter; > register struct symbol *sym; > struct value *val; > /* Offset of next stack argument beyond the one we have seen that is > @@ -1779,11 +1780,8 @@ print_frame_args (struct symbol *func, s > if (func) > { > b = SYMBOL_BLOCK_VALUE (func); > - /* Function blocks are order sensitive, and thus should not be > - hashed. */ > - gdb_assert (BLOCK_HASHTABLE (b) == 0); > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > QUIT; > > Index: stack.c > =================================================================== > RCS file: /cvs/src/src/gdb/stack.c,v > retrieving revision 1.73 > diff -u -p -r1.73 stack.c > --- stack.c 5 Apr 2003 15:19:12 -0000 1.73 > +++ stack.c 30 Apr 2003 22:46:09 -0000 > @@ -40,6 +40,7 @@ > #include "annotate.h" > #include "ui-out.h" > #include "block.h" > +#include "dictionary.h" > > /* Prototypes for exported functions. */ > > @@ -1061,11 +1062,12 @@ static int > print_block_frame_locals (struct block *b, register struct frame_info *fi, > int num_tabs, register struct ui_file *stream) > { > - register int i, j; > + struct dict_iterator iter; > + register int j; no need for register. > register struct symbol *sym; > register int values_printed = 0; > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -1097,11 +1099,11 @@ static int > print_block_frame_labels (struct block *b, int *have_default, > register struct ui_file *stream) > { > - register int i; > + struct dict_iterator iter; > register struct symbol *sym; > register int values_printed = 0; > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > if (STREQ (DEPRECATED_SYMBOL_NAME (sym), "default")) > { > @@ -1279,7 +1281,7 @@ print_frame_arg_vars (register struct fr > { > struct symbol *func = get_frame_function (fi); > register struct block *b; > - register int i; > + struct dict_iterator iter; > register struct symbol *sym, *sym2; > register int values_printed = 0; > > @@ -1290,7 +1292,7 @@ print_frame_arg_vars (register struct fr > } > > b = SYMBOL_BLOCK_VALUE (func); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > Index: symfile.c > =================================================================== > RCS file: /cvs/src/src/gdb/symfile.c,v > retrieving revision 1.93 > diff -u -p -r1.93 symfile.c > --- symfile.c 1 Apr 2003 14:17:20 -0000 1.93 > +++ symfile.c 30 Apr 2003 22:46:13 -0000 > @@ -236,38 +236,6 @@ sort_pst_symbols (struct partial_symtab > compare_psymbols); > } > > -/* Call sort_block_syms to sort alphabetically the symbols of one block. */ > - > -void > -sort_block_syms (register struct block *b) > -{ > - qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b), > - sizeof (struct symbol *), compare_symbols); > -} > - > -/* Call sort_symtab_syms to sort alphabetically > - the symbols of each block of one symtab. */ > - > -void > -sort_symtab_syms (register struct symtab *s) > -{ > - register struct blockvector *bv; > - int nbl; > - int i; > - register struct block *b; > - > - if (s == 0) > - return; > - bv = BLOCKVECTOR (s); > - nbl = BLOCKVECTOR_NBLOCKS (bv); > - for (i = 0; i < nbl; i++) > - { > - b = BLOCKVECTOR_BLOCK (bv, i); > - if (BLOCK_SHOULD_SORT (b)) > - sort_block_syms (b); > - } > -} > - > /* Make a null terminated copy of the string at PTR with SIZE characters in > the obstack pointed to by OBSTACKP . Returns the address of the copy. > Note that the string at PTR does not have to be null terminated, I.E. it > Index: symfile.h > =================================================================== > RCS file: /cvs/src/src/gdb/symfile.h,v > retrieving revision 1.20 > diff -u -p -r1.20 symfile.h > --- symfile.h 12 Apr 2003 17:41:26 -0000 1.20 > +++ symfile.h 30 Apr 2003 22:46:13 -0000 > @@ -204,12 +204,6 @@ extern struct partial_symtab *start_psym > struct partial_symbol **, > struct partial_symbol **); > > -/* Sorting your symbols for fast lookup or alphabetical printing. */ > - > -extern void sort_block_syms (struct block *); > - > -extern void sort_symtab_syms (struct symtab *); > - > /* Make a copy of the string at PTR with SIZE characters in the symbol obstack > (and add a null character at the end in the copy). > Returns the address of the copy. */ > Index: symmisc.c > =================================================================== > RCS file: /cvs/src/src/gdb/symmisc.c,v > retrieving revision 1.20 > diff -u -p -r1.20 symmisc.c > --- symmisc.c 14 Apr 2003 18:42:27 -0000 1.20 > +++ symmisc.c 30 Apr 2003 22:46:15 -0000 > @@ -34,6 +34,7 @@ > #include "bcache.h" > #include "block.h" > #include "gdb_regex.h" > +#include "dictionary.h" > > #include "gdb_string.h" > #include <readline/readline.h> > @@ -87,22 +88,22 @@ static void free_symtab_block (struct ob > > /* Free a struct block <- B and all the symbols defined in that block. */ > > +/* FIXME: carlton/2003-04-28: I don't believe this is currently ever > + used. */ > + > static void > free_symtab_block (struct objfile *objfile, struct block *b) > { > - register int i, n; > - struct symbol *sym, *next_sym; > + struct dict_iterator iter; > + struct symbol *sym; > > - n = BLOCK_BUCKETS (b); > - for (i = 0; i < n; i++) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > - for (sym = BLOCK_BUCKET (b, i); sym; sym = next_sym) > - { > - next_sym = sym->hash_next; > - xmfree (objfile->md, DEPRECATED_SYMBOL_NAME (sym)); > - xmfree (objfile->md, sym); > - } > + xmfree (objfile->md, DEPRECATED_SYMBOL_NAME (sym)); > + xmfree (objfile->md, sym); > } > + > + dict_free (BLOCK_DICT (b)); > xmfree (objfile->md, b); > } > > @@ -141,7 +142,7 @@ free_symtab (register struct symtab *s) > /* Also free the linetable. */ > > case free_linetable: > - /* Everything will be freed either by our `free_ptr' > + /* Everything will be freed either by our `free_func' > or by some other symtab, except for our linetable. > Free that now. */ > if (LINETABLE (s)) > @@ -150,8 +151,8 @@ free_symtab (register struct symtab *s) > } > > /* If there is a single block of memory to free, free it. */ > - if (s->free_ptr != NULL) > - xmfree (s->objfile->md, s->free_ptr); > + if (s->free_func != NULL) > + s->free_func (s); > > /* Free source-related stuff */ > if (s->line_charpos != NULL) > @@ -444,7 +445,8 @@ static void > dump_symtab (struct objfile *objfile, struct symtab *symtab, > struct ui_file *outfile) > { > - register int i, j; > + register int i; no need for register. > + struct dict_iterator iter; > int len, blen; > register struct linetable *l; > struct blockvector *bv; > @@ -493,6 +495,11 @@ dump_symtab (struct objfile *objfile, st > fprintf_filtered (outfile, " under "); > gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile); > } > +#if 0 > + /* NOTE: carlton/2003-04-28: If we really want to be able to > + print out something here, we'll need to add an extra > + dictionary method just for that purpose. */ > + Hmmm, I think we should. We don't want to change gdb's behavior. > /* drow/2002-07-10: We could save the total symbols count > even if we're using a hashtable, but nothing else but this message > wants it. */ > @@ -501,6 +508,7 @@ dump_symtab (struct objfile *objfile, st > fprintf_filtered (outfile, ", %d buckets in ", blen); > else > fprintf_filtered (outfile, ", %d syms in ", blen); > +#endif > print_address_numeric (BLOCK_START (b), 1, outfile); > fprintf_filtered (outfile, ".."); > print_address_numeric (BLOCK_END (b), 1, outfile); > @@ -518,7 +526,7 @@ dump_symtab (struct objfile *objfile, st > fprintf_filtered (outfile, "\n"); > /* Now print each symbol in this block (in no particular order, if > we're using a hashtable). */ > - ALL_BLOCK_SYMBOLS (b, j, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > struct print_symbol_args s; > s.symbol = sym; > Index: symtab.c > =================================================================== > RCS file: /cvs/src/src/gdb/symtab.c,v > retrieving revision 1.101 > diff -u -p -r1.101 symtab.c > --- symtab.c 14 Apr 2003 19:56:32 -0000 1.101 > +++ symtab.c 30 Apr 2003 22:46:19 -0000 > @@ -45,6 +45,7 @@ > > #include "gdb_obstack.h" > #include "block.h" > +#include "dictionary.h" > > #include <sys/types.h> > #include <fcntl.h> > @@ -1666,127 +1667,40 @@ lookup_block_symbol (register const stru > const char *mangled_name, > const namespace_enum namespace) > { > - register int bot, top, inc; > - register struct symbol *sym; > - register struct symbol *sym_found = NULL; > - register int do_linear_search = 1; > + struct dict_iterator iter; > + struct symbol *sym; > > - if (BLOCK_HASHTABLE (block)) > + if (!BLOCK_FUNCTION (block)) > { > - unsigned int hash_index; > - hash_index = msymbol_hash_iw (name); > - hash_index = hash_index % BLOCK_BUCKETS (block); > - for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next) > - { > - if (SYMBOL_NAMESPACE (sym) == namespace > - && (mangled_name > - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 > - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) > + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); > + sym != NULL; > + sym = dict_iter_name_next (name, &iter)) > + { > + if (SYMBOL_NAMESPACE (sym) == namespace > + && (mangled_name != NULL > + ? strcmp (SYMBOL_LINKAGE_NAME (sym), mangled_name) == 0 : 1)) > return sym; > } > return NULL; > } > - > - /* If the blocks's symbols were sorted, start with a binary search. */ > - > - if (BLOCK_SHOULD_SORT (block)) > + else > { > - /* Reset the linear search flag so if the binary search fails, we > - won't do the linear search once unless we find some reason to > - do so */ > - > - do_linear_search = 0; > - top = BLOCK_NSYMS (block); > - bot = 0; > - > - /* Advance BOT to not far before the first symbol whose name is NAME. */ > - > - while (1) > + /* Note that parameter symbols do not always show up last in the > + list. This loop makes sure to take anything else other than > + parameter symbols first; it only uses parameter symbols as a > + last resort. Note that this only takes up extra computation > + time on a match. */ > + > + struct symbol *sym_found = NULL; > + > + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); > + sym != NULL; > + sym = dict_iter_name_next (name, &iter)) > { > - inc = (top - bot + 1); > - /* No need to keep binary searching for the last few bits worth. */ > - if (inc < 4) > - { > - break; > - } > - inc = (inc >> 1) + bot; > - sym = BLOCK_SYM (block, inc); > - if (!do_linear_search && (SYMBOL_LANGUAGE (sym) == language_java)) > - { > - do_linear_search = 1; > - } > - if (SYMBOL_NATURAL_NAME (sym)[0] < name[0]) > - { > - bot = inc; > - } > - else if (SYMBOL_NATURAL_NAME (sym)[0] > name[0]) > - { > - top = inc; > - } > - else if (strcmp (SYMBOL_NATURAL_NAME (sym), name) < 0) > - { > - bot = inc; > - } > - else > - { > - top = inc; > - } > - } > - > - /* Now scan forward until we run out of symbols, find one whose > - name is greater than NAME, or find one we want. If there is > - more than one symbol with the right name and namespace, we > - return the first one; I believe it is now impossible for us > - to encounter two symbols with the same name and namespace > - here, because blocks containing argument symbols are no > - longer sorted. The exception is for C++, where multiple functions > - (cloned constructors / destructors, in particular) can have > - the same demangled name. So if we have a particular > - mangled name to match, try to do so. */ > - > - top = BLOCK_NSYMS (block); > - while (bot < top) > - { > - sym = BLOCK_SYM (block, bot); > if (SYMBOL_NAMESPACE (sym) == namespace > - && (mangled_name > - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 > - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) > - { > - return sym; > - } > - if (SYMBOL_PRINT_NAME (sym)[0] > name[0]) > - { > - break; > - } > - bot++; > - } > - } > - > - /* Here if block isn't sorted, or we fail to find a match during the > - binary search above. If during the binary search above, we find a > - symbol which is a Java symbol, then we have re-enabled the linear > - search flag which was reset when starting the binary search. > - > - This loop is equivalent to the loop above, but hacked greatly for speed. > - > - Note that parameter symbols do not always show up last in the > - list; this loop makes sure to take anything else other than > - parameter symbols first; it only uses parameter symbols as a > - last resort. Note that this only takes up extra computation > - time on a match. */ > + && (mangled_name != NULL > + ? strcmp (SYMBOL_LINKAGE_NAME (sym), mangled_name) == 0 : 1)) > > - if (do_linear_search) > - { > - top = BLOCK_NSYMS (block); > - bot = 0; > - while (bot < top) > - { > - sym = BLOCK_SYM (block, bot); > - if (SYMBOL_NAMESPACE (sym) == namespace > - && (mangled_name > - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0 > - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) > { > /* If SYM has aliases, then use any alias that is active > at the current PC. If no alias is active at the current > @@ -1795,18 +1709,18 @@ lookup_block_symbol (register const stru > ?!? Is checking the current pc correct? Is this routine > ever called to look up a symbol from another context? > > - FIXME: No, it's not correct. If someone sets a > - conditional breakpoint at an address, then the > - breakpoint's `struct expression' should refer to the > - `struct symbol' appropriate for the breakpoint's > - address, which may not be the PC. > - > - Even if it were never called from another context, > - it's totally bizarre for lookup_symbol's behavior to > - depend on the value of the inferior's current PC. We > - should pass in the appropriate PC as well as the > - block. The interface to lookup_symbol should change > - to require the caller to provide a PC. */ > + FIXME: No, it's not correct. If someone sets a > + conditional breakpoint at an address, then the > + breakpoint's `struct expression' should refer to the > + `struct symbol' appropriate for the breakpoint's > + address, which may not be the PC. > + > + Even if it were never called from another context, > + it's totally bizarre for lookup_symbol's behavior to > + depend on the value of the inferior's current PC. We > + should pass in the appropriate PC as well as the > + block. The interface to lookup_symbol should change > + to require the caller to provide a PC. */ > > if (SYMBOL_ALIASES (sym)) > sym = find_active_alias (sym, read_pc ()); > @@ -1823,10 +1737,9 @@ lookup_block_symbol (register const stru > break; > } > } > - bot++; > } > + return (sym_found); /* Will be NULL if not found. */ > } > - return (sym_found); /* Will be NULL if not found. */ > } > > /* Given a main symbol SYM and ADDR, search through the alias > @@ -1929,16 +1842,16 @@ find_pc_sect_symtab (CORE_ADDR pc, asect > } > if (section != 0) > { > - int i; > + struct dict_iterator iter; > struct symbol *sym = NULL; > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > fixup_symbol_section (sym, objfile); > if (section == SYMBOL_BFD_SECTION (sym)) > break; > } > - if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL)) > + if (sym == NULL) > continue; /* no symbol in this symtab matches section */ > } > distance = BLOCK_END (b) - BLOCK_START (b); > @@ -2875,7 +2788,7 @@ search_symbols (char *regexp, namespace_ > struct blockvector *prev_bv = 0; > register struct block *b; > register int i = 0; > - register int j; > + struct dict_iterator iter; > register struct symbol *sym; > struct partial_symbol **psym; > struct objfile *objfile; > @@ -3064,7 +2977,7 @@ search_symbols (char *regexp, namespace_ > struct symbol_search *prevtail = tail; > int nfound = 0; > b = BLOCKVECTOR_BLOCK (bv, i); > - ALL_BLOCK_SYMBOLS (b, j, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > QUIT; > if (file_matches (s->filename, files, nfiles) > @@ -3425,7 +3338,8 @@ make_symbol_completion_list (char *text, > register struct minimal_symbol *msymbol; > register struct objfile *objfile; > register struct block *b, *surrounding_static_block = 0; > - register int i, j; > + struct dict_iterator iter; > + register int j; no need for register. > struct partial_symbol **psym; > /* The symbol we are completing on. Points in same buffer as text. */ > char *sym_text; > @@ -3546,7 +3460,7 @@ make_symbol_completion_list (char *text, > /* Also catch fields of types defined in this places which match our > text string. Only complete on types visible from current context. */ > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); > if (SYMBOL_CLASS (sym) == LOC_TYPEDEF) > @@ -3576,7 +3490,7 @@ make_symbol_completion_list (char *text, > { > QUIT; > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); > } > @@ -3589,7 +3503,7 @@ make_symbol_completion_list (char *text, > /* Don't do this block twice. */ > if (b == surrounding_static_block) > continue; > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); > } > @@ -3607,7 +3521,7 @@ make_file_symbol_completion_list (char * > register struct symbol *sym; > register struct symtab *s; > register struct block *b; > - register int i; > + struct dict_iterator iter; > /* The symbol we are completing on. Points in same buffer as text. */ > char *sym_text; > /* Length of sym_text. */ > @@ -3694,13 +3608,13 @@ make_file_symbol_completion_list (char * > symbols which match. */ > > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); > } > > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); > } > @@ -4051,7 +3965,7 @@ make_symbol_overload_list (struct symbol > register struct partial_symtab *ps; > register struct objfile *objfile; > register struct block *b, *surrounding_static_block = 0; > - register int i; > + struct dict_iterator iter; > /* The name we are completing on. */ > char *oload_name = NULL; > /* Length of name. */ > @@ -4108,7 +4022,7 @@ make_symbol_overload_list (struct symbol > /* Also catch fields of types defined in this places which match our > text string. Only complete on types visible from current context. */ > > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > overload_list_add_symbol (sym, oload_name); > } > @@ -4121,7 +4035,7 @@ make_symbol_overload_list (struct symbol > { > QUIT; > b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > overload_list_add_symbol (sym, oload_name); > } > @@ -4134,7 +4048,7 @@ make_symbol_overload_list (struct symbol > /* Don't do this block twice. */ > if (b == surrounding_static_block) > continue; > - ALL_BLOCK_SYMBOLS (b, i, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > overload_list_add_symbol (sym, oload_name); > } > Index: symtab.h > =================================================================== > RCS file: /cvs/src/src/gdb/symtab.h,v > retrieving revision 1.68 > diff -u -p -r1.68 symtab.h > --- symtab.h 14 Apr 2003 19:55:27 -0000 1.68 > +++ symtab.h 30 Apr 2003 22:46:20 -0000 > @@ -819,10 +819,10 @@ struct symtab > } > free_code; > > - /* Pointer to one block of storage to be freed, if nonzero. */ > - /* This is IN ADDITION to the action indicated by free_code. */ > + /* A function to call to free space, if necessary. This is IN > + ADDITION to the action indicated by free_code. */ > > - char *free_ptr; > + void (*free_func)(struct symtab *symtab); > > /* Total number of lines found in source file. */ > > Index: tracepoint.c > =================================================================== > RCS file: /cvs/src/src/gdb/tracepoint.c,v > retrieving revision 1.49 > diff -u -p -r1.49 tracepoint.c > --- tracepoint.c 25 Feb 2003 21:36:20 -0000 1.49 > +++ tracepoint.c 30 Apr 2003 22:46:24 -0000 > @@ -38,6 +38,7 @@ > #include "completer.h" > #include "gdb-events.h" > #include "block.h" > +#include "dictionary.h" > > #include "ax.h" > #include "ax-gdb.h" > @@ -1289,13 +1290,14 @@ add_local_symbols (struct collection_lis > { > struct symbol *sym; > struct block *block; > - int i, count = 0; > + struct dict_iterator iter; > + int count = 0; > > block = block_for_pc (pc); > while (block != 0) > { > QUIT; /* allow user to bail out with ^C */ > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -2333,7 +2335,8 @@ scope_info (char *args, int from_tty) > struct minimal_symbol *msym; > struct block *block; > char **canonical, *symname, *save_args = args; > - int i, j, count = 0; > + struct dict_iterator iter; > + int j, count = 0; > > if (args == 0 || *args == 0) > error ("requires an argument (function, line or *addr) to define a scope"); > @@ -2349,7 +2352,7 @@ scope_info (char *args, int from_tty) > while (block != 0) > { > QUIT; /* allow user to bail out with ^C */ > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > QUIT; /* allow user to bail out with ^C */ > if (count == 0) > Index: valops.c > =================================================================== > RCS file: /cvs/src/src/gdb/valops.c,v > retrieving revision 1.105 > diff -u -p -r1.105 valops.c > --- valops.c 21 Apr 2003 16:48:40 -0000 1.105 > +++ valops.c 30 Apr 2003 22:46:26 -0000 > @@ -35,6 +35,7 @@ > #include "cp-abi.h" > #include "block.h" > #include "infcall.h" > +#include "dictionary.h" > > #include <errno.h> > #include "gdb_string.h" > @@ -2479,7 +2480,6 @@ value_of_local (const char *name, int co > { > struct symbol *func, *sym; > struct block *b; > - int i; > struct value * ret; > > if (deprecated_selected_frame == 0) > @@ -2500,8 +2500,7 @@ value_of_local (const char *name, int co > } > > b = SYMBOL_BLOCK_VALUE (func); > - i = BLOCK_NSYMS (b); > - if (i <= 0) > + if (dict_empty (BLOCK_DICT (b))) > { > if (complain) > error ("no args, no `%s'", name); > Index: gdbtk/generic/gdbtk-cmds.c > =================================================================== > RCS file: /cvs/src/src/gdb/gdbtk/generic/gdbtk-cmds.c,v > retrieving revision 1.72 > diff -u -p -r1.72 gdbtk-cmds.c > --- gdbtk/generic/gdbtk-cmds.c 6 Mar 2003 21:58:41 -0000 1.72 > +++ gdbtk/generic/gdbtk-cmds.c 30 Apr 2003 22:46:31 -0000 > @@ -35,6 +35,7 @@ > #include "top.h" > #include "annotate.h" > #include "block.h" > +#include "dictionary.h" > > /* tcl header files includes varargs.h unless HAS_STDARG is defined, > but gdb uses stdarg.h, so make sure HAS_STDARG is defined. */ > @@ -1402,7 +1403,8 @@ gdb_listfuncs (clientData, interp, objc, > struct blockvector *bv; > struct block *b; > struct symbol *sym; > - int i, j; > + int i; > + struct dict_iterator iter; > Tcl_Obj *funcVals[2]; > > if (objc != 2) > @@ -1433,7 +1435,7 @@ gdb_listfuncs (clientData, interp, objc, > for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) > { > b = BLOCKVECTOR_BLOCK (bv, i); > - ALL_BLOCK_SYMBOLS (b, j, sym) > + ALL_BLOCK_SYMBOLS (b, iter, sym) > { > if (SYMBOL_CLASS (sym) == LOC_BLOCK) > { > Index: gdbtk/generic/gdbtk-stack.c > =================================================================== > RCS file: /cvs/src/src/gdb/gdbtk/generic/gdbtk-stack.c,v > retrieving revision 1.18 > diff -u -p -r1.18 gdbtk-stack.c > --- gdbtk/generic/gdbtk-stack.c 11 Apr 2003 17:40:23 -0000 1.18 > +++ gdbtk/generic/gdbtk-stack.c 30 Apr 2003 22:46:32 -0000 > @@ -23,6 +23,7 @@ > #include "breakpoint.h" > #include "linespec.h" > #include "block.h" > +#include "dictionary.h" > > #include <tcl.h> > #include "gdbtk.h" > @@ -85,7 +86,7 @@ gdb_block_vars (ClientData clientData, T > int objc, Tcl_Obj *CONST objv[]) > { > struct block *block; > - int i; > + struct dict_iterator iter; > struct symbol *sym; > CORE_ADDR start, end; > > @@ -108,7 +109,7 @@ gdb_block_vars (ClientData clientData, T > { > if (BLOCK_START (block) == start && BLOCK_END (block) == end) > { > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -160,7 +161,8 @@ gdb_get_blocks (ClientData clientData, T > int objc, Tcl_Obj *CONST objv[]) > { > struct block *block; > - int i, junk; > + struct dict_iterator iter; > + int junk; > struct symbol *sym; > CORE_ADDR pc; > > @@ -173,7 +175,7 @@ gdb_get_blocks (ClientData clientData, T > while (block != 0) > { > junk = 0; > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > @@ -280,6 +282,7 @@ gdb_get_vars_command (ClientData clientD > struct symbol *sym; > struct block *block; > char **canonical, *args; > + struct dict_iterator iter; > int i, arguments; > > if (objc > 2) > @@ -322,7 +325,7 @@ gdb_get_vars_command (ClientData clientD > > while (block != 0) > { > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > switch (SYMBOL_CLASS (sym)) > { > Index: mi/mi-cmd-stack.c > =================================================================== > RCS file: /cvs/src/src/gdb/mi/mi-cmd-stack.c,v > retrieving revision 1.16 > diff -u -p -r1.16 mi-cmd-stack.c > --- mi/mi-cmd-stack.c 25 Feb 2003 21:36:23 -0000 1.16 > +++ mi/mi-cmd-stack.c 30 Apr 2003 22:46:35 -0000 > @@ -27,6 +27,7 @@ > #include "ui-out.h" > #include "symtab.h" > #include "block.h" > +#include "dictionary.h" > > /* FIXME: these should go in some .h file but stack.c doesn't have a > corresponding .h file. These wrappers will be obsolete anyway, once > @@ -217,7 +218,8 @@ list_args_or_locals (int locals, int val > { > struct block *block; > struct symbol *sym; > - int i, nsyms; > + struct dict_iterator iter; > + int nsyms; > struct cleanup *cleanup_list; > static struct ui_stream *stb = NULL; > > @@ -229,7 +231,7 @@ list_args_or_locals (int locals, int val > > while (block != 0) > { > - ALL_BLOCK_SYMBOLS (block, i, sym) > + ALL_BLOCK_SYMBOLS (block, iter, sym) > { > int print_me = 0; > ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-09 22:39 ` Elena Zannoni @ 2003-06-09 22:55 ` Daniel Jacobowitz 2003-06-10 0:05 ` Joel Brobecker 2003-06-10 16:43 ` David Carlton 1 sibling, 1 reply; 15+ messages in thread From: Daniel Jacobowitz @ 2003-06-09 22:55 UTC (permalink / raw) To: Elena Zannoni; +Cc: David Carlton, gdb-patches, Jim Blandy On Mon, Jun 09, 2003 at 06:45:21PM -0400, Elena Zannoni wrote: > > David Carlton writes: > > As promised in > > <http://sources.redhat.com/ml/gdb/2003-04/msg00177.html>, here's the > > 'struct dictionary' patch. > > > > I've tested this on GCC 3.2, DWARF 2, i686-pc-linux-gnu, and have been > > using it on my branch for months. Most of the work is generic; the > > two special cases are jv-lang.c and mdebugread.c. I'm fairly sure I > > got the former right; the mdebugread.c changes are big enough that I > > could easily have slipped up somewhere. (Though I have tested the > > data structures that are used by mdebugread.c but not by buildsym.c.) > > So obviously somebody should test this on a machine using > > mdebugread.c; any volunteers? > > Does anybody have a setup for testing mdebug? Daniel? Not me. Joel might? Since OSF/Tru64 is about the only thing left using it that we care about... -- Daniel Jacobowitz MontaVista Software Debian GNU/Linux Developer ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-09 22:55 ` Daniel Jacobowitz @ 2003-06-10 0:05 ` Joel Brobecker 2003-06-10 0:24 ` Elena Zannoni 0 siblings, 1 reply; 15+ messages in thread From: Joel Brobecker @ 2003-06-10 0:05 UTC (permalink / raw) To: Elena Zannoni, David Carlton, gdb-patches, Jim Blandy > > Does anybody have a setup for testing mdebug? Daniel? > > Not me. Joel might? Since OSF/Tru64 is about the only thing left > using it that we care about... We have a Tru64 machine, but no C++ compiler... Is this still ok? -- Joel ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 0:05 ` Joel Brobecker @ 2003-06-10 0:24 ` Elena Zannoni 2003-06-10 15:58 ` David Carlton 0 siblings, 1 reply; 15+ messages in thread From: Elena Zannoni @ 2003-06-10 0:24 UTC (permalink / raw) To: Joel Brobecker; +Cc: Elena Zannoni, David Carlton, gdb-patches, Jim Blandy Joel Brobecker writes: > > > Does anybody have a setup for testing mdebug? Daniel? > > > > Not me. Joel might? Since OSF/Tru64 is about the only thing left > > using it that we care about... > > We have a Tru64 machine, but no C++ compiler... Is this still ok? > yes, this is generic stuff. Even though maybe some c++ symbols would make any performance difference more pronounced. The important change is the removal of the sorting for the symbol lists. elena > -- > Joel ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 0:24 ` Elena Zannoni @ 2003-06-10 15:58 ` David Carlton 0 siblings, 0 replies; 15+ messages in thread From: David Carlton @ 2003-06-10 15:58 UTC (permalink / raw) To: Elena Zannoni; +Cc: Joel Brobecker, gdb-patches, Jim Blandy On Mon, 9 Jun 2003 20:30:31 -0400, Elena Zannoni <ezannoni@redhat.com> said: > Joel Brobecker writes: >> > > Does anybody have a setup for testing mdebug? Daniel? >> > >> > Not me. Joel might? Since OSF/Tru64 is about the only thing left >> > using it that we care about... >> >> We have a Tru64 machine, but no C++ compiler... Is this still ok? > yes, this is generic stuff. Even though maybe some c++ symbols would > make any performance difference more pronounced. The important > change is the removal of the sorting for the symbol lists. No, it will be fine performance-wise: I replaced the sorted lists by hash tables. I'm just worried about correctness for mdebugread.c: I had to touch it in enough places that I might have screwed up everything and GDB will die a horrible death somewhere. David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-09 22:39 ` Elena Zannoni 2003-06-09 22:55 ` Daniel Jacobowitz @ 2003-06-10 16:43 ` David Carlton 2003-06-10 18:37 ` Elena Zannoni 2003-06-11 23:33 ` David Carlton 1 sibling, 2 replies; 15+ messages in thread From: David Carlton @ 2003-06-10 16:43 UTC (permalink / raw) To: Elena Zannoni; +Cc: gdb-patches, Jim Blandy On Mon, 9 Jun 2003 18:45:21 -0400, Elena Zannoni <ezannoni@redhat.com> said: > David Carlton writes: > As usual, some comments. Could you check in the removal of the > sorting as one patch, and the dictionary as another? Will do. > See below for some things, but in general it's ok. Great! > I don't feel too comfortable with the Java stuff, are there any > tests that use that particular code? It sure looks safe to me > though. The Java testsuite might exercise it a little bit, but it might not. Once this goes in, I'll e-mail Tom Tromey to ask him to pound on it a bit. >> +/* Various vtbls that we'll actually use. */ >> + >> +static const struct dict_vtbl dict_hashed_vtbl = >> + { >> + DICT_HASHED, free_obstack, add_symbol_nonexpandable, >> + iterator_first_hashed, iterator_next_hashed, >> + iter_name_first_hashed, iter_name_next_hashed, >> + }; >> + > Could you do these one per line and put a comment with the field > name next to it (for easy grepping)? I am not too fond of the use > of vtable terminology, could you use 'vector' or something else? Sure. >> + $(infcall_h) $(dictionary.h) > dictionary_h Whoops, good eye! >> @@ -348,9 +309,11 @@ finish_block (struct symbol *symbol, str >> TYPE_FIELDS (ftype) = (struct field *) >> TYPE_ALLOC (ftype, nparams * sizeof (struct field)); >> >> - for (i = iparams = 0; iparams < nparams; i++) >> + for (sym = dict_iterator_first (BLOCK_DICT (block), &iter), >> + iparams = 0; >> + iparams < nparams; >> + sym = dict_iterator_next (&iter)) > could you use the macro ALL_BLOCK_SYMBOLS here? and move the check for > iparams inside the loop body? Sure, that makes sense. I was just going with the way it had been written before, but now that I look at it, it was only written that way for reasons that are no longer relevant: you want me to do ALL_BLOCK_SYMBOLS (block, iter, sym) { if (iparams == nparams) break; .... } And before this change, that wouldn't have worked, because ALL_BLOCK_SYMBOLS was secretly two nested loops, so you can't break out of them, but after my change it's just a single loop, so the break works just fine. Excellent. >> -static struct block *new_block (int); >> +static struct block *new_block (int function); > can this take an enum parameter with some meaningful names? Well, I'm just using it as a boolean, so it seems to me that doing an enum would be a little funny. How about I rename the argument to function_p, or is_function, or something like that? But if you'd prefer an enum, I could do something like enum block_type { FUNCTION, NON_FUNCTION }; instead. >> @@ -1236,13 +1231,16 @@ parse_symbol (SYMR *sh, union aux_ext *a >> >> if (nparams > 0) >> { >> + struct dict_iterator iter; >> TYPE_NFIELDS (ftype) = nparams; >> TYPE_FIELDS (ftype) = (struct field *) >> TYPE_ALLOC (ftype, nparams * sizeof (struct field)); >> >> - for (i = iparams = 0; iparams < nparams; i++) >> + for (sym = dict_iterator_first (BLOCK_DICT (b), &iter), >> + iparams = 0; >> + iparams < nparams; >> + sym = dict_iterator_next (&iter)) > could you still use the macro here ALL_BLOCK_SYMBOLS and add an if > (iparams == nparams) break; inside the loop? Yes, presumably I can handle this like the buildsym case above. >> - register int i, j; >> + struct dict_iterator iter; >> + register int j; > no need for register. Right, sorry. >> @@ -493,6 +495,11 @@ dump_symtab (struct objfile *objfile, st >> fprintf_filtered (outfile, " under "); >> gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile); >> } >> +#if 0 >> + /* NOTE: carlton/2003-04-28: If we really want to be able to >> + print out something here, we'll need to add an extra >> + dictionary method just for that purpose. */ >> + > Hmmm, I think we should. We don't want to change gdb's behavior. Well, it's for a maint command, so we can really do whatever we want here. But if you think that's an important part of the info, I'll add the extra method. I'll make those changes and commit it tomorrow afternoon (unless exam grading takes longer than I expect), if nobody complains; and I'll be spending all day Thursday doing GDB stuff as well, so I'll be available if I accidentally break anything... David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 16:43 ` David Carlton @ 2003-06-10 18:37 ` Elena Zannoni 2003-06-10 18:47 ` David Carlton 2003-06-11 23:33 ` David Carlton 1 sibling, 1 reply; 15+ messages in thread From: Elena Zannoni @ 2003-06-10 18:37 UTC (permalink / raw) To: David Carlton; +Cc: Elena Zannoni, gdb-patches, Jim Blandy David Carlton writes: > On Mon, 9 Jun 2003 18:45:21 -0400, Elena Zannoni <ezannoni@redhat.com> said: > > David Carlton writes: > > > As usual, some comments. Could you check in the removal of the > > sorting as one patch, and the dictionary as another? > > Will do. > > > See below for some things, but in general it's ok. > > Great! > > > I don't feel too comfortable with the Java stuff, are there any > > tests that use that particular code? It sure looks safe to me > > though. > > The Java testsuite might exercise it a little bit, but it might not. > Once this goes in, I'll e-mail Tom Tromey to ask him to pound on it a > bit. > > >> +/* Various vtbls that we'll actually use. */ > >> + > >> +static const struct dict_vtbl dict_hashed_vtbl = > >> + { > >> + DICT_HASHED, free_obstack, add_symbol_nonexpandable, > >> + iterator_first_hashed, iterator_next_hashed, > >> + iter_name_first_hashed, iter_name_next_hashed, > >> + }; > >> + > > > Could you do these one per line and put a comment with the field > > name next to it (for easy grepping)? I am not too fond of the use > > of vtable terminology, could you use 'vector' or something else? > > Sure. > > >> + $(infcall_h) $(dictionary.h) > > > dictionary_h > > Whoops, good eye! > > >> @@ -348,9 +309,11 @@ finish_block (struct symbol *symbol, str > >> TYPE_FIELDS (ftype) = (struct field *) > >> TYPE_ALLOC (ftype, nparams * sizeof (struct field)); > >> > >> - for (i = iparams = 0; iparams < nparams; i++) > >> + for (sym = dict_iterator_first (BLOCK_DICT (block), &iter), > >> + iparams = 0; > >> + iparams < nparams; > >> + sym = dict_iterator_next (&iter)) > > > could you use the macro ALL_BLOCK_SYMBOLS here? and move the check for > > iparams inside the loop body? > > Sure, that makes sense. I was just going with the way it had been > written before, but now that I look at it, it was only written that > way for reasons that are no longer relevant: you want me to do > > ALL_BLOCK_SYMBOLS (block, iter, sym) > { > if (iparams == nparams) > break; > > .... > } > > And before this change, that wouldn't have worked, because > ALL_BLOCK_SYMBOLS was secretly two nested loops, so you can't break > out of them, but after my change it's just a single loop, so the break > works just fine. Excellent. > > >> -static struct block *new_block (int); > >> +static struct block *new_block (int function); > > > can this take an enum parameter with some meaningful names? > > Well, I'm just using it as a boolean, so it seems to me that doing an > enum would be a little funny. How about I rename the argument to > function_p, or is_function, or something like that? But if you'd > prefer an enum, I could do something like > > enum block_type { FUNCTION, NON_FUNCTION }; > > instead. For me the real problem is to understand the code that does the call. I don't know what 1 or 0 means at that point w/o going looking for the function definition. And I lose my train of thoughts. Don't really care too much because this is only in mdebugread.c though :-) > > >> @@ -1236,13 +1231,16 @@ parse_symbol (SYMR *sh, union aux_ext *a > >> > >> if (nparams > 0) > >> { > >> + struct dict_iterator iter; > >> TYPE_NFIELDS (ftype) = nparams; > >> TYPE_FIELDS (ftype) = (struct field *) > >> TYPE_ALLOC (ftype, nparams * sizeof (struct field)); > >> > >> - for (i = iparams = 0; iparams < nparams; i++) > >> + for (sym = dict_iterator_first (BLOCK_DICT (b), &iter), > >> + iparams = 0; > >> + iparams < nparams; > >> + sym = dict_iterator_next (&iter)) > > > could you still use the macro here ALL_BLOCK_SYMBOLS and add an if > > (iparams == nparams) break; inside the loop? > > Yes, presumably I can handle this like the buildsym case above. > > >> - register int i, j; > >> + struct dict_iterator iter; > >> + register int j; > > > no need for register. > > Right, sorry. > > >> @@ -493,6 +495,11 @@ dump_symtab (struct objfile *objfile, st > >> fprintf_filtered (outfile, " under "); > >> gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile); > >> } > >> +#if 0 > >> + /* NOTE: carlton/2003-04-28: If we really want to be able to > >> + print out something here, we'll need to add an extra > >> + dictionary method just for that purpose. */ > >> + > > > Hmmm, I think we should. We don't want to change gdb's behavior. > > Well, it's for a maint command, so we can really do whatever we want > here. But if you think that's an important part of the info, I'll add > the extra method. > thanks yes. > I'll make those changes and commit it tomorrow afternoon (unless > exam grading takes longer than I expect), if nobody complains; and > I'll be spending all day Thursday doing GDB stuff as well, so I'll be > available if I accidentally break anything... > ok, great. BTW, i have started setting up the same test framework that Michael Chastain uses for his tests. I have done a preliminary run, but I screwed up the combinations of gcc and binutils to test with, so I'll get back to that tomorrow, and I should be able to help with testing for gdb6. elena > David Carlton > carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 18:37 ` Elena Zannoni @ 2003-06-10 18:47 ` David Carlton 2003-06-11 1:20 ` Richard Henderson 0 siblings, 1 reply; 15+ messages in thread From: David Carlton @ 2003-06-10 18:47 UTC (permalink / raw) To: Elena Zannoni; +Cc: gdb-patches, Jim Blandy On Tue, 10 Jun 2003 14:43:11 -0400, Elena Zannoni <ezannoni@redhat.com> said: >> >> -static struct block *new_block (int); >> >> +static struct block *new_block (int function); >> >> > can this take an enum parameter with some meaningful names? >> >> Well, I'm just using it as a boolean, so it seems to me that doing an >> enum would be a little funny. How about I rename the argument to >> function_p, or is_function, or something like that? But if you'd >> prefer an enum, I could do something like >> >> enum block_type { FUNCTION, NON_FUNCTION }; >> >> instead. > For me the real problem is to understand the code that does the > call. I don't know what 1 or 0 means at that point w/o going looking > for the function definition. And I lose my train of thoughts. That makes sense: an enum it is, then. (And in a year or two, we can switch GDB over to C++, and have an actual boolean type, but never mind that.) >> >> @@ -493,6 +495,11 @@ dump_symtab (struct objfile *objfile, st >> >> fprintf_filtered (outfile, " under "); >> >> gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile); >> >> } >> >> +#if 0 >> >> + /* NOTE: carlton/2003-04-28: If we really want to be able to >> >> + print out something here, we'll need to add an extra >> >> + dictionary method just for that purpose. */ >> >> + >> >> > Hmmm, I think we should. We don't want to change gdb's behavior. >> >> Well, it's for a maint command, so we can really do whatever we want >> here. But if you think that's an important part of the info, I'll add >> the extra method. > thanks yes. Will do, then. >> I'll make those changes and commit it tomorrow afternoon (unless >> exam grading takes longer than I expect), if nobody complains; and >> I'll be spending all day Thursday doing GDB stuff as well, so I'll be >> available if I accidentally break anything... > ok, great. BTW, i have started setting up the same test framework > that Michael Chastain uses for his tests. I have done a preliminary > run, but I screwed up the combinations of gcc and binutils to test > with, so I'll get back to that tomorrow, and I should be able to help > with testing for gdb6. Cool! I miss his test runs. David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 18:47 ` David Carlton @ 2003-06-11 1:20 ` Richard Henderson 0 siblings, 0 replies; 15+ messages in thread From: Richard Henderson @ 2003-06-11 1:20 UTC (permalink / raw) To: David Carlton; +Cc: Elena Zannoni, gdb-patches, Jim Blandy On Tue, Jun 10, 2003 at 11:47:19AM -0700, David Carlton wrote: > That makes sense: an enum it is, then. (And in a year or two, we can > switch GDB over to C++, and have an actual boolean type, but never > mind that.) <stdbool.h>? Gcc has supported it for a long time (2.95, at least). It's got the C99 _Bool type. r~ ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-10 16:43 ` David Carlton 2003-06-10 18:37 ` Elena Zannoni @ 2003-06-11 23:33 ` David Carlton 2003-06-13 0:15 ` Joel Brobecker 1 sibling, 1 reply; 15+ messages in thread From: David Carlton @ 2003-06-11 23:33 UTC (permalink / raw) To: Elena Zannoni; +Cc: gdb-patches, Joel Brobecker, Jim Blandy On 10 Jun 2003 09:43:36 -0700, David Carlton <carlton@math.stanford.edu> said: > I'll make those changes and commit it tomorrow afternoon (unless > exam grading takes longer than I expect), if nobody complains; and > I'll be spending all day Thursday doing GDB stuff as well, so I'll > be available if I accidentally break anything... Okay, it's in; revised patch is below. Joel, if you could see if mainline works on an mdebugread target, I'd appreciate it. If it doesn't, any relevant information (e.g. where it crashes or hangs or whatever) would be greatly appreciated. David Carlton carlton@math.stanford.edu 2003-06-11 David Carlton <carlton@bactrian.org> * dictionary.h: New. * dictionary.c: New. * block.h: Add opaque declaration for struct dictionary. (struct block): Add 'dict' member; delete 'hashtable', 'nsyms', 'sym' members. (BLOCK_DICT): New macro. Delete macros BLOCK_HASHTABLE, BLOCK_NSYMS, BLOCK_SYM, BLOCK_BUCKETS, BLOCK_BUCKET, BLOCK_HASHTABLE_SIZE, BLOCK_SHOULD_SORT. (ALL_BLOCK_SYMBOLS): Update definition. * Makefile.in (SFILES): Add dictionary.c. (dictionary_h): New. (COMMON_OBS): Add dictionary.o. (dictionary.o): New. (ada-lang.o): Depend on dictionary_h. (buildsym.o, coffread.o, jv-lang.o, mdebugread.o, objfiles.o) (stack.o, symmisc.o, symtab.o, tracepoint.o, valops.o) (mi-cmd-stack.o): Ditto. (gdbtk-cmds.o): Update dependencies. (gdbtk-stack.o): Ditto. * ada-lang.c: Include dictionary.h. (symtab_for_sym): Update uses of ALL_BLOCK_SYMBOLS. (fill_in_ada_prototype, debug_print_block): Ditto. (ada_add_block_symbols): Update uses of ALL_BLOCK_SYMBOLS; replace explicit iteration by use of ALL_BLOCK_SYMBOLS. Delete variable 'is_sorted'. * mdebugread.c: Include dictionary.h. (struct parse_stack): Delete 'maxsyms' member. (parse_symbol): Update calls to new_block. Delete calls to shrink_block. Use dictionary methods. (psymtab_to_symtab_1): Delete calls to sort_symtab_syms. Update calls to new_symtab. Don't maintain maxsyms data. (mylookup_symbol): Update use of ALL_BLOCK_SYMBOLS. (add_symbol): Just call dict_add_symbol. (new_symtab): Delete 'maxsyms' argument. (new_symtab): Update calls to new_block. (new_block): Delete 'maxsyms' argument; add 'function' argument. (shrink_block): Delete function. (fixup_sigtramp): Update call to new_block. Add symbol via dict_add_symbol. * jv-lang.c: Include dictionary.h. (get_java_class_symtab): Set the BLOCK_DICT of the blocks appropriately. Set class_symtab->free_func. Make sure the blockvector is big enough to hold two blocks. (add_class_symtab_symbol): Use dictionary methods. (free_class_block): New function. (type_from_class): Replace explicit iteration by ALL_BLOCK_SYMBOLS. * symtab.h (struct symtab): Replace 'free_ptr' method by 'free_func'. * dwarf2read.c (psymtab_to_symtab_1): Delete call to sort_symtab_syms. * dwarfread.c (psymtab_to_symtab_1): Delete call to sort_symtab_syms. * coffread.c (coff_symfile_read): Delete call to sort_symtab_syms. Include dictionary.h. (patch_opaque_types): Update use of ALL_BLOCK_SYMBOLS. * dbxread.c (dbx_psymtab_to_symtab_1): Delete call to sort_symtab_syms. * objfiles.c: Include dictionary.h. (objfile_relocate): Update use of ALL_BLOCK_SYMBOLS. * buildsym.c: Include dictionary.h. (finish_block): Use dictionary methods. (end_symtab): Set free_func to NULL, not free_ptr. * tracepoint.c: Include dictionary.h. (add_local_symbols): Update use of ALL_BLOCK_SYMBOLS. (scope_info): Ditto. * stack.c: Include dictionary.h. (print_block_frame_locals): Update use of ALL_BLOCK_SYMBOLS. (print_block_frame_labels, print_frame_arg_vars) (print_frame_args): Ditto. * symmisc.c (free_symtab_block): Use dictionary methods. (dump_symtab): Ditto. (free_symtab): Replace use of 'free_ptr' by 'free_func'. Include dictionary.h. * symfile.h: Delete declarations of sort_block_syms, sort_symtab_syms. * symfile.c (sort_block_syms): Delete. (sort_symtab_syms): Delete. * symtab.c: Include dictionary.h. (lookup_block_symbol): Use dictionary iterators. (find_pc_sect_symtab): Update use of ALL_BLOCK_SYMBOLS. (search_symbols, make_symbol_completion_list): Ditto. (make_symbol_overload_list): Ditto. * valops.c (value_of_local): Use dict_empty. Include dictionary.h. 2003-06-11 David Carlton <carlton@bactrian.org> * mi-cmd-stack.c: Include dictionary.h. (list_args_or_locals): Update use of ALL_BLOCK_SYMBOLS. 2003-06-11 David Carlton <carlton@bactrian.org> * generic/gdbtk-stack.c: Include dictionary.h. (gdb_block_vars): Update use of ALL_BLOCK_SYMBOLS. (gdb_get_blocks, gdb_get_vars_command): Ditto. * generic/gdbtk-cmds.c: Include dictionary.h. (gdb_listfuncs): Update use of ALL_BLOCK_SYMBOLS. --- /dev/null 2002-08-30 16:31:37.000000000 -0700 +++ dictionary.h 2003-06-11 16:02:37.000000000 -0700 @@ -0,0 +1,156 @@ +/* Routines for name->symbol lookups in GDB. + + Copyright 2003 Free Software Foundation, Inc. + + Contributed by David Carlton <carlton@bactrian.org> and by Kealia, + 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 (at + your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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. */ + +#ifndef DICTIONARY_H +#define DICTIONARY_H + +/* An opaque type for dictionaries; only dictionary.c should know + about its innards. */ + +struct dictionary; + +/* Other types needed for declarations. */ + +struct symbol; +struct obstack; +struct pending; + + +/* The creation functions for various implementations of + dictionaries. */ + +/* Create a dictionary 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, + const struct pending + *symbol_list); + +/* Create a dictionary 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. */ + +extern struct dictionary *dict_create_hashed_expandable (void); + +/* Create a dictionary 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, + const struct pending + *symbol_list); + +/* Create a dictionary 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. */ + +extern struct dictionary *dict_create_linear_expandable (void); + + +/* 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. */ + +/* Free the memory used by a dictionary that's not on an obstack. (If + any.) */ + +extern void dict_free (struct dictionary *dict); + +/* Add a symbol to an expandable dictionary. */ + +extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym); + +/* Is the dictionary empty? */ + +extern int dict_empty (struct dictionary *dict); + +/* 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 + be opaque if we didn't need to be able to allocate it on the + stack. */ + +struct dict_iterator +{ + /* The dictionary that this iterator is associated to. */ + const struct dictionary *dict; + /* The next two members are data that is used in a way that depends + on DICT's implementation type. */ + int index; + struct symbol *current; +}; + +/* Initialize ITERATOR to point at the first symbol in DICT, and + return that first symbol, or NULL if DICT is empty. */ + +extern struct symbol *dict_iterator_first (const struct dictionary *dict, + struct dict_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 dict_iterator_first or dict_iterator_next on this + iteration. */ + +extern struct symbol *dict_iterator_next (struct dict_iterator *iterator); + +/* Initialize ITERATOR to point at the first symbol in DICT whose + SYMBOL_BEST_NAME is NAME (as tested using strcmp_iw), and return + that first symbol, or NULL if there are no such symbols. */ + +extern struct symbol *dict_iter_name_first (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator); + +/* Advance ITERATOR to point at the next symbol in DICT whose + SYMBOL_BEST_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 dict_iterator_first or + dict_iterator_next on this iteration. And don't call it unless + ITERATOR was created by a previous call to dict_iter_name_first + with the same NAME. */ + +extern struct symbol *dict_iter_name_next (const char *name, + struct dict_iterator *iterator); + +/* Return some notion of the size of the dictionary: the number of + symbols if we have that, the number of hash buckets otherwise. */ + +extern int dict_size (const struct dictionary *dict); + +/* Macro to loop through all symbols in a dictionary DICT, in no + particular order. ITER is a struct dict_iterator (NOTE: __not__ a + struct dict_iterator *), and SYM points to the current symbol. + + It's implemented as a single loop, so you can terminate the loop + early by a break if you desire. */ + +#define ALL_DICT_SYMBOLS(dict, iter, sym) \ + for ((sym) = dict_iterator_first ((dict), &(iter)); \ + (sym); \ + (sym) = dict_iterator_next (&(iter))) + +#endif /* DICTIONARY_H */ --- /dev/null 2002-08-30 16:31:37.000000000 -0700 +++ dictionary.c 2003-06-11 16:12:47.000000000 -0700 @@ -0,0 +1,836 @@ +/* Routines for name->symbol lookups in GDB. + + Copyright 2003 Free Software Foundation, Inc. + + Contributed by David Carlton <carlton@bactrian.org> and by Kealia, + 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 (at + your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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. */ + +#include "defs.h" +#include "gdb_obstack.h" +#include "symtab.h" +#include "buildsym.h" +#include "gdb_assert.h" +#include "dictionary.h" + +/* This file implements dictionaries, which are tables that associate + symbols to names. They are represented by an opaque type 'struct + dictionary'. That type has various internal implementations, which + you can choose between depending on what properties you need + (e.g. fast lookup, order-preserving, expandable). + + Each dictionary starts with a 'virtual function table' that + contains the functions that actually implement the various + operations that dictionaries provide. (Note, however, that, for + the sake of client code, we also provide some functions that can be + implemented generically in terms of the functions in the vtable.) + + To add a new dictionary implementation <impl>, what you should do + is: + + * Add a new element DICT_<IMPL> to dict_type. + + * Create a new structure dictionary_<impl>. If your new + implementation is a variant of an existing one, make sure that + their structs have the same initial data members. Define accessor + macros for your new data members. + + * Implement all the functions in dict_vector as static functions, + whose name is the same as the corresponding member of dict_vector + plus _<impl>. You don't have to do this for those members where + you can reuse existing generic functions + (e.g. add_symbol_nonexpandable, free_obstack) or in the case where + your new implementation is a variant of an existing implementation + and where the variant doesn't affect the member function in + question. + + * Define a static const struct dict_vector dict_<impl>_vector. + + * Define a function dict_create_<impl> to create these + gizmos. Add its declaration to dictionary.h. + + To add a new operation <op> on all existing implementations, what + you should do is: + + * Add a new member <op> to struct dict_vector. + + * If there is useful generic behavior <op>, define a static + function <op>_something_informative that implements that behavior. + (E.g. add_symbol_nonexpandable, free_obstack.) + + * For every implementation <impl> that should have its own specific + behavior for <op>, define a static function <op>_<impl> + implementing it. + + * Modify all existing dict_vector_<impl>'s to include the appropriate + member. + + * Define a function dict_<op> that looks up <op> in the dict_vector + and calls the appropriate function. Add a declaration for + dict_<op> to dictionary.h. + +*/ + +/* An enum representing the various implementations of dictionaries. + Used only for debugging. */ + +enum dict_type + { + /* Symbols are stored in a fixed-size hash table. */ + DICT_HASHED, + /* Symbols are stored in an expandable hash table. */ + DICT_HASHED_EXPANDABLE, + /* Symbols are stored in a fixed-size array. */ + DICT_LINEAR, + /* Symbols are stored in an expandable array. */ + DICT_LINEAR_EXPANDABLE, + }; + +/* The virtual function table. */ + +struct dict_vector +{ + /* The type of the dictionary. This is only here to make debugging + a bit easier; it's not actually used. */ + enum dict_type type; + /* The function to free a dictionary. */ + void (*free) (struct dictionary *dict); + /* Add a symbol to a dictionary, if possible. */ + void (*add_symbol) (struct dictionary *dict, struct symbol *sym); + /* Iterator functions. */ + struct symbol *(*iterator_first) (const struct dictionary *dict, + struct dict_iterator *iterator); + struct symbol *(*iterator_next) (struct dict_iterator *iterator); + /* Functions to iterate over symbols with a given name. */ + struct symbol *(*iter_name_first) (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator); + struct symbol *(*iter_name_next) (const char *name, + struct dict_iterator *iterator); + /* A size function, for maint print symtabs. */ + int (*size) (const struct dictionary *dict); +}; + +/* Now comes the structs used to store the data for different + implementations. If two implementations have data in common, put + the common data at the top of their structs, ordered in the same + way. */ + +struct dictionary_hashed +{ + int nbuckets; + struct symbol **buckets; +}; + +struct dictionary_hashed_expandable +{ + /* How many buckets we currently have. */ + int nbuckets; + struct symbol **buckets; + /* How many syms we currently have; we need this so we will know + when to add more buckets. */ + int nsyms; +}; + +struct dictionary_linear +{ + int nsyms; + struct symbol **syms; +}; + +struct dictionary_linear_expandable +{ + /* How many symbols we currently have. */ + int nsyms; + struct symbol **syms; + /* How many symbols we can store before needing to reallocate. */ + int capacity; +}; + +/* And now, the star of our show. */ + +struct dictionary +{ + const struct dict_vector *vector; + union + { + struct dictionary_hashed hashed; + struct dictionary_hashed_expandable hashed_expandable; + struct dictionary_linear linear; + struct dictionary_linear_expandable linear_expandable; + } + data; +}; + +/* Accessor macros. */ + +#define DICT_VECTOR(d) (d)->vector + +/* These can be used for DICT_HASHED_EXPANDABLE, too. */ + +#define DICT_HASHED_NBUCKETS(d) (d)->data.hashed.nbuckets +#define DICT_HASHED_BUCKETS(d) (d)->data.hashed.buckets +#define DICT_HASHED_BUCKET(d,i) DICT_HASHED_BUCKETS (d) [i] + +#define DICT_HASHED_EXPANDABLE_NSYMS(d) (d)->data.hashed_expandable.nsyms + +/* These can be used for DICT_LINEAR_EXPANDABLEs, too. */ + +#define DICT_LINEAR_NSYMS(d) (d)->data.linear.nsyms +#define DICT_LINEAR_SYMS(d) (d)->data.linear.syms +#define DICT_LINEAR_SYM(d,i) DICT_LINEAR_SYMS (d) [i] + +#define DICT_LINEAR_EXPANDABLE_CAPACITY(d) \ + (d)->data.linear_expandable.capacity + +/* The initial size of a DICT_*_EXPANDABLE dictionary. */ + +#define DICT_EXPANDABLE_INITIAL_CAPACITY 10 + +/* This calculates the number of buckets we'll use in a hashtable, + given the number of symbols that it will contain. */ + +#define DICT_HASHTABLE_SIZE(n) ((n)/5 + 1) + +/* Accessor macros for dict_iterators; they're here rather than + dictionary.h because code elsewhere should treat dict_iterators as + opaque. */ + +/* The dictionary that the iterator is associated to. */ +#define DICT_ITERATOR_DICT(iter) (iter)->dict +/* For linear dictionaries, the index of the last symbol returned; for + hashed dictionaries, the bucket of the last symbol returned. */ +#define DICT_ITERATOR_INDEX(iter) (iter)->index +/* For hashed dictionaries, this points to the last symbol returned; + otherwise, this is unused. */ +#define DICT_ITERATOR_CURRENT(iter) (iter)->current + +/* Declarations of functions for vectors. */ + +/* Functions that might work across a range of dictionary types. */ + +static void add_symbol_nonexpandable (struct dictionary *dict, + struct symbol *sym); + +static void free_obstack (struct dictionary *dict); + +/* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE + dictionaries. */ + +static struct symbol *iterator_first_hashed (const struct dictionary *dict, + struct dict_iterator *iterator); + +static struct symbol *iterator_next_hashed (struct dict_iterator *iterator); + +static struct symbol *iter_name_first_hashed (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator); + +static struct symbol *iter_name_next_hashed (const char *name, + struct dict_iterator *iterator); + +/* Functions only for DICT_HASHED. */ + +static int size_hashed (const struct dictionary *dict); + +/* Functions only for DICT_HASHED_EXPANDABLE. */ + +static void free_hashed_expandable (struct dictionary *dict); + +static void add_symbol_hashed_expandable (struct dictionary *dict, + struct symbol *sym); + +static int size_hashed_expandable (const struct dictionary *dict); + +/* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE + dictionaries. */ + +static struct symbol *iterator_first_linear (const struct dictionary *dict, + struct dict_iterator *iterator); + +static struct symbol *iterator_next_linear (struct dict_iterator *iterator); + +static struct symbol *iter_name_first_linear (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator); + +static struct symbol *iter_name_next_linear (const char *name, + struct dict_iterator *iterator); + +static int size_linear (const struct dictionary *dict); + +/* Functions only for DICT_LINEAR_EXPANDABLE. */ + +static void free_linear_expandable (struct dictionary *dict); + +static void add_symbol_linear_expandable (struct dictionary *dict, + struct symbol *sym); + +/* Various vectors that we'll actually use. */ + +static const struct dict_vector dict_hashed_vector = + { + DICT_HASHED, /* type */ + free_obstack, /* free */ + add_symbol_nonexpandable, /* add_symbol */ + iterator_first_hashed, /* iteractor_first */ + iterator_next_hashed, /* iterator_next */ + iter_name_first_hashed, /* iter_name_first */ + iter_name_next_hashed, /* iter_name_next */ + size_hashed, /* size */ + }; + +static const struct dict_vector dict_hashed_expandable_vector = + { + DICT_HASHED_EXPANDABLE, /* type */ + free_hashed_expandable, /* free */ + add_symbol_hashed_expandable, /* add_symbol */ + iterator_first_hashed, /* iteractor_first */ + iterator_next_hashed, /* iterator_next */ + iter_name_first_hashed, /* iter_name_first */ + iter_name_next_hashed, /* iter_name_next */ + size_hashed_expandable, /* size */ + }; + +static const struct dict_vector dict_linear_vector = + { + DICT_LINEAR, /* type */ + free_obstack, /* free */ + add_symbol_nonexpandable, /* add_symbol */ + iterator_first_linear, /* iteractor_first */ + iterator_next_linear, /* iterator_next */ + iter_name_first_linear, /* iter_name_first */ + iter_name_next_linear, /* iter_name_next */ + size_linear, /* size */ + }; + +static const struct dict_vector dict_linear_expandable_vector = + { + DICT_LINEAR_EXPANDABLE, /* type */ + free_linear_expandable, /* free */ + add_symbol_linear_expandable, /* add_symbol */ + iterator_first_linear, /* iteractor_first */ + iterator_next_linear, /* iterator_next */ + iter_name_first_linear, /* iter_name_first */ + iter_name_next_linear, /* iter_name_next */ + size_linear, /* size */ + }; + +/* Declarations of helper functions (i.e. ones that don't go into + vectors). */ + +static struct symbol *iterator_hashed_advance (struct dict_iterator *iter); + +static void insert_symbol_hashed (struct dictionary *dict, + struct symbol *sym); + +static void expand_hashtable (struct dictionary *dict); + +/* The creation functions. */ + +/* Create a dictionary implemented via a fixed-size hashtable. All + memory it uses is allocated on OBSTACK; the environment is + initialized from SYMBOL_LIST. */ + +struct dictionary * +dict_create_hashed (struct obstack *obstack, + const struct pending *symbol_list) +{ + struct dictionary *retval; + int nsyms = 0, nbuckets, i; + struct symbol **buckets; + const struct pending *list_counter; + + retval = obstack_alloc (obstack, sizeof (struct dictionary)); + DICT_VECTOR (retval) = &dict_hashed_vector; + + /* Calculate the number of symbols, and allocate space for them. */ + for (list_counter = symbol_list; + list_counter != NULL; + list_counter = list_counter->next) + { + nsyms += list_counter->nsyms; + } + nbuckets = DICT_HASHTABLE_SIZE (nsyms); + DICT_HASHED_NBUCKETS (retval) = nbuckets; + buckets = obstack_alloc (obstack, nbuckets * sizeof (struct symbol *)); + memset (buckets, 0, nbuckets * sizeof (struct symbol *)); + DICT_HASHED_BUCKETS (retval) = buckets; + + /* Now fill the buckets. */ + for (list_counter = symbol_list; + list_counter != NULL; + list_counter = list_counter->next) + { + for (i = list_counter->nsyms - 1; i >= 0; --i) + { + insert_symbol_hashed (retval, list_counter->symbol[i]); + } + } + + return retval; +} + +/* Create a dictionary 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. */ + +extern struct dictionary * +dict_create_hashed_expandable (void) +{ + struct dictionary *retval; + + retval = xmalloc (sizeof (struct dictionary)); + DICT_VECTOR (retval) = &dict_hashed_expandable_vector; + DICT_HASHED_NBUCKETS (retval) = DICT_EXPANDABLE_INITIAL_CAPACITY; + DICT_HASHED_BUCKETS (retval) = xcalloc (DICT_EXPANDABLE_INITIAL_CAPACITY, + sizeof (struct symbol *)); + DICT_HASHED_EXPANDABLE_NSYMS (retval) = 0; + + return retval; +} + +/* Create a dictionary 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. */ + +struct dictionary * +dict_create_linear (struct obstack *obstack, + const struct pending *symbol_list) +{ + struct dictionary *retval; + int nsyms = 0, i, j; + struct symbol **syms; + const struct pending *list_counter; + + retval = obstack_alloc (obstack, sizeof (struct dictionary)); + DICT_VECTOR (retval) = &dict_linear_vector; + + /* Calculate the number of symbols, and allocate space for them. */ + for (list_counter = symbol_list; + list_counter != NULL; + list_counter = list_counter->next) + { + nsyms += list_counter->nsyms; + } + DICT_LINEAR_NSYMS (retval) = nsyms; + syms = obstack_alloc (obstack, nsyms * sizeof (struct symbol *)); + DICT_LINEAR_SYMS (retval) = syms; + + /* Now fill in the symbols. Start filling in from the back, so as + to preserve the original order of the symbols. */ + for (list_counter = symbol_list, j = nsyms - 1; + list_counter != NULL; + list_counter = list_counter->next) + { + for (i = list_counter->nsyms - 1; + i >= 0; + --i, --j) + { + syms[j] = list_counter->symbol[i]; + } + } + + return retval; +} + +/* Create a dictionary 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. */ + +struct dictionary * +dict_create_linear_expandable (void) +{ + struct dictionary *retval; + + retval = xmalloc (sizeof (struct dictionary)); + DICT_VECTOR (retval) = &dict_linear_expandable_vector; + DICT_LINEAR_NSYMS (retval) = 0; + DICT_LINEAR_EXPANDABLE_CAPACITY (retval) + = DICT_EXPANDABLE_INITIAL_CAPACITY; + DICT_LINEAR_SYMS (retval) + = xmalloc (DICT_LINEAR_EXPANDABLE_CAPACITY (retval) + * sizeof (struct symbol *)); + + return retval; +} + +/* The functions providing the dictionary interface. */ + +/* Free the memory used by a dictionary that's not on an obstack. (If + any.) */ + +void +dict_free (struct dictionary *dict) +{ + (DICT_VECTOR (dict))->free (dict); +} + +/* Add SYM to DICT. DICT had better be expandable. */ + +void +dict_add_symbol (struct dictionary *dict, struct symbol *sym) +{ + (DICT_VECTOR (dict))->add_symbol (dict, sym); +} + +/* Initialize ITERATOR to point at the first symbol in DICT, and + return that first symbol, or NULL if DICT is empty. */ + +struct symbol * +dict_iterator_first (const struct dictionary *dict, + struct dict_iterator *iterator) +{ + return (DICT_VECTOR (dict))->iterator_first (dict, iterator); +} + +/* Advance ITERATOR, and return the next symbol, or NULL if there are + no more symbols. */ + +struct symbol * +dict_iterator_next (struct dict_iterator *iterator) +{ + return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator))) + ->iterator_next (iterator); +} + +struct symbol * +dict_iter_name_first (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator) +{ + return (DICT_VECTOR (dict))->iter_name_first (dict, name, iterator); +} + +struct symbol * +dict_iter_name_next (const char *name, struct dict_iterator *iterator) +{ + return (DICT_VECTOR (DICT_ITERATOR_DICT (iterator))) + ->iter_name_next (name, iterator); +} + +int +dict_size (const struct dictionary *dict) +{ + return (DICT_VECTOR (dict))->size (dict); +} + +/* Now come functions (well, one function, currently) that are + implemented generically by means of the vtable. Typically, they're + rarely used. */ + +/* Test to see if DICT is empty. */ + +int +dict_empty (struct dictionary *dict) +{ + struct dict_iterator iter; + + return (dict_iterator_first (dict, &iter) == NULL); +} + + +/* The functions implementing the dictionary interface. */ + +/* Generic functions, where appropriate. */ + +static void +free_obstack (struct dictionary *dict) +{ + /* Do nothing! */ +} + +static void +add_symbol_nonexpandable (struct dictionary *dict, struct symbol *sym) +{ + internal_error (__FILE__, __LINE__, + "dict_add_symbol: non-expandable dictionary"); +} + +/* Functions for DICT_HASHED and DICT_HASHED_EXPANDABLE. */ + +static struct symbol * +iterator_first_hashed (const struct dictionary *dict, + struct dict_iterator *iterator) +{ + DICT_ITERATOR_DICT (iterator) = dict; + DICT_ITERATOR_INDEX (iterator) = -1; + return iterator_hashed_advance (iterator); +} + +static struct symbol * +iterator_next_hashed (struct dict_iterator *iterator) +{ + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); + struct symbol *next; + + next = DICT_ITERATOR_CURRENT (iterator)->hash_next; + + if (next == NULL) + return iterator_hashed_advance (iterator); + else + { + DICT_ITERATOR_CURRENT (iterator) = next; + return next; + } +} + +static struct symbol * +iterator_hashed_advance (struct dict_iterator *iterator) +{ + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); + int nbuckets = DICT_HASHED_NBUCKETS (dict); + int i; + + for (i = DICT_ITERATOR_INDEX (iterator) + 1; i < nbuckets; ++i) + { + struct symbol *sym = DICT_HASHED_BUCKET (dict, i); + + if (sym != NULL) + { + DICT_ITERATOR_INDEX (iterator) = i; + DICT_ITERATOR_CURRENT (iterator) = sym; + return sym; + } + } + + return NULL; +} + +static struct symbol * +iter_name_first_hashed (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator) +{ + unsigned int hash_index + = msymbol_hash_iw (name) % DICT_HASHED_NBUCKETS (dict); + struct symbol *sym; + + DICT_ITERATOR_DICT (iterator) = dict; + + /* Loop through the symbols in the given bucket, breaking when SYM + first matches. If SYM never matches, it will be set to NULL; + either way, we have the right return value. */ + + for (sym = DICT_HASHED_BUCKET (dict, hash_index); + sym != NULL; + sym = sym->hash_next) + { + /* Warning: the order of arguments to strcmp_iw matters! */ + if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0) + { + break; + } + + } + + DICT_ITERATOR_CURRENT (iterator) = sym; + return sym; +} + +static struct symbol * +iter_name_next_hashed (const char *name, struct dict_iterator *iterator) +{ + struct symbol *next; + + for (next = DICT_ITERATOR_CURRENT (iterator)->hash_next; + next != NULL; + next = next->hash_next) + { + if (strcmp_iw (SYMBOL_NATURAL_NAME (next), name) == 0) + break; + } + + DICT_ITERATOR_CURRENT (iterator) = next; + + return next; +} + +/* Insert SYM into DICT. */ + +static void +insert_symbol_hashed (struct dictionary *dict, + struct symbol *sym) +{ + unsigned int hash_index; + struct symbol **buckets = DICT_HASHED_BUCKETS (dict); + + hash_index = (msymbol_hash_iw (SYMBOL_NATURAL_NAME (sym)) + % DICT_HASHED_NBUCKETS (dict)); + sym->hash_next = buckets[hash_index]; + buckets[hash_index] = sym; +} + +static int +size_hashed (const struct dictionary *dict) +{ + return DICT_HASHED_NBUCKETS (dict); +} + +/* Functions only for DICT_HASHED_EXPANDABLE. */ + +static void +free_hashed_expandable (struct dictionary *dict) +{ + xfree (DICT_HASHED_BUCKETS (dict)); + xfree (dict); +} + +static void +add_symbol_hashed_expandable (struct dictionary *dict, + struct symbol *sym) +{ + int nsyms = ++DICT_HASHED_EXPANDABLE_NSYMS (dict); + + if (DICT_HASHTABLE_SIZE (nsyms) > DICT_HASHED_NBUCKETS (dict)) + expand_hashtable (dict); + + insert_symbol_hashed (dict, sym); + DICT_HASHED_EXPANDABLE_NSYMS (dict) = nsyms; +} + +static int +size_hashed_expandable (const struct dictionary *dict) +{ + return DICT_HASHED_EXPANDABLE_NSYMS (dict); +} + +static void +expand_hashtable (struct dictionary *dict) +{ + int old_nbuckets = DICT_HASHED_NBUCKETS (dict); + struct symbol **old_buckets = DICT_HASHED_BUCKETS (dict); + int new_nbuckets = 2*old_nbuckets + 1; + struct symbol **new_buckets = xcalloc (new_nbuckets, + sizeof (struct symbol *)); + int i; + + DICT_HASHED_NBUCKETS (dict) = new_nbuckets; + DICT_HASHED_BUCKETS (dict) = new_buckets; + + for (i = 0; i < old_nbuckets; ++i) { + struct symbol *sym, *next_sym; + + sym = old_buckets[i]; + if (sym != NULL) { + for (next_sym = sym->hash_next; + next_sym != NULL; + next_sym = sym->hash_next) { + insert_symbol_hashed (dict, sym); + sym = next_sym; + } + + insert_symbol_hashed (dict, sym); + } + } + + xfree (old_buckets); +} + +/* Functions for DICT_LINEAR and DICT_LINEAR_EXPANDABLE. */ + +static struct symbol * +iterator_first_linear (const struct dictionary *dict, + struct dict_iterator *iterator) +{ + DICT_ITERATOR_DICT (iterator) = dict; + DICT_ITERATOR_INDEX (iterator) = 0; + return DICT_LINEAR_NSYMS (dict) ? DICT_LINEAR_SYM (dict, 0) : NULL; +} + +static struct symbol * +iterator_next_linear (struct dict_iterator *iterator) +{ + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); + + if (++DICT_ITERATOR_INDEX (iterator) >= DICT_LINEAR_NSYMS (dict)) + return NULL; + else + return DICT_LINEAR_SYM (dict, DICT_ITERATOR_INDEX (iterator)); +} + +static struct symbol * +iter_name_first_linear (const struct dictionary *dict, + const char *name, + struct dict_iterator *iterator) +{ + DICT_ITERATOR_DICT (iterator) = dict; + DICT_ITERATOR_INDEX (iterator) = -1; + + return iter_name_next_linear (name, iterator); +} + +static struct symbol * +iter_name_next_linear (const char *name, struct dict_iterator *iterator) +{ + const struct dictionary *dict = DICT_ITERATOR_DICT (iterator); + int i, nsyms = DICT_LINEAR_NSYMS (dict); + struct symbol *sym, *retval = NULL; + + for (i = DICT_ITERATOR_INDEX (iterator) + 1; i < nsyms; ++i) + { + sym = DICT_LINEAR_SYM (dict, i); + if (strcmp_iw (SYMBOL_NATURAL_NAME (sym), name) == 0) + { + retval = sym; + break; + } + } + + DICT_ITERATOR_INDEX (iterator) = i; + + return retval; +} + +static int +size_linear (const struct dictionary *dict) +{ + return DICT_LINEAR_NSYMS (dict); +} + +/* Functions only for DICT_LINEAR_EXPANDABLE. */ + +static void +free_linear_expandable (struct dictionary *dict) +{ + xfree (DICT_LINEAR_SYMS (dict)); + xfree (dict); +} + + +static void +add_symbol_linear_expandable (struct dictionary *dict, + struct symbol *sym) +{ + int nsyms = ++DICT_LINEAR_NSYMS (dict); + + /* Do we have enough room? If not, grow it. */ + if (nsyms > DICT_LINEAR_EXPANDABLE_CAPACITY (dict)) { + DICT_LINEAR_EXPANDABLE_CAPACITY (dict) *= 2; + DICT_LINEAR_SYMS (dict) + = xrealloc (DICT_LINEAR_SYMS (dict), + DICT_LINEAR_EXPANDABLE_CAPACITY (dict) + * sizeof (struct symbol *)); + } + + DICT_LINEAR_SYM (dict, nsyms - 1) = sym; +} Index: Makefile.in =================================================================== RCS file: /cvs/src/src/gdb/Makefile.in,v retrieving revision 1.398 diff -u -p -r1.398 Makefile.in --- Makefile.in 11 Jun 2003 13:50:11 -0000 1.398 +++ Makefile.in 11 Jun 2003 23:25:24 -0000 @@ -513,7 +513,7 @@ SFILES = ada-exp.y ada-lang.c ada-typepr charset.c cli-out.c coffread.c coff-pe-read.c \ complaints.c completer.c corefile.c \ cp-abi.c cp-support.c cp-namespace.c cp-valprint.c \ - dbxread.c demangle.c disasm.c doublest.c dummy-frame.c \ + dbxread.c demangle.c dictionary.c disasm.c doublest.c dummy-frame.c \ dwarfread.c dwarf2expr.c dwarf2loc.c dwarf2read.c dwarf2-frame.c \ elfread.c environ.c eval.c event-loop.c event-top.c expprint.c \ f-exp.y f-lang.c f-typeprint.c f-valprint.c findvar.c frame.c \ @@ -633,6 +633,7 @@ dcache_h = dcache.h defs_h = defs.h $(config_h) $(gdb_locale_h) $(gdb_signals_h) $(ansidecl_h) \ $(libiberty_h) $(progress_h) $(bfd_h) $(tui_h) $(ui_file_h) $(xm_h) \ $(nm_h) $(tm_h) $(fopen_same_h) $(gdbarch_h) $(arch_utils_h) +dictionary_h = dictionary.h disasm_h = disasm.h doublest_h = doublest.h $(floatformat_h) dst_h = dst.h @@ -843,7 +844,7 @@ TAGFILES_WITH_SRCDIR = $(HFILES_WITH_SRC COMMON_OBS = version.o blockframe.o breakpoint.o findvar.o regcache.o \ charset.o disasm.o dummy-frame.o \ source.o values.o eval.o valops.o valarith.o valprint.o printcmd.o \ - block.o symtab.o symfile.o symmisc.o linespec.o \ + block.o symtab.o symfile.o symmisc.o linespec.o dictionary.o \ infcall.o \ infcmd.o infrun.o \ expprint.o environ.o stack.o thread.o \ @@ -1501,7 +1502,7 @@ ada-lang.o: ada-lang.c $(gdb_string_h) $ $(gdbtypes_h) $(gdbcmd_h) $(expression_h) $(parser_defs_h) \ $(language_h) $(c_lang_h) $(inferior_h) $(symfile_h) $(objfiles_h) \ $(breakpoint_h) $(gdbcore_h) $(ada_lang_h) $(ui_out_h) $(block_h) \ - $(infcall_h) + $(infcall_h) $(dictionary_h) ada-tasks.o: ada-tasks.c $(defs_h) $(command_h) $(value_h) $(language_h) \ $(inferior_h) $(symtab_h) $(target_h) $(gdbcore_h) $(gregset_h) \ $(ada_lang_h) @@ -1586,7 +1587,7 @@ buildsym.o: buildsym.c $(defs_h) $(bfd_h $(symfile_h) $(objfiles_h) $(gdbtypes_h) $(gdb_assert_h) \ $(complaints_h) $(gdb_string_h) $(expression_h) $(language_h) \ $(bcache_h) $(filenames_h) $(macrotab_h) $(demangle_h) $(buildsym_h) \ - $(stabsread_h) $(block_h) $(cp_support_h) + $(stabsread_h) $(block_h) $(cp_support_h) $(dictionary_h) builtin-regs.o: builtin-regs.c $(defs_h) $(builtin_regs_h) $(gdbtypes_h) \ $(gdb_string_h) $(gdb_assert_h) c-lang.o: c-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \ @@ -1610,7 +1611,8 @@ coffread.o: coffread.c $(defs_h) $(symta $(breakpoint_h) $(bfd_h) $(gdb_obstack_h) $(gdb_string_h) \ $(coff_internal_h) $(libcoff_h) $(symfile_h) $(objfiles_h) \ $(buildsym_h) $(gdb_stabs_h) $(stabsread_h) $(complaints_h) \ - $(target_h) $(gdb_assert_h) $(block_h) $(coff_pe_read_h) + $(target_h) $(gdb_assert_h) $(block_h) $(dictionary_h) \ + $(coff_pe_read_h) coff-pe-read.o: coff-pe-read.c $(bfd_h) $(defs_h) $(symtab_h) \ $(gdbtypes_h) $(symfile_h) $(objfiles_h) $(coff_pe_read_h) complaints.o: complaints.c $(defs_h) $(complaints_h) $(gdb_assert_h) \ @@ -1664,6 +1666,8 @@ dcache.o: dcache.c $(defs_h) $(dcache_h) delta68-nat.o: delta68-nat.c $(defs_h) demangle.o: demangle.c $(defs_h) $(command_h) $(gdbcmd_h) $(demangle_h) \ $(gdb_string_h) +dictionary.o: dictionary.c $(defs_h) $(gdb_obstack_h) $(symtab_h) \ + $(buildsym_h) $(gdb_assert_h) $(dictionary_h) dink32-rom.o: dink32-rom.c $(defs_h) $(gdbcore_h) $(target_h) $(monitor_h) \ $(serial_h) $(symfile_h) $(inferior_h) $(regcache_h) disasm.o: disasm.c $(defs_h) $(gdb_string_h) $(target_h) $(value_h) \ @@ -1886,7 +1890,7 @@ irix5-nat.o: irix5-nat.c $(defs_h) $(inf jv-lang.o: jv-lang.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(expression_h) \ $(parser_defs_h) $(language_h) $(gdbtypes_h) $(symtab_h) \ $(symfile_h) $(objfiles_h) $(gdb_string_h) $(value_h) $(c_lang_h) \ - $(jv_lang_h) $(gdbcore_h) $(block_h) $(demangle_h) + $(jv_lang_h) $(gdbcore_h) $(block_h) $(demangle_h) $(dictionary_h) jv-typeprint.o: jv-typeprint.c $(defs_h) $(symtab_h) $(gdbtypes_h) \ $(value_h) $(demangle_h) $(jv_lang_h) $(gdb_string_h) $(typeprint_h) \ $(c_lang_h) $(cp_abi_h) @@ -1967,7 +1971,7 @@ mcore-tdep.o: mcore-tdep.c $(defs_h) $(f mdebugread.o: mdebugread.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \ $(symfile_h) $(objfiles_h) $(gdb_obstack_h) $(buildsym_h) \ $(stabsread_h) $(complaints_h) $(demangle_h) $(gdb_assert_h) \ - $(block_h) \ + $(block_h) $(dictionary_h) \ $(coff_sym_h) $(coff_symconst_h) $(gdb_stat_h) $(gdb_string_h) \ $(bfd_h) $(coff_ecoff_h) $(libaout_h) $(aout_aout64_h) \ $(aout_stab_gnu_h) $(expression_h) $(language_h) @@ -2028,7 +2032,7 @@ objc-lang.o: objc-lang.c $(defs_h) $(sym objfiles.o: objfiles.c $(defs_h) $(bfd_h) $(symtab_h) $(symfile_h) \ $(objfiles_h) $(gdb_stabs_h) $(target_h) $(bcache_h) $(gdb_stat_h) \ $(gdb_obstack_h) $(gdb_string_h) $(breakpoint_h) $(mmalloc_h) \ - $(block_h) + $(block_h) $(dictionary_h) observer.o: observer.c $(observer_h) $(defs_h) ocd.o: ocd.c $(defs_h) $(gdbcore_h) $(gdb_string_h) $(frame_h) $(inferior_h) \ $(bfd_h) $(symfile_h) $(target_h) $(gdbcmd_h) $(objfiles_h) \ @@ -2270,7 +2274,7 @@ stack.o: stack.c $(defs_h) $(gdb_string_ $(gdbtypes_h) $(expression_h) $(language_h) $(frame_h) $(gdbcmd_h) \ $(gdbcore_h) $(target_h) $(source_h) $(breakpoint_h) $(demangle_h) \ $(inferior_h) $(annotate_h) $(ui_out_h) $(block_h) $(stack_h) \ - $(gdb_assert_h) + $(gdb_assert_h) $(dictionary_h) standalone.o: standalone.c $(gdb_stat_h) $(defs_h) $(symtab_h) $(frame_h) \ $(inferior_h) $(gdb_wait_h) std-regs.o: std-regs.c $(defs_h) $(builtin_regs_h) $(frame_h) $(gdbtypes_h) \ @@ -2291,13 +2295,13 @@ symm-tdep.o: symm-tdep.c $(defs_h) $(fra symmisc.o: symmisc.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(bfd_h) \ $(symfile_h) $(objfiles_h) $(breakpoint_h) $(command_h) \ $(gdb_obstack_h) $(language_h) $(bcache_h) $(gdb_string_h) \ - $(readline_h) $(block_h) $(gdb_regex_h) + $(readline_h) $(block_h) $(gdb_regex_h) $(dictionary_h) symtab.o: symtab.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(gdbcore_h) \ $(frame_h) $(target_h) $(value_h) $(symfile_h) $(objfiles_h) \ $(gdbcmd_h) $(call_cmds_h) $(gdb_regex_h) $(expression_h) \ $(language_h) $(demangle_h) $(inferior_h) $(linespec_h) \ $(filenames_h) $(gdb_obstack_h) $(gdb_string_h) $(gdb_stat_h) \ - $(cp_abi_h) $(source_h) $(block_h) $(objc_lang_h) + $(cp_abi_h) $(source_h) $(block_h) $(objc_lang_h) $(dictionary_h) target.o: target.c $(defs_h) $(gdb_string_h) $(target_h) $(gdbcmd_h) \ $(symtab_h) $(inferior_h) $(bfd_h) $(symfile_h) $(objfiles_h) \ $(gdb_wait_h) $(dcache_h) $(regcache_h) @@ -2318,7 +2322,7 @@ tracepoint.o: tracepoint.c $(defs_h) $(s $(expression_h) $(gdbcmd_h) $(value_h) $(target_h) $(language_h) \ $(gdb_string_h) $(inferior_h) $(tracepoint_h) $(remote_h) \ $(linespec_h) $(regcache_h) $(completer_h) $(gdb_events_h) \ - $(block_h) $(ax_h) $(ax_gdb_h) $(readline_h) + $(block_h) $(ax_h) $(ax_gdb_h) $(readline_h) $(dictionary_h) trad-frame.o: trad-frame.c $(defs_h) $(frame_h) $(trad_frame_h) $(regcache_h) typeprint.o: typeprint.c $(defs_h) $(gdb_obstack_h) $(bfd_h) $(symtab_h) \ $(gdbtypes_h) $(expression_h) $(value_h) $(gdbcore_h) $(command_h) \ @@ -2345,7 +2349,7 @@ valarith.o: valarith.c $(defs_h) $(value valops.o: valops.c $(defs_h) $(symtab_h) $(gdbtypes_h) $(value_h) $(frame_h) \ $(inferior_h) $(gdbcore_h) $(target_h) $(demangle_h) $(language_h) \ $(gdbcmd_h) $(regcache_h) $(cp_abi_h) $(gdb_string_h) \ - $(gdb_assert_h) $(block_h) + $(gdb_assert_h) $(block_h) $(dictionary_h) valprint.o: valprint.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \ $(value_h) $(gdbcore_h) $(gdbcmd_h) $(target_h) $(language_h) \ $(annotate_h) $(valprint_h) $(floatformat_h) $(doublest_h) @@ -2514,9 +2518,10 @@ gdbtk-bp.o: $(srcdir)/gdbtk/generic/gdbt gdbtk-cmds.o: $(srcdir)/gdbtk/generic/gdbtk-cmds.c \ $(srcdir)/gdbtk/generic/gdbtk.h $(srcdir)/gdbtk/generic/gdbtk-cmds.h \ - $(defs_h) $(symtab_h) $(inferior_h) \ - $(command_h) $(bfd_h) $(top_h) $(symfile_h) $(objfiles_h) $(target_h) \ - $(gdb_string_h) $(tracepoint_h) $(source_h) $(regcache_h) + $(defs_h) $(inferior_h) $(source_h) $(symfile_h) $(objfiles_h) \ + $(gdbcore_h) $(demangle_h) $(linespec_h) $(tui_file_h) $(top_h) \ + $(annotate_h) $(block_h) $(dictionary_h) $(gdb_string_h) \ + $(dis_asm_h) $(gdbcmd_h) $(CC) -c $(INTERNAL_CFLAGS) $(IDE_CFLAGS) $(ITCL_CFLAGS) \ $(TCL_CFLAGS) $(TK_CFLAGS) $(X11_CFLAGS) \ $(GDBTK_CFLAGS) $(srcdir)/gdbtk/generic/gdbtk-cmds.c \ @@ -2557,8 +2562,8 @@ gdbtk-register.o: $(srcdir)/gdbtk/generi gdbtk-stack.o: $(srcdir)/gdbtk/generic/gdbtk-stack.c \ $(srcdir)/gdbtk/generic/gdbtk.h $(srcdir)/gdbtk/generic/gdbtk-cmds.h \ $(srcdir)/gdbtk/generic/gdbtk-wrapper.h \ - $(defs_h) $(frame_h) $(value_h) $(target_h) $(breakpoint_h) \ - $(linespec_h) + $(defs_h) $(target_h) $(breakpoint_h) $(linespec_h) \ + $(block_h) $(dictionary_h) $(CC) -c $(INTERNAL_CFLAGS) $(IDE_CFLAGS) $(ITCL_CFLAGS) \ $(TCL_CFLAGS) $(TK_CFLAGS) $(X11_CFLAGS) \ $(GDBTK_CFLAGS) $(srcdir)/gdbtk/generic/gdbtk-stack.c \ @@ -2599,7 +2604,8 @@ mi-cmd-env.o: $(srcdir)/mi/mi-cmd-env.c $(environ_h) $(command_h) $(ui_out_h) $(top_h) $(gdb_string_h) $(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-env.c mi-cmd-stack.o: $(srcdir)/mi/mi-cmd-stack.c $(defs_h) $(target_h) $(frame_h) \ - $(value_h) $(mi_cmds_h) $(ui_out_h) $(symtab_h) $(block_h) $(stack_h) + $(value_h) $(mi_cmds_h) $(ui_out_h) $(symtab_h) $(block_h) $(stack_h) \ + $(dictionary_h) $(CC) -c $(INTERNAL_CFLAGS) $(srcdir)/mi/mi-cmd-stack.c mi-cmd-var.o: $(srcdir)/mi/mi-cmd-var.c $(defs_h) $(mi_cmds_h) $(ui_out_h) \ $(mi_out_h) $(varobj_h) $(value_h) $(gdb_string_h) Index: ada-lang.c =================================================================== RCS file: /cvs/src/src/gdb/ada-lang.c,v retrieving revision 1.28 diff -u -p -r1.28 ada-lang.c --- ada-lang.c 11 Jun 2003 22:27:07 -0000 1.28 +++ ada-lang.c 11 Jun 2003 23:25:32 -0000 @@ -40,6 +40,7 @@ Foundation, Inc., 675 Mass Ave, Cambridg #include "ui-out.h" #include "block.h" #include "infcall.h" +#include "dictionary.h" struct cleanup *unresolved_names; @@ -3433,7 +3434,8 @@ symtab_for_sym (struct symbol *sym) struct objfile *objfile; struct block *b; struct symbol *tmp_sym; - int i, j; + struct dict_iterator iter; + int j; ALL_SYMTABS (objfile, s) { @@ -3447,10 +3449,10 @@ symtab_for_sym (struct symbol *sym) case LOC_BLOCK: case LOC_CONST_BYTES: b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) return s; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) return s; break; default: @@ -3474,7 +3476,7 @@ symtab_for_sym (struct symbol *sym) j < BLOCKVECTOR_NBLOCKS (BLOCKVECTOR (s)); j += 1) { b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), j); - ALL_BLOCK_SYMBOLS (b, i, tmp_sym) if (sym == tmp_sym) + ALL_BLOCK_SYMBOLS (b, iter, tmp_sym) if (sym == tmp_sym) return s; } break; @@ -3947,7 +3949,7 @@ ada_add_block_symbols (struct block *blo domain_enum domain, struct objfile *objfile, int wild) { - int i; + struct dict_iterator iter; int name_len = strlen (name); /* A matching argument symbol, if any. */ struct symbol *arg_sym; @@ -3960,7 +3962,7 @@ ada_add_block_symbols (struct block *blo if (wild) { struct symbol *sym; - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { if (SYMBOL_DOMAIN (sym) == domain && wild_match (name, name_len, DEPRECATED_SYMBOL_NAME (sym))) @@ -3989,7 +3991,7 @@ ada_add_block_symbols (struct block *blo } else { - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { if (SYMBOL_DOMAIN (sym) == domain) { @@ -4034,7 +4036,7 @@ ada_add_block_symbols (struct block *blo arg_sym = NULL; found_sym = 0; - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { struct symbol *sym = BLOCK_SYM (block, i); @@ -4098,7 +4100,7 @@ fill_in_ada_prototype (struct symbol *fu { struct block *b; int nargs, nsyms; - int i; + struct dict_iterator iter; struct type *ftype; struct type *rtype; size_t max_fields; @@ -4124,7 +4126,7 @@ fill_in_ada_prototype (struct symbol *fu max_fields = 8; TYPE_FIELDS (ftype) = (struct field *) xmalloc (sizeof (struct field) * max_fields); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { GROW_VECT (TYPE_FIELDS (ftype), max_fields, nargs + 1); @@ -4697,8 +4699,8 @@ debug_print_lines (struct linetable *lt) static void debug_print_block (struct block *b) { - int i; - struct symbol *i; + struct dict_iterator iter; + struct symbol *sym; fprintf (stderr, "Block: %p; [0x%lx, 0x%lx]", b, BLOCK_START (b), BLOCK_END (b)); @@ -4707,10 +4709,8 @@ debug_print_block (struct block *b) fprintf (stderr, "\n"); fprintf (stderr, "\t Superblock: %p\n", BLOCK_SUPERBLOCK (b)); fprintf (stderr, "\t Symbols:"); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { - if (i > 0 && i % 4 == 0) - fprintf (stderr, "\n\t\t "); fprintf (stderr, " %s", DEPRECATED_SYMBOL_NAME (sym)); } fprintf (stderr, "\n"); Index: block.h =================================================================== RCS file: /cvs/src/src/gdb/block.h,v retrieving revision 1.7 diff -u -p -r1.7 block.h --- block.h 11 Jun 2003 22:27:08 -0000 1.7 +++ block.h 11 Jun 2003 23:25:32 -0000 @@ -29,6 +29,7 @@ struct symtab; struct block_namespace_info; struct using_direct; struct obstack; +struct dictionary; /* All of the name-scope contours of the program are represented by `struct block' objects. @@ -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 @@ -104,34 +109,6 @@ struct block 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; - - /* Number of local symbols. */ - - int nsyms; - - /* The symbols. If some of them are arguments, then they must be - in the order in which we would like to print them. */ - - struct symbol *sym[1]; }; #define BLOCK_START(bl) (bl)->startaddr @@ -139,28 +116,15 @@ struct block #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) +/* 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 { Index: buildsym.c =================================================================== RCS file: /cvs/src/src/gdb/buildsym.c,v retrieving revision 1.32 diff -u -p -r1.32 buildsym.c --- buildsym.c 15 Apr 2003 23:07:11 -0000 1.32 +++ buildsym.c 11 Jun 2003 23:25:34 -0000 @@ -45,6 +45,7 @@ #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ #include "block.h" #include "cp-support.h" +#include "dictionary.h" /* Ask buildsym.h to define the vars it normally declares `extern'. */ #define EXTERN @@ -229,62 +230,22 @@ finish_block (struct symbol *symbol, str register struct block *block; register struct pending_block *pblock; struct pending_block *opblock; - register int i; - register int j; - - /* Count the length of the list of symbols. */ - - for (next = *listhead, i = 0; - next; - i += next->nsyms, next = next->next) - { - /* EMPTY */ ; - } - /* Copy the symbols into the block. */ + /* Initialize the block's dictionary. */ if (symbol) { block = (struct block *) - obstack_alloc (&objfile->symbol_obstack, - (sizeof (struct block) + - ((i - 1) * sizeof (struct symbol *)))); - BLOCK_NSYMS (block) = i; - for (next = *listhead; next; next = next->next) - for (j = next->nsyms - 1; j >= 0; j--) - { - BLOCK_SYM (block, --i) = next->symbol[j]; - } + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); + BLOCK_DICT (block) = dict_create_linear (&objfile->symbol_obstack, + *listhead); } else { - int htab_size = BLOCK_HASHTABLE_SIZE (i); - block = (struct block *) - obstack_alloc (&objfile->symbol_obstack, - (sizeof (struct block) + - ((htab_size - 1) * sizeof (struct symbol *)))); - for (j = 0; j < htab_size; j++) - { - BLOCK_BUCKET (block, j) = 0; - } - BLOCK_BUCKETS (block) = htab_size; - for (next = *listhead; next; next = next->next) - { - for (j = next->nsyms - 1; j >= 0; j--) - { - struct symbol *sym; - unsigned int hash_index; - const char *name = SYMBOL_DEMANGLED_NAME (next->symbol[j]); - if (name == NULL) - name = DEPRECATED_SYMBOL_NAME (next->symbol[j]); - hash_index = msymbol_hash_iw (name); - hash_index = hash_index % BLOCK_BUCKETS (block); - sym = BLOCK_BUCKET (block, hash_index); - BLOCK_BUCKET (block, hash_index) = next->symbol[j]; - next->symbol[j]->hash_next = sym; - } - } + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); + BLOCK_DICT (block) = dict_create_hashed (&objfile->symbol_obstack, + *listhead); } BLOCK_START (block) = start; @@ -300,9 +261,9 @@ finish_block (struct symbol *symbol, str if (symbol) { struct type *ftype = SYMBOL_TYPE (symbol); + struct dict_iterator iter; SYMBOL_BLOCK_VALUE (symbol) = block; BLOCK_FUNCTION (block) = symbol; - BLOCK_HASHTABLE (block) = 0; if (TYPE_NFIELDS (ftype) <= 0) { @@ -311,7 +272,7 @@ finish_block (struct symbol *symbol, str parameter symbols. */ int nparams = 0, iparams; struct symbol *sym; - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { switch (SYMBOL_CLASS (sym)) { @@ -348,9 +309,12 @@ finish_block (struct symbol *symbol, str TYPE_FIELDS (ftype) = (struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field)); - for (i = iparams = 0; iparams < nparams; i++) + iparams = 0; + ALL_BLOCK_SYMBOLS (block, iter, sym) { - sym = BLOCK_SYM (block, i); + if (iparams == nparams) + break; + switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -394,7 +358,6 @@ finish_block (struct symbol *symbol, str else { BLOCK_FUNCTION (block) = NULL; - BLOCK_HASHTABLE (block) = 1; } /* Now "free" the links of the list, and empty the list. */ @@ -476,6 +439,7 @@ finish_block (struct symbol *symbol, str record_pending_block (objfile, block, opblock); } + /* Record BLOCK on the list of all blocks in the file. Put it after OPBLOCK, or at the beginning if opblock is NULL. This puts the block in the list after all its subblocks. @@ -1031,7 +995,7 @@ end_symtab (CORE_ADDR end_addr, struct o symtab->dirname = NULL; } symtab->free_code = free_linetable; - symtab->free_ptr = NULL; + symtab->free_func = NULL; /* Use whatever language we have been using for this subfile, not the one that was deduced in allocate_symtab Index: coffread.c =================================================================== RCS file: /cvs/src/src/gdb/coffread.c,v retrieving revision 1.40 diff -u -p -r1.40 coffread.c --- coffread.c 11 Jun 2003 22:27:09 -0000 1.40 +++ coffread.c 11 Jun 2003 23:25:36 -0000 @@ -45,6 +45,7 @@ #include "target.h" #include "gdb_assert.h" #include "block.h" +#include "dictionary.h" #include "coff-pe-read.h" @@ -1414,12 +1415,12 @@ static void patch_opaque_types (struct symtab *s) { register struct block *b; - register int i; + struct dict_iterator iter; register struct symbol *real_sym; /* Go through the per-file symbols only */ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, real_sym) + ALL_BLOCK_SYMBOLS (b, iter, real_sym) { /* Find completed typedefs to use to fix opaque ones. Remove syms from the chain when their types are stored, Index: hpread.c =================================================================== RCS file: /cvs/src/src/gdb/hpread.c,v retrieving revision 1.37 diff -u -p -r1.37 hpread.c --- hpread.c 11 Jun 2003 22:27:12 -0000 1.37 +++ hpread.c 11 Jun 2003 23:25:43 -0000 @@ -2711,6 +2711,7 @@ hpread_psymtab_to_symtab_1 (struct parti hpread_expand_symtab (pst->objfile, LDSYMOFF (pst), LDSYMLEN (pst), pst->textlow, pst->texthigh - pst->textlow, pst->section_offsets, pst->filename); + sort_symtab_syms (pst->symtab); do_cleanups (old_chain); } Index: jv-lang.c =================================================================== RCS file: /cvs/src/src/gdb/jv-lang.c,v retrieving revision 1.20 diff -u -p -r1.20 jv-lang.c --- jv-lang.c 20 May 2003 01:55:17 -0000 1.20 +++ jv-lang.c 11 Jun 2003 23:25:44 -0000 @@ -35,6 +35,7 @@ #include "gdbcore.h" #include "block.h" #include "demangle.h" +#include "dictionary.h" #include <ctype.h> struct type *java_int_type; @@ -91,9 +92,7 @@ get_dynamics_objfile (void) static struct symtab *class_symtab = NULL; -/* Maximum number of class in class_symtab before relocation is needed. */ - -static int class_symtab_space; +static void free_class_block (struct symtab *symtab); static struct symtab * get_java_class_symtab (void) @@ -106,15 +105,16 @@ get_java_class_symtab (void) class_symtab = allocate_symtab ("<java-classes>", objfile); class_symtab->language = language_java; bv = (struct blockvector *) - obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector)); + obstack_alloc (&objfile->symbol_obstack, + sizeof (struct blockvector) + sizeof (struct block *)); BLOCKVECTOR_NBLOCKS (bv) = 1; BLOCKVECTOR (class_symtab) = bv; /* Allocate dummy STATIC_BLOCK. */ bl = (struct block *) obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); - BLOCK_NSYMS (bl) = 0; - BLOCK_HASHTABLE (bl) = 0; + BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack, + NULL); BLOCK_START (bl) = 0; BLOCK_END (bl) = 0; BLOCK_FUNCTION (bl) = NULL; @@ -124,13 +124,12 @@ get_java_class_symtab (void) BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl; /* Allocate GLOBAL_BLOCK. This has to be relocatable. */ - class_symtab_space = 128; - bl = xmmalloc (objfile->md, - sizeof (struct block) - + ((class_symtab_space - 1) * sizeof (struct symbol *))); + bl = (struct block *) + obstack_alloc (&objfile->symbol_obstack, sizeof (struct block)); *bl = *BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); + BLOCK_DICT (bl) = dict_create_hashed_expandable (); BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl; - class_symtab->free_ptr = (char *) bl; + class_symtab->free_func = free_class_block; } return class_symtab; } @@ -140,20 +139,7 @@ add_class_symtab_symbol (struct symbol * { struct symtab *symtab = get_java_class_symtab (); struct blockvector *bv = BLOCKVECTOR (symtab); - struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - if (BLOCK_NSYMS (bl) >= class_symtab_space) - { - /* Need to re-allocate. */ - class_symtab_space *= 2; - bl = xmrealloc (symtab->objfile->md, bl, - sizeof (struct block) - + ((class_symtab_space - 1) * sizeof (struct symbol *))); - class_symtab->free_ptr = (char *) bl; - BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl; - } - - BLOCK_SYM (bl, BLOCK_NSYMS (bl)) = sym; - BLOCK_NSYMS (bl) = BLOCK_NSYMS (bl) + 1; + dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym); } static struct symbol *add_class_symbol (struct type *type, CORE_ADDR addr); @@ -174,6 +160,16 @@ add_class_symbol (struct type *type, COR SYMBOL_VALUE_ADDRESS (sym) = addr; return sym; } + +/* Free the dynamic symbols block. */ +static void +free_class_block (struct symtab *symtab) +{ + struct blockvector *bv = BLOCKVECTOR (symtab); + struct block *bl = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); + + dict_free (BLOCK_DICT (bl)); +} #endif struct type * @@ -268,7 +264,7 @@ type_from_class (struct value *clas) char *nptr; CORE_ADDR addr; struct block *bl; - int i; + struct dict_iterator iter; int is_array = 0; type = check_typedef (VALUE_TYPE (clas)); @@ -283,9 +279,8 @@ type_from_class (struct value *clas) #if 0 get_java_class_symtab (); bl = BLOCKVECTOR_BLOCK (BLOCKVECTOR (class_symtab), GLOBAL_BLOCK); - for (i = BLOCK_NSYMS (bl); --i >= 0;) + ALL_BLOCK_SYMBOLS (block, iter, sym) { - struct symbol *sym = BLOCK_SYM (bl, i); if (SYMBOL_VALUE_ADDRESS (sym) == addr) return SYMBOL_TYPE (sym); } Index: mdebugread.c =================================================================== RCS file: /cvs/src/src/gdb/mdebugread.c,v retrieving revision 1.46 diff -u -p -r1.46 mdebugread.c --- mdebugread.c 11 Jun 2003 22:27:12 -0000 1.46 +++ mdebugread.c 11 Jun 2003 23:25:50 -0000 @@ -54,6 +54,7 @@ #include "demangle.h" #include "gdb_assert.h" #include "block.h" +#include "dictionary.h" /* These are needed if the tm.h file does not contain the necessary mips specific definitions. */ @@ -284,9 +285,11 @@ static struct symbol *new_symbol (char * static struct type *new_type (char *); -static struct block *new_block (int); +enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK }; -static struct symtab *new_symtab (char *, int, int, struct objfile *); +static struct block *new_block (enum block_type); + +static struct symtab *new_symtab (char *, int, struct objfile *); static struct linetable *new_linetable (int); @@ -298,8 +301,6 @@ static struct type *parse_type (int, uni static struct symbol *mylookup_symbol (char *, struct block *, domain_enum, enum address_class); -static struct block *shrink_block (struct block *, struct symtab *); - static void sort_blocks (struct symtab *); static struct partial_symtab *new_psymtab (char *, struct objfile *); @@ -483,7 +484,6 @@ static struct parse_stack int blocktype; - int maxsyms; /* Max symbols in this block. */ struct type *cur_type; /* Type we parse fields for. */ int cur_field; /* Field number in cur_type. */ CORE_ADDR procadr; /* Start addres of this procedure */ @@ -834,7 +834,7 @@ parse_symbol (SYMR *sh, union aux_ext *a TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED; /* Create and enter a new lexical context */ - b = new_block (top_stack->maxsyms); + b = new_block (FUNCTION_BLOCK); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_FUNCTION (b) = s; BLOCK_START (b) = BLOCK_END (b) = sh->value; @@ -1169,7 +1169,7 @@ parse_symbol (SYMR *sh, union aux_ext *a } top_stack->blocktype = stBlock; - b = new_block (top_stack->maxsyms); + b = new_block (NON_FUNCTION_BLOCK); BLOCK_START (b) = sh->value + top_stack->procadr; BLOCK_SUPERBLOCK (b) = top_stack->cur_block; top_stack->cur_block = b; @@ -1189,7 +1189,7 @@ parse_symbol (SYMR *sh, union aux_ext *a /* Finished with procedure */ struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); struct mips_extra_func_info *e; - struct block *b; + struct block *b = top_stack->cur_block; struct type *ftype = top_stack->cur_type; int i; @@ -1209,9 +1209,6 @@ parse_symbol (SYMR *sh, union aux_ext *a e->pdr.framereg = -1; add_symbol (s, top_stack->cur_block); - /* Reallocate symbols, saving memory */ - b = shrink_block (top_stack->cur_block, top_stack->cur_st); - /* f77 emits proc-level with address bounds==[0,0], So look for such child blocks, and patch them. */ for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) @@ -1236,13 +1233,17 @@ parse_symbol (SYMR *sh, union aux_ext *a if (nparams > 0) { + struct dict_iterator iter; TYPE_NFIELDS (ftype) = nparams; TYPE_FIELDS (ftype) = (struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field)); - for (i = iparams = 0; iparams < nparams; i++) + iparams = 0; + ALL_BLOCK_SYMBOLS (b, iter, sym) { - sym = BLOCK_SYM (b, i); + if (iparams == nparams) + break; + switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -1266,7 +1267,6 @@ parse_symbol (SYMR *sh, union aux_ext *a displacement from the procedure`s start address of the end of this block. */ BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr; - shrink_block (top_stack->cur_block, top_stack->cur_st); } else if (sh->sc == scText && top_stack->blocktype == stNil) { @@ -4061,19 +4061,15 @@ psymtab_to_symtab_1 (struct partial_symt int maxlines; EXTR *ext_ptr; - /* How many symbols will we need */ - /* FIXME, this does not count enum values. */ - f_max = pst->n_global_syms + pst->n_static_syms; if (fh == 0) { maxlines = 0; - st = new_symtab ("unknown", f_max, 0, pst->objfile); + st = new_symtab ("unknown", 0, pst->objfile); } else { - f_max += fh->csym + fh->cpd; maxlines = 2 * fh->cline; - st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile); + st = new_symtab (pst->filename, maxlines, pst->objfile); /* The proper language was already determined when building the psymtab, use it. */ @@ -4093,7 +4089,6 @@ psymtab_to_symtab_1 (struct partial_symt BLOCK_START (top_stack->cur_block) = pst->textlow; BLOCK_END (top_stack->cur_block) = 0; top_stack->blocktype = stFile; - top_stack->maxsyms = 2 * f_max; top_stack->cur_type = 0; top_stack->procadr = 0; top_stack->numargs = 0; @@ -4177,10 +4172,6 @@ psymtab_to_symtab_1 (struct partial_symt top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), GLOBAL_BLOCK); top_stack->blocktype = stFile; - top_stack->maxsyms - = (debug_info->symbolic_header.isymMax - + debug_info->symbolic_header.ipdMax - + debug_info->symbolic_header.iextMax); ext_ptr = PST_PRIVATE (pst)->extern_tab; for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++) @@ -4450,11 +4441,12 @@ static struct symbol * mylookup_symbol (char *name, register struct block *block, domain_enum domain, enum address_class class) { - int i, inc; + struct dict_iterator iter; + int inc; struct symbol *sym; inc = name[0]; - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc && SYMBOL_DOMAIN (sym) == domain @@ -4470,41 +4462,12 @@ mylookup_symbol (char *name, register st } -/* Add a new symbol S to a block B. - Infrequently, we will need to reallocate the block to make it bigger. - We only detect this case when adding to top_stack->cur_block, since - that's the only time we know how big the block is. FIXME. */ +/* Add a new symbol S to a block B. */ static void add_symbol (struct symbol *s, struct block *b) { - int nsyms = BLOCK_NSYMS (b)++; - struct block *origb; - struct parse_stack *stackp; - - if (b == top_stack->cur_block && - nsyms >= top_stack->maxsyms) - { - complaint (&symfile_complaints, "block containing %s overfilled", - DEPRECATED_SYMBOL_NAME (s)); - /* In this case shrink_block is actually grow_block, since - BLOCK_NSYMS(b) is larger than its current size. */ - origb = b; - b = shrink_block (top_stack->cur_block, top_stack->cur_st); - - /* Now run through the stack replacing pointers to the - original block. shrink_block has already done this - for the blockvector and BLOCK_FUNCTION. */ - for (stackp = top_stack; stackp; stackp = stackp->next) - { - if (stackp->cur_block == origb) - { - stackp->cur_block = b; - stackp->maxsyms = BLOCK_NSYMS (b); - } - } - } - BLOCK_SYM (b, nsyms) = s; + dict_add_symbol (BLOCK_DICT (b), s); } /* Add a new block B to a symtab S */ @@ -4626,11 +4589,11 @@ sort_blocks (struct symtab *s) /* Constructor/restructor/destructor procedures */ -/* Allocate a new symtab for NAME. Needs an estimate of how many symbols - MAXSYMS and linenumbers MAXLINES we'll put in it */ +/* Allocate a new symtab for NAME. Needs an estimate of how many + linenumbers MAXLINES we'll put in it */ static struct symtab * -new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile) +new_symtab (char *name, int maxlines, struct objfile *objfile) { struct symtab *s = allocate_symtab (name, objfile); @@ -4638,8 +4601,10 @@ new_symtab (char *name, int maxsyms, int /* All symtabs must have at least two blocks */ BLOCKVECTOR (s) = new_bvect (2); - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms); - BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms); + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) + = new_block (NON_FUNCTION_BLOCK); + BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) + = new_block (NON_FUNCTION_BLOCK); BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); @@ -4723,48 +4688,22 @@ new_bvect (int nblocks) return bv; } -/* Allocate and zero a new block of MAXSYMS symbols */ +/* Allocate and zero a new block, and set its BLOCK_DICT. 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. */ static struct block * -new_block (int maxsyms) +new_block (enum block_type type) { - int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *); + struct block *retval = xzalloc (sizeof (struct block)); - return (struct block *) xzalloc (size); -} - -/* Ooops, too big. Shrink block B in symtab S to its minimal size. - Shrink_block can also be used by add_symbol to grow a block. */ - -static struct block * -shrink_block (struct block *b, struct symtab *s) -{ - struct block *new; - struct blockvector *bv = BLOCKVECTOR (s); - int i; - - /* Just reallocate it and fix references to the old one */ + if (type == FUNCTION_BLOCK) + BLOCK_DICT (retval) = dict_create_linear_expandable (); + else + BLOCK_DICT (retval) = dict_create_hashed_expandable (); - new = (struct block *) xrealloc ((void *) b, - (sizeof (struct block) - + ((BLOCK_NSYMS (b) - 1) - * sizeof (struct symbol *)))); - - /* FIXME: Not worth hashing this block as it's built. */ - /* All callers should have created the block with new_block (), which - would mean it was not previously hashed. Make sure. */ - gdb_assert (BLOCK_HASHTABLE (new) == 0); - - /* Should chase pointers to old one. Fortunately, that`s just - the block`s function and inferior blocks */ - if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b) - SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new; - for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) - if (BLOCKVECTOR_BLOCK (bv, i) == b) - BLOCKVECTOR_BLOCK (bv, i) = new; - else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b) - BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new; - return new; + return retval; } /* Create a new symbol with printname NAME */ @@ -4901,7 +4840,7 @@ fixup_sigtramp (void) TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void; /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */ - b = new_block (1); + b = new_block (NON_FUNCTION_BLOCK); SYMBOL_BLOCK_VALUE (s) = b; BLOCK_START (b) = sigtramp_address; BLOCK_END (b) = sigtramp_end; @@ -4944,7 +4883,7 @@ fixup_sigtramp (void) current_objfile = NULL; } - BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s; + dict_add_symbol (BLOCK_DICT (b), s); } #endif /* TM_MIPS_H */ Index: objfiles.c =================================================================== RCS file: /cvs/src/src/gdb/objfiles.c,v retrieving revision 1.32 diff -u -p -r1.32 objfiles.c --- objfiles.c 6 Jun 2003 23:32:59 -0000 1.32 +++ objfiles.c 11 Jun 2003 23:25:51 -0000 @@ -43,6 +43,7 @@ #include "breakpoint.h" #include "block.h" +#include "dictionary.h" /* Prototypes for local functions */ @@ -657,13 +658,13 @@ objfile_relocate (struct objfile *objfil { struct block *b; struct symbol *sym; - int j; + struct dict_iterator iter; b = BLOCKVECTOR_BLOCK (bv, i); BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); - ALL_BLOCK_SYMBOLS (b, j, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { fixup_symbol_section (sym, objfile); Index: stack.c =================================================================== RCS file: /cvs/src/src/gdb/stack.c,v retrieving revision 1.80 diff -u -p -r1.80 stack.c --- stack.c 9 Jun 2003 17:35:58 -0000 1.80 +++ stack.c 11 Jun 2003 23:25:53 -0000 @@ -42,6 +42,7 @@ #include "block.h" #include "stack.h" #include "gdb_assert.h" +#include "dictionary.h" /* Prototypes for exported functions. */ @@ -211,7 +212,7 @@ print_frame_args (struct symbol *func, s { struct block *b = NULL; int first = 1; - register int i; + struct dict_iterator iter; register struct symbol *sym; struct value *val; /* Offset of next stack argument beyond the one we have seen that is @@ -230,11 +231,8 @@ print_frame_args (struct symbol *func, s if (func) { b = SYMBOL_BLOCK_VALUE (func); - /* Function blocks are order sensitive, and thus should not be - hashed. */ - gdb_assert (BLOCK_HASHTABLE (b) == 0); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { QUIT; @@ -1311,14 +1309,15 @@ backtrace_full_command (char *arg, int f Return 1 if any variables were printed; 0 otherwise. */ static int -print_block_frame_locals (struct block *b, register struct frame_info *fi, - int num_tabs, register struct ui_file *stream) +print_block_frame_locals (struct block *b, struct frame_info *fi, + int num_tabs, struct ui_file *stream) { - register int i, j; - register struct symbol *sym; - register int values_printed = 0; + struct dict_iterator iter; + int j; + struct symbol *sym; + int values_printed = 0; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { switch (SYMBOL_CLASS (sym)) { @@ -1350,11 +1349,11 @@ static int print_block_frame_labels (struct block *b, int *have_default, register struct ui_file *stream) { - register int i; + struct dict_iterator iter; register struct symbol *sym; register int values_printed = 0; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { if (STREQ (DEPRECATED_SYMBOL_NAME (sym), "default")) { @@ -1532,7 +1531,7 @@ print_frame_arg_vars (register struct fr { struct symbol *func = get_frame_function (fi); register struct block *b; - register int i; + struct dict_iterator iter; register struct symbol *sym, *sym2; register int values_printed = 0; @@ -1543,7 +1542,7 @@ print_frame_arg_vars (register struct fr } b = SYMBOL_BLOCK_VALUE (func); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { switch (SYMBOL_CLASS (sym)) { Index: symmisc.c =================================================================== RCS file: /cvs/src/src/gdb/symmisc.c,v retrieving revision 1.22 diff -u -p -r1.22 symmisc.c --- symmisc.c 14 May 2003 17:43:19 -0000 1.22 +++ symmisc.c 11 Jun 2003 23:25:54 -0000 @@ -34,6 +34,7 @@ #include "bcache.h" #include "block.h" #include "gdb_regex.h" +#include "dictionary.h" #include "gdb_string.h" #include <readline/readline.h> @@ -87,22 +88,22 @@ static void free_symtab_block (struct ob /* Free a struct block <- B and all the symbols defined in that block. */ +/* FIXME: carlton/2003-04-28: I don't believe this is currently ever + used. */ + static void free_symtab_block (struct objfile *objfile, struct block *b) { - register int i, n; - struct symbol *sym, *next_sym; + struct dict_iterator iter; + struct symbol *sym; - n = BLOCK_BUCKETS (b); - for (i = 0; i < n; i++) + ALL_BLOCK_SYMBOLS (b, iter, sym) { - for (sym = BLOCK_BUCKET (b, i); sym; sym = next_sym) - { - next_sym = sym->hash_next; - xmfree (objfile->md, DEPRECATED_SYMBOL_NAME (sym)); - xmfree (objfile->md, sym); - } + xmfree (objfile->md, DEPRECATED_SYMBOL_NAME (sym)); + xmfree (objfile->md, sym); } + + dict_free (BLOCK_DICT (b)); xmfree (objfile->md, b); } @@ -141,7 +142,7 @@ free_symtab (register struct symtab *s) /* Also free the linetable. */ case free_linetable: - /* Everything will be freed either by our `free_ptr' + /* Everything will be freed either by our `free_func' or by some other symtab, except for our linetable. Free that now. */ if (LINETABLE (s)) @@ -150,8 +151,8 @@ free_symtab (register struct symtab *s) } /* If there is a single block of memory to free, free it. */ - if (s->free_ptr != NULL) - xmfree (s->objfile->md, s->free_ptr); + if (s->free_func != NULL) + s->free_func (s); /* Free source-related stuff */ if (s->line_charpos != NULL) @@ -444,12 +445,13 @@ static void dump_symtab (struct objfile *objfile, struct symtab *symtab, struct ui_file *outfile) { - register int i, j; + int i; + struct dict_iterator iter; int len, blen; - register struct linetable *l; + struct linetable *l; struct blockvector *bv; struct symbol *sym; - register struct block *b; + struct block *b; int depth; fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename); @@ -496,11 +498,8 @@ dump_symtab (struct objfile *objfile, st /* drow/2002-07-10: We could save the total symbols count even if we're using a hashtable, but nothing else but this message wants it. */ - blen = BLOCK_BUCKETS (b); - if (BLOCK_HASHTABLE (b)) - fprintf_filtered (outfile, ", %d buckets in ", blen); - else - fprintf_filtered (outfile, ", %d syms in ", blen); + fprintf_filtered (outfile, ", %d syms/buckets in ", + dict_size (BLOCK_DICT (b))); print_address_numeric (BLOCK_START (b), 1, outfile); fprintf_filtered (outfile, ".."); print_address_numeric (BLOCK_END (b), 1, outfile); @@ -518,7 +517,7 @@ dump_symtab (struct objfile *objfile, st fprintf_filtered (outfile, "\n"); /* Now print each symbol in this block (in no particular order, if we're using a hashtable). */ - ALL_BLOCK_SYMBOLS (b, j, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { struct print_symbol_args s; s.symbol = sym; Index: symtab.c =================================================================== RCS file: /cvs/src/src/gdb/symtab.c,v retrieving revision 1.110 diff -u -p -r1.110 symtab.c --- symtab.c 11 Jun 2003 22:27:14 -0000 1.110 +++ symtab.c 11 Jun 2003 23:25:58 -0000 @@ -46,6 +46,7 @@ #include "gdb_obstack.h" #include "block.h" +#include "dictionary.h" #include <sys/types.h> #include <fcntl.h> @@ -1633,21 +1634,18 @@ lookup_block_symbol (register const stru const char *linkage_name, const domain_enum domain) { - register int bot, top, inc; - register struct symbol *sym; - register struct symbol *sym_found = NULL; + struct dict_iterator iter; + struct symbol *sym; - if (BLOCK_HASHTABLE (block)) + if (!BLOCK_FUNCTION (block)) { - unsigned int hash_index; - hash_index = msymbol_hash_iw (name); - hash_index = hash_index % BLOCK_BUCKETS (block); - for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next) - { - if (SYMBOL_DOMAIN (sym) == domain - && (linkage_name - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), linkage_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); + sym != NULL; + sym = dict_iter_name_next (name, &iter)) + { + if (SYMBOL_DOMAIN (sym) == domain + && (linkage_name != NULL + ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) return sym; } return NULL; @@ -1659,15 +1657,16 @@ lookup_block_symbol (register const stru parameter symbols first; it only uses parameter symbols as a last resort. Note that this only takes up extra computation time on a match. */ - top = BLOCK_NSYMS (block); - bot = 0; - while (bot < top) + + struct symbol *sym_found = NULL; + + for (sym = dict_iter_name_first (BLOCK_DICT (block), name, &iter); + sym != NULL; + sym = dict_iter_name_next (name, &iter)) { - sym = BLOCK_SYM (block, bot); if (SYMBOL_DOMAIN (sym) == domain - && (linkage_name - ? strcmp (DEPRECATED_SYMBOL_NAME (sym), linkage_name) == 0 - : SYMBOL_MATCHES_NATURAL_NAME (sym, name))) + && (linkage_name != NULL + ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1)) { /* If SYM has aliases, then use any alias that is active at the current PC. If no alias is active at the current @@ -1676,18 +1675,18 @@ lookup_block_symbol (register const stru ?!? Is checking the current pc correct? Is this routine ever called to look up a symbol from another context? - FIXME: No, it's not correct. If someone sets a - conditional breakpoint at an address, then the - breakpoint's `struct expression' should refer to the - `struct symbol' appropriate for the breakpoint's - address, which may not be the PC. - - Even if it were never called from another context, - it's totally bizarre for lookup_symbol's behavior to - depend on the value of the inferior's current PC. We - should pass in the appropriate PC as well as the - block. The interface to lookup_symbol should change - to require the caller to provide a PC. */ + FIXME: No, it's not correct. If someone sets a + conditional breakpoint at an address, then the + breakpoint's `struct expression' should refer to the + `struct symbol' appropriate for the breakpoint's + address, which may not be the PC. + + Even if it were never called from another context, + it's totally bizarre for lookup_symbol's behavior to + depend on the value of the inferior's current PC. We + should pass in the appropriate PC as well as the + block. The interface to lookup_symbol should change + to require the caller to provide a PC. */ if (SYMBOL_ALIASES (sym)) sym = find_active_alias (sym, read_pc ()); @@ -1704,10 +1703,8 @@ lookup_block_symbol (register const stru break; } } - bot++; } - - return (sym_found); /* Will be NULL if not found. */ + return (sym_found); /* Will be NULL if not found. */ } } @@ -1811,16 +1808,16 @@ find_pc_sect_symtab (CORE_ADDR pc, asect } if (section != 0) { - int i; + struct dict_iterator iter; struct symbol *sym = NULL; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { fixup_symbol_section (sym, objfile); if (section == SYMBOL_BFD_SECTION (sym)) break; } - if ((i >= BLOCK_BUCKETS (b)) && (sym == NULL)) + if (sym == NULL) continue; /* no symbol in this symtab matches section */ } distance = BLOCK_END (b) - BLOCK_START (b); @@ -2757,7 +2754,7 @@ search_symbols (char *regexp, domain_enu struct blockvector *prev_bv = 0; register struct block *b; register int i = 0; - register int j; + struct dict_iterator iter; register struct symbol *sym; struct partial_symbol **psym; struct objfile *objfile; @@ -2946,7 +2943,7 @@ search_symbols (char *regexp, domain_enu struct symbol_search *prevtail = tail; int nfound = 0; b = BLOCKVECTOR_BLOCK (bv, i); - ALL_BLOCK_SYMBOLS (b, j, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { QUIT; if (file_matches (s->filename, files, nfiles) @@ -3407,13 +3404,14 @@ language_search_unquoted_string (char *t char ** make_symbol_completion_list (char *text, char *word) { - register struct symbol *sym; - register struct symtab *s; - register struct partial_symtab *ps; - register struct minimal_symbol *msymbol; - register struct objfile *objfile; - register struct block *b, *surrounding_static_block = 0; - register int i, j; + struct symbol *sym; + struct symtab *s; + struct partial_symtab *ps; + struct minimal_symbol *msymbol; + struct objfile *objfile; + struct block *b, *surrounding_static_block = 0; + struct dict_iterator iter; + int j; struct partial_symbol **psym; /* The symbol we are completing on. Points in same buffer as text. */ char *sym_text; @@ -3536,7 +3534,7 @@ make_symbol_completion_list (char *text, /* Also catch fields of types defined in this places which match our text string. Only complete on types visible from current context. */ - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { QUIT; COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); @@ -3567,7 +3565,7 @@ make_symbol_completion_list (char *text, { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3580,7 +3578,7 @@ make_symbol_completion_list (char *text, /* Don't do this block twice. */ if (b == surrounding_static_block) continue; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -3598,7 +3596,7 @@ make_file_symbol_completion_list (char * register struct symbol *sym; register struct symtab *s; register struct block *b; - register int i; + struct dict_iterator iter; /* The symbol we are completing on. Points in same buffer as text. */ char *sym_text; /* Length of sym_text. */ @@ -3677,13 +3675,13 @@ make_file_symbol_completion_list (char * symbols which match. */ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text, word); } @@ -4034,7 +4032,7 @@ make_symbol_overload_list (struct symbol register struct partial_symtab *ps; register struct objfile *objfile; register struct block *b, *surrounding_static_block = 0; - register int i; + struct dict_iterator iter; /* The name we are completing on. */ char *oload_name = NULL; /* Length of name. */ @@ -4091,7 +4089,7 @@ make_symbol_overload_list (struct symbol /* Also catch fields of types defined in this places which match our text string. Only complete on types visible from current context. */ - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { overload_list_add_symbol (sym, oload_name); } @@ -4104,7 +4102,7 @@ make_symbol_overload_list (struct symbol { QUIT; b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { overload_list_add_symbol (sym, oload_name); } @@ -4117,7 +4115,7 @@ make_symbol_overload_list (struct symbol /* Don't do this block twice. */ if (b == surrounding_static_block) continue; - ALL_BLOCK_SYMBOLS (b, i, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { overload_list_add_symbol (sym, oload_name); } Index: symtab.h =================================================================== RCS file: /cvs/src/src/gdb/symtab.h,v retrieving revision 1.73 diff -u -p -r1.73 symtab.h --- symtab.h 6 Jun 2003 23:32:59 -0000 1.73 +++ symtab.h 11 Jun 2003 23:26:00 -0000 @@ -801,10 +801,10 @@ struct symtab } free_code; - /* Pointer to one block of storage to be freed, if nonzero. */ - /* This is IN ADDITION to the action indicated by free_code. */ + /* A function to call to free space, if necessary. This is IN + ADDITION to the action indicated by free_code. */ - char *free_ptr; + void (*free_func)(struct symtab *symtab); /* Total number of lines found in source file. */ Index: tracepoint.c =================================================================== RCS file: /cvs/src/src/gdb/tracepoint.c,v retrieving revision 1.50 diff -u -p -r1.50 tracepoint.c --- tracepoint.c 8 May 2003 18:46:48 -0000 1.50 +++ tracepoint.c 11 Jun 2003 23:26:03 -0000 @@ -38,6 +38,7 @@ #include "completer.h" #include "gdb-events.h" #include "block.h" +#include "dictionary.h" #include "ax.h" #include "ax-gdb.h" @@ -1289,13 +1290,14 @@ add_local_symbols (struct collection_lis { struct symbol *sym; struct block *block; - int i, count = 0; + struct dict_iterator iter; + int count = 0; block = block_for_pc (pc); while (block != 0) { QUIT; /* allow user to bail out with ^C */ - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { switch (SYMBOL_CLASS (sym)) { @@ -2333,7 +2335,8 @@ scope_info (char *args, int from_tty) struct minimal_symbol *msym; struct block *block; char **canonical, *symname, *save_args = args; - int i, j, count = 0; + struct dict_iterator iter; + int j, count = 0; if (args == 0 || *args == 0) error ("requires an argument (function, line or *addr) to define a scope"); @@ -2349,7 +2352,7 @@ scope_info (char *args, int from_tty) while (block != 0) { QUIT; /* allow user to bail out with ^C */ - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { QUIT; /* allow user to bail out with ^C */ if (count == 0) Index: valops.c =================================================================== RCS file: /cvs/src/src/gdb/valops.c,v retrieving revision 1.110 diff -u -p -r1.110 valops.c --- valops.c 5 Jun 2003 20:59:16 -0000 1.110 +++ valops.c 11 Jun 2003 23:26:06 -0000 @@ -35,6 +35,7 @@ #include "cp-abi.h" #include "block.h" #include "infcall.h" +#include "dictionary.h" #include <errno.h> #include "gdb_string.h" @@ -2475,7 +2476,6 @@ value_of_local (const char *name, int co { struct symbol *func, *sym; struct block *b; - int i; struct value * ret; if (deprecated_selected_frame == 0) @@ -2496,8 +2496,7 @@ value_of_local (const char *name, int co } b = SYMBOL_BLOCK_VALUE (func); - i = BLOCK_NSYMS (b); - if (i <= 0) + if (dict_empty (BLOCK_DICT (b))) { if (complain) error ("no args, no `%s'", name); Index: xcoffread.c =================================================================== RCS file: /cvs/src/src/gdb/xcoffread.c,v retrieving revision 1.30 diff -u -p -r1.30 xcoffread.c --- xcoffread.c 11 Jun 2003 22:27:17 -0000 1.30 +++ xcoffread.c 11 Jun 2003 23:26:09 -0000 @@ -1767,6 +1767,7 @@ xcoff_psymtab_to_symtab_1 (struct partia old_chain = make_cleanup (really_free_pendings, 0); read_xcoff_symtab (pst); + sort_symtab_syms (pst->symtab); do_cleanups (old_chain); } Index: gdbtk/ChangeLog =================================================================== RCS file: /cvs/src/src/gdb/gdbtk/ChangeLog,v retrieving revision 1.319 diff -u -p -r1.319 ChangeLog --- gdbtk/ChangeLog 11 Jun 2003 21:52:22 -0000 1.319 +++ gdbtk/ChangeLog 11 Jun 2003 23:26:10 -0000 @@ -1,5 +1,13 @@ 2003-06-11 David Carlton <carlton@bactrian.org> + * generic/gdbtk-stack.c: Include dictionary.h. + (gdb_block_vars): Update use of ALL_BLOCK_SYMBOLS. + (gdb_get_blocks, gdb_get_vars_command): Ditto. + * generic/gdbtk-cmds.c: Include dictionary.h. + (gdb_listfuncs): Update use of ALL_BLOCK_SYMBOLS. + +2003-06-11 David Carlton <carlton@bactrian.org> + * generic/gdbtk-register.c (get_register): REGISTER_CONVERTIBLE and REGISTER_CONVERT_TO_VIRTUAL are deprecated. Index: gdbtk/generic/gdbtk-cmds.c =================================================================== RCS file: /cvs/src/src/gdb/gdbtk/generic/gdbtk-cmds.c,v retrieving revision 1.74 diff -u -p -r1.74 gdbtk-cmds.c --- gdbtk/generic/gdbtk-cmds.c 14 May 2003 17:43:45 -0000 1.74 +++ gdbtk/generic/gdbtk-cmds.c 11 Jun 2003 23:26:13 -0000 @@ -35,6 +35,7 @@ #include "top.h" #include "annotate.h" #include "block.h" +#include "dictionary.h" /* tcl header files includes varargs.h unless HAS_STDARG is defined, but gdb uses stdarg.h, so make sure HAS_STDARG is defined. */ @@ -1402,7 +1403,8 @@ gdb_listfuncs (clientData, interp, objc, struct blockvector *bv; struct block *b; struct symbol *sym; - int i, j; + int i; + struct dict_iterator iter; Tcl_Obj *funcVals[2]; if (objc != 2) @@ -1433,7 +1435,7 @@ gdb_listfuncs (clientData, interp, objc, for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++) { b = BLOCKVECTOR_BLOCK (bv, i); - ALL_BLOCK_SYMBOLS (b, j, sym) + ALL_BLOCK_SYMBOLS (b, iter, sym) { if (SYMBOL_CLASS (sym) == LOC_BLOCK) { Index: gdbtk/generic/gdbtk-stack.c =================================================================== RCS file: /cvs/src/src/gdb/gdbtk/generic/gdbtk-stack.c,v retrieving revision 1.18 diff -u -p -r1.18 gdbtk-stack.c --- gdbtk/generic/gdbtk-stack.c 11 Apr 2003 17:40:23 -0000 1.18 +++ gdbtk/generic/gdbtk-stack.c 11 Jun 2003 23:26:13 -0000 @@ -23,6 +23,7 @@ #include "breakpoint.h" #include "linespec.h" #include "block.h" +#include "dictionary.h" #include <tcl.h> #include "gdbtk.h" @@ -85,7 +86,7 @@ gdb_block_vars (ClientData clientData, T int objc, Tcl_Obj *CONST objv[]) { struct block *block; - int i; + struct dict_iterator iter; struct symbol *sym; CORE_ADDR start, end; @@ -108,7 +109,7 @@ gdb_block_vars (ClientData clientData, T { if (BLOCK_START (block) == start && BLOCK_END (block) == end) { - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { switch (SYMBOL_CLASS (sym)) { @@ -160,7 +161,8 @@ gdb_get_blocks (ClientData clientData, T int objc, Tcl_Obj *CONST objv[]) { struct block *block; - int i, junk; + struct dict_iterator iter; + int junk; struct symbol *sym; CORE_ADDR pc; @@ -173,7 +175,7 @@ gdb_get_blocks (ClientData clientData, T while (block != 0) { junk = 0; - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { switch (SYMBOL_CLASS (sym)) { @@ -280,6 +282,7 @@ gdb_get_vars_command (ClientData clientD struct symbol *sym; struct block *block; char **canonical, *args; + struct dict_iterator iter; int i, arguments; if (objc > 2) @@ -322,7 +325,7 @@ gdb_get_vars_command (ClientData clientD while (block != 0) { - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { switch (SYMBOL_CLASS (sym)) { Index: mi/ChangeLog =================================================================== RCS file: /cvs/src/src/gdb/mi/ChangeLog,v retrieving revision 1.109 diff -u -p -r1.109 ChangeLog --- mi/ChangeLog 11 Jun 2003 19:38:27 -0000 1.109 +++ mi/ChangeLog 11 Jun 2003 23:26:16 -0000 @@ -1,3 +1,8 @@ +2003-06-11 David Carlton <carlton@bactrian.org> + + * mi-cmd-stack.c: Include dictionary.h. + (list_args_or_locals): Update use of ALL_BLOCK_SYMBOLS. + 2003-06-11 Andrew Cagney <cagney@redhat.com> * mi-main.c (get_register): Replace REGISTER_CONVERTIBLE with Index: mi/mi-cmd-stack.c =================================================================== RCS file: /cvs/src/src/gdb/mi/mi-cmd-stack.c,v retrieving revision 1.18 diff -u -p -r1.18 mi-cmd-stack.c --- mi/mi-cmd-stack.c 8 Jun 2003 18:27:14 -0000 1.18 +++ mi/mi-cmd-stack.c 11 Jun 2003 23:26:17 -0000 @@ -28,6 +28,7 @@ #include "symtab.h" #include "block.h" #include "stack.h" +#include "dictionary.h" static void list_args_or_locals (int locals, int values, struct frame_info *fi); @@ -213,7 +214,8 @@ list_args_or_locals (int locals, int val { struct block *block; struct symbol *sym; - int i, nsyms; + struct dict_iterator iter; + int nsyms; struct cleanup *cleanup_list; static struct ui_stream *stb = NULL; @@ -225,7 +227,7 @@ list_args_or_locals (int locals, int val while (block != 0) { - ALL_BLOCK_SYMBOLS (block, i, sym) + ALL_BLOCK_SYMBOLS (block, iter, sym) { int print_me = 0; ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-11 23:33 ` David Carlton @ 2003-06-13 0:15 ` Joel Brobecker 2003-06-13 0:52 ` David Carlton 0 siblings, 1 reply; 15+ messages in thread From: Joel Brobecker @ 2003-06-13 0:15 UTC (permalink / raw) To: David Carlton; +Cc: Elena Zannoni, gdb-patches, Jim Blandy Hello David, > Okay, it's in; revised patch is below. Joel, if you could see if > mainline works on an mdebugread target, I'd appreciate it. If it > doesn't, any relevant information (e.g. where it crashes or hangs or > whatever) would be greatly appreciated. I just tested your patch on Tru64 5.1a, and did not see any regression... Cheers, -- Joel ^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [rfa] struct dictionary 2003-06-13 0:15 ` Joel Brobecker @ 2003-06-13 0:52 ` David Carlton 0 siblings, 0 replies; 15+ messages in thread From: David Carlton @ 2003-06-13 0:52 UTC (permalink / raw) To: Joel Brobecker; +Cc: Elena Zannoni, gdb-patches, Jim Blandy On Thu, 12 Jun 2003 17:15:16 -0700, Joel Brobecker <brobecker@gnat.com> said: > Hello David, >> Okay, it's in; revised patch is below. Joel, if you could see if >> mainline works on an mdebugread target, I'd appreciate it. If it >> doesn't, any relevant information (e.g. where it crashes or hangs or >> whatever) would be greatly appreciated. > I just tested your patch on Tru64 5.1a, and did not see any > regression... Yay! I really wasn't expecting that: I mean, I tried to be careful, but mistakes are always possible in patches of that size. David Carlton carlton@math.stanford.edu ^ permalink raw reply [flat|nested] 15+ messages in thread
end of thread, other threads:[~2003-06-13 0:52 UTC | newest]
Thread overview: 15+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <ro1k7dbwprh.fsf@jackfruit.Stanford.EDU>
2003-05-01 3:37 ` [rfa] struct dictionary Eli Zaretskii
2003-05-01 21:15 ` David Carlton
2003-05-20 3:58 ` David Carlton
2003-06-09 22:39 ` Elena Zannoni
2003-06-09 22:55 ` Daniel Jacobowitz
2003-06-10 0:05 ` Joel Brobecker
2003-06-10 0:24 ` Elena Zannoni
2003-06-10 15:58 ` David Carlton
2003-06-10 16:43 ` David Carlton
2003-06-10 18:37 ` Elena Zannoni
2003-06-10 18:47 ` David Carlton
2003-06-11 1:20 ` Richard Henderson
2003-06-11 23:33 ` David Carlton
2003-06-13 0:15 ` Joel Brobecker
2003-06-13 0:52 ` David Carlton
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox