gdb/23712: Use new multidictionary API
authorKeith Seitz <keiths@redhat.com>
Thu, 10 Jan 2019 21:57:08 +0000 (13:57 -0800)
committerKeith Seitz <keiths@redhat.com>
Thu, 10 Jan 2019 21:57:08 +0000 (13:57 -0800)
This patch builds on the previous by enabling the `new' multidictionary
API.  A lot of the hunks are simply textual replacements of "dict_"
with "mdict_" and similar transformations.

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

gdb/ChangeLog:

PR gdb/23712
PR symtab/23010
* dictionary.h (struct dictionary): Replace declaration with
multidictionary.
(dict_create_hashed, dict_create_hashed_expandable)
(dict_create_linear, dict_create_linear_expandable)
(dict_free, dict_add_symbol, dict_add_pending, dict_empty)
(dict_iterator_first, dict_iterator_next, dict_iter_match_first)
(dict_iter_match_next, dict_size): Rename to "mdict_" versions
taking multidictionary argument.
[ALL_DICT_SYMBOLS]: Update for multidictionary.
* block.h (struct block) <dict>: Change to multidictionary
and rename `multidict'.
* block.c, buildsym.c, jit.c, mdebugread.c, objfiles.c,
symmisc.c: Update all dictionary references to multidictionary.

gdb/ChangeLog
gdb/block.c
gdb/block.h
gdb/buildsym.c
gdb/dictionary.h
gdb/jit.c
gdb/mdebugread.c
gdb/objfiles.c
gdb/symmisc.c

index 24af9eb..c7650ca 100644 (file)
@@ -2,6 +2,24 @@
 
        PR gdb/23712
        PR symtab/23010
+       * dictionary.h (struct dictionary): Replace declaration with
+       multidictionary.
+       (dict_create_hashed, dict_create_hashed_expandable)
+       (dict_create_linear, dict_create_linear_expandable)
+       (dict_free, dict_add_symbol, dict_add_pending, dict_empty)
+       (dict_iterator_first, dict_iterator_next, dict_iter_match_first)
+       (dict_iter_match_next, dict_size): Rename to "mdict_" versions
+       taking multidictionary argument.
+       [ALL_DICT_SYMBOLS]: Update for multidictionary.
+       * block.h (struct block) <dict>: Change to multidictionary
+       and rename `multidict'.
+       * block.c, buildsym.c, jit.c, mdebugread.c, objfiles.c,
+       symmisc.c: Update all dictionary references to multidictionary.
+
+2019-01-10  Keith Seitz  <keiths@redhat.com>
+
+       PR gdb/23712
+       PR symtab/23010
        * dictionary.c: Include unordered_map.
        (pending_to_vector): New function.
        (dict_create_hashed_1, dict_create_linear_1, dict_add_pending_1):
index 473de67..3192b33 100644 (file)
@@ -387,9 +387,9 @@ block_global_block (const struct block *block)
    zero/NULL.  This is useful for creating "dummy" blocks that don't
    correspond to actual source files.
 
-   Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
+   Warning: it sets the block's BLOCK_MULTIDICT to NULL, which isn't a
    valid value.  If you really don't want the block to have a
-   dictionary, then you should subsequently set its BLOCK_DICT to
+   dictionary, then you should subsequently set its BLOCK_MULTIDICT to
    dict_create_linear (obstack, NULL).  */
 
 struct block *
@@ -544,10 +544,11 @@ block_iterator_step (struct block_iterator *iterator, int first)
 
          block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
                                     iterator->which);
-         sym = dict_iterator_first (BLOCK_DICT (block), &iterator->dict_iter);
+         sym = mdict_iterator_first (BLOCK_MULTIDICT (block),
+                                     &iterator->mdict_iter);
        }
       else
-       sym = dict_iterator_next (&iterator->dict_iter);
+       sym = mdict_iterator_next (&iterator->mdict_iter);
 
       if (sym != NULL)
        return sym;
@@ -569,7 +570,7 @@ block_iterator_first (const struct block *block,
   initialize_block_iterator (block, iterator);
 
   if (iterator->which == FIRST_LOCAL_BLOCK)
-    return dict_iterator_first (block->dict, &iterator->dict_iter);
+    return mdict_iterator_first (block->multidict, &iterator->mdict_iter);
 
   return block_iterator_step (iterator, 1);
 }
@@ -580,7 +581,7 @@ struct symbol *
 block_iterator_next (struct block_iterator *iterator)
 {
   if (iterator->which == FIRST_LOCAL_BLOCK)
-    return dict_iterator_next (&iterator->dict_iter);
+    return mdict_iterator_next (&iterator->mdict_iter);
 
   return block_iterator_step (iterator, 0);
 }
@@ -612,11 +613,11 @@ block_iter_match_step (struct block_iterator *iterator,
 
          block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
                                     iterator->which);
-         sym = dict_iter_match_first (BLOCK_DICT (block), name,
-                                      &iterator->dict_iter);
+         sym = mdict_iter_match_first (BLOCK_MULTIDICT (block), name,
+                                       &iterator->mdict_iter);
        }
       else
-       sym = dict_iter_match_next (name, &iterator->dict_iter);
+       sym = mdict_iter_match_next (name, &iterator->mdict_iter);
 
       if (sym != NULL)
        return sym;
@@ -639,7 +640,8 @@ block_iter_match_first (const struct block *block,
   initialize_block_iterator (block, iterator);
 
   if (iterator->which == FIRST_LOCAL_BLOCK)
-    return dict_iter_match_first (block->dict, name, &iterator->dict_iter);
+    return mdict_iter_match_first (block->multidict, name,
+                                  &iterator->mdict_iter);
 
   return block_iter_match_step (iterator, name, 1);
 }
@@ -651,7 +653,7 @@ block_iter_match_next (const lookup_name_info &name,
                       struct block_iterator *iterator)
 {
   if (iterator->which == FIRST_LOCAL_BLOCK)
-    return dict_iter_match_next (name, &iterator->dict_iter);
+    return mdict_iter_match_next (name, &iterator->mdict_iter);
 
   return block_iter_match_step (iterator, name, 0);
 }
@@ -731,7 +733,7 @@ block_lookup_symbol_primary (const struct block *block, const char *name,
                             const domain_enum domain)
 {
   struct symbol *sym, *other;
-  struct dict_iterator dict_iter;
+  struct mdict_iterator mdict_iter;
 
   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
 
@@ -740,9 +742,10 @@ block_lookup_symbol_primary (const struct block *block, const char *name,
              || BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL);
 
   other = NULL;
-  for (sym = dict_iter_match_first (block->dict, lookup_name, &dict_iter);
+  for (sym
+        = mdict_iter_match_first (block->multidict, lookup_name, &mdict_iter);
        sym != NULL;
-       sym = dict_iter_match_next (lookup_name, &dict_iter))
+       sym = mdict_iter_match_next (lookup_name, &mdict_iter))
     {
       if (SYMBOL_DOMAIN (sym) == domain)
        return sym;
index cc78b08..d32114b 100644 (file)
@@ -111,7 +111,7 @@ struct block
 
   /* This is used to store the symbols in the block.  */
 
-  struct dictionary *dict;
+  struct multidictionary *multidict;
 
   /* Contains information about namespace-related info relevant to this block:
      using directives and the current namespace scope.  */
@@ -143,7 +143,7 @@ struct global_block
 #define BLOCK_END(bl)          (bl)->endaddr
 #define BLOCK_FUNCTION(bl)     (bl)->function
 #define BLOCK_SUPERBLOCK(bl)   (bl)->superblock
-#define BLOCK_DICT(bl)         (bl)->dict
+#define BLOCK_MULTIDICT(bl)    (bl)->multidict
 #define BLOCK_NAMESPACE(bl)    (bl)->namespace_info
 
 /* Accessor for ranges field within block BL.  */
@@ -298,9 +298,9 @@ struct block_iterator
 
   enum block_enum which;
 
-  /* The underlying dictionary iterator.  */
+  /* The underlying multidictionary iterator.  */
 
-  struct dict_iterator dict_iter;
+  struct mdict_iterator mdict_iter;
 };
 
 /* Initialize ITERATOR to point at the first symbol in BLOCK, and
index 1afff3d..bd0f25e 100644 (file)
@@ -227,22 +227,20 @@ buildsym_compunit::finish_block_internal
 
   if (symbol)
     {
-      BLOCK_DICT (block)
-       = dict_create_linear (&m_objfile->objfile_obstack,
-                             m_language, *listhead);
+      BLOCK_MULTIDICT (block)
+       = mdict_create_linear (&m_objfile->objfile_obstack, *listhead);
     }
   else
     {
       if (expandable)
        {
-         BLOCK_DICT (block) = dict_create_hashed_expandable (m_language);
-         dict_add_pending (BLOCK_DICT (block), *listhead);
+         BLOCK_MULTIDICT (block) = mdict_create_hashed_expandable (m_language);
+         mdict_add_pending (BLOCK_MULTIDICT (block), *listhead);
        }
       else
        {
-         BLOCK_DICT (block) =
-           dict_create_hashed (&m_objfile->objfile_obstack,
-                               m_language, *listhead);
+         BLOCK_MULTIDICT (block) =
+           mdict_create_hashed (&m_objfile->objfile_obstack, *listhead);
        }
     }
 
@@ -254,7 +252,7 @@ buildsym_compunit::finish_block_internal
   if (symbol)
     {
       struct type *ftype = SYMBOL_TYPE (symbol);
-      struct dict_iterator iter;
+      struct mdict_iterator miter;
       SYMBOL_BLOCK_VALUE (symbol) = block;
       BLOCK_FUNCTION (block) = symbol;
 
@@ -268,7 +266,7 @@ buildsym_compunit::finish_block_internal
 
          /* Here we want to directly access the dictionary, because
             we haven't fully initialized the block yet.  */
-         ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+         ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
            {
              if (SYMBOL_IS_ARGUMENT (sym))
                nparams++;
@@ -282,7 +280,7 @@ buildsym_compunit::finish_block_internal
              iparams = 0;
              /* Here we want to directly access the dictionary, because
                 we haven't fully initialized the block yet.  */
-             ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+             ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
                {
                  if (iparams == nparams)
                    break;
@@ -1066,7 +1064,7 @@ buildsym_compunit::end_symtab_with_blockvector (struct block *static_block,
       {
        struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i);
        struct symbol *sym;
-       struct dict_iterator iter;
+       struct mdict_iterator miter;
 
        /* Inlined functions may have symbols not in the global or
           static symbol lists.  */
@@ -1077,7 +1075,7 @@ buildsym_compunit::end_symtab_with_blockvector (struct block *static_block,
        /* Note that we only want to fix up symbols from the local
           blocks, not blocks coming from included symtabs.  That is why
           we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS.  */
-       ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+       ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
          if (symbol_symtab (sym) == NULL)
            symbol_set_symtab (sym, symtab);
       }
@@ -1211,7 +1209,7 @@ buildsym_compunit::augment_type_symtab ()
         to the primary symtab.  */
       set_missing_symtab (m_file_symbols, cust);
 
-      dict_add_pending (BLOCK_DICT (block), m_file_symbols);
+      mdict_add_pending (BLOCK_MULTIDICT (block), m_file_symbols);
     }
 
   if (m_global_symbols != NULL)
@@ -1222,7 +1220,7 @@ buildsym_compunit::augment_type_symtab ()
         to the primary symtab.  */
       set_missing_symtab (m_global_symbols, cust);
 
-      dict_add_pending (BLOCK_DICT (block),
+      mdict_add_pending (BLOCK_MULTIDICT (block),
                        m_global_symbols);
     }
 }
index 5e17a8b..5705dbb 100644 (file)
 
 #include "symfile.h"
 
-/* An opaque type for dictionaries; only dictionary.c should know
-   about its innards.  */
+/* An opaque type for multi-language dictionaries; only dictionary.c should
+   know about its innards.  */
 
-struct dictionary;
+struct multidictionary;
 
 /* Other types needed for declarations.  */
 
@@ -38,65 +38,64 @@ struct pending;
 struct language_defn;
 
 /* The creation functions for various implementations of
-   dictionaries.  */
+   multi-language dictionaries.  */
 
-/* Create a dictionary of symbols of language LANGUAGE implemented via
+/* Create a multi-language dictionary of symbols implemented via
    a fixed-size hashtable.  All memory it uses is allocated on
    OBSTACK; the environment is initialized from SYMBOL_LIST.  */
 
-extern struct dictionary *dict_create_hashed (struct obstack *obstack,
-                                             enum language language,
-                                             const struct pending
-                                             *symbol_list);
+extern struct multidictionary *
+  mdict_create_hashed (struct obstack *obstack,
+                      const struct pending *symbol_list);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
-   via a hashtable that grows as necessary.  The dictionary is
-   initially empty; to add symbols to it, call dict_add_symbol().
-   Call dict_free() when you're done with it.  */
+/* Create a multi-language dictionary of symbols, implemented
+   via a hashtable that grows as necessary.  The initial dictionary of
+   LANGUAGE is empty; to add symbols to it, call mdict_add_symbol().
+   Call mdict_free() when you're done with it.  */
 
-extern struct dictionary *
-  dict_create_hashed_expandable (enum language language);
+extern struct multidictionary *
+  mdict_create_hashed_expandable (enum language language);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
+/* Create a multi-language dictionary of symbols, implemented
    via a fixed-size array.  All memory it uses is allocated on
    OBSTACK; the environment is initialized from the SYMBOL_LIST.  The
    symbols are ordered in the same order that they're found in
    SYMBOL_LIST.  */
 
-extern struct dictionary *dict_create_linear (struct obstack *obstack,
-                                             enum language language,
-                                             const struct pending
-                                             *symbol_list);
+extern struct multidictionary *
+  mdict_create_linear (struct obstack *obstack,
+                      const struct pending *symbol_list);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
-   via an array that grows as necessary.  The dictionary is initially
-   empty; to add symbols to it, call dict_add_symbol().  Call
-   dict_free() when you're done with it.  */
+/* Create a multi-language dictionary of symbols, implemented
+   via an array that grows as necessary.  The multidictionary initially
+   contains a single empty dictionary of LANGUAGE; to add symbols to it,
+   call mdict_add_symbol().  Call mdict_free() when you're done with it.  */
 
-extern struct dictionary *
-  dict_create_linear_expandable (enum language language);
+extern struct multidictionary *
+  mdict_create_linear_expandable (enum language language);
 
-/* The functions providing the interface to dictionaries.  Note that
-   the most common parts of the interface, namely symbol lookup, are
-   only provided via iterator functions.  */
+/* The functions providing the interface to multi-language dictionaries.
+   Note that the most common parts of the interface, namely symbol lookup,
+   are only provided via iterator functions.  */
 
-/* Free the memory used by a dictionary that's not on an obstack.  (If
+/* Free the memory used by a multidictionary that's not on an obstack.  (If
    any.)  */
 
-extern void dict_free (struct dictionary *dict);
+extern void mdict_free (struct multidictionary *mdict);
 
-/* Add a symbol to an expandable dictionary.  */
+/* Add a symbol to an expandable multidictionary.  */
 
-extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym);
+extern void mdict_add_symbol (struct multidictionary *mdict,
+                             struct symbol *sym);
 
-/* Utility to add a list of symbols to a dictionary.  */
+/* Utility to add a list of symbols to a multidictionary.  */
 
-extern void dict_add_pending (struct dictionary *dict,
-                             const struct pending *symbol_list);
+extern void mdict_add_pending (struct multidictionary *mdict,
+                              const struct pending *symbol_list);
 
-/* Is the dictionary empty?  */
+/* Is the multidictionary empty?  */
 
-extern int dict_empty (struct dictionary *dict);
+extern int mdict_empty (struct multidictionary *mdict);
 
 /* A type containing data that is used when iterating over all symbols
    in a dictionary.  Don't ever look at its innards; this type would
@@ -128,44 +127,46 @@ struct mdict_iterator
   unsigned short current_idx;
 };
 
-/* Initialize ITERATOR to point at the first symbol in DICT, and
-   return that first symbol, or NULL if DICT is empty.  */
+/* Initialize ITERATOR to point at the first symbol in MDICT, and
+   return that first symbol, or NULL if MDICT is empty.  */
 
-extern struct symbol *dict_iterator_first (const struct dictionary *dict,
-                                          struct dict_iterator *iterator);
+extern struct symbol *
+  mdict_iterator_first (const struct multidictionary *mdict,
+                       struct mdict_iterator *miterator);
 
-/* Advance ITERATOR, and return the next symbol, or NULL if there are
+/* Advance MITERATOR, and return the next symbol, or NULL if there are
    no more symbols.  Don't call this if you've previously received
-   NULL from dict_iterator_first or dict_iterator_next on this
+   NULL from mdict_iterator_first or mdict_iterator_next on this
    iteration.  */
 
-extern struct symbol *dict_iterator_next (struct dict_iterator *iterator);
+extern struct symbol *mdict_iterator_next (struct mdict_iterator *miterator);
 
-/* Initialize ITERATOR to point at the first symbol in DICT whose
+/* Initialize MITERATOR to point at the first symbol in MDICT whose
    SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use
    the same conventions as strcmp_iw and be compatible with any
    dictionary hashing function), and return that first symbol, or NULL
    if there are no such symbols.  */
 
-extern struct symbol *dict_iter_match_first (const struct dictionary *dict,
-                                            const lookup_name_info &name,
-                                            struct dict_iterator *iterator);
+extern struct symbol *
+  mdict_iter_match_first (const struct multidictionary *mdict,
+                         const lookup_name_info &name,
+                         struct mdict_iterator *miterator);
 
-/* Advance ITERATOR to point at the next symbol in DICT whose
+/* Advance MITERATOR to point at the next symbol in MDICT whose
    SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see
    dict_iter_match_first), or NULL if there are no more such symbols.
    Don't call this if you've previously received NULL from 
-   dict_iterator_match_first or dict_iterator_match_next on this
-   iteration.  And don't call it unless ITERATOR was created by a
-   previous call to dict_iter_match_first with the same NAME and COMPARE.  */
+   mdict_iterator_match_first or mdict_iterator_match_next on this
+   iteration.  And don't call it unless MITERATOR was created by a
+   previous call to mdict_iter_match_first with the same NAME and COMPARE.  */
 
-extern struct symbol *dict_iter_match_next (const lookup_name_info &name,
-                                           struct dict_iterator *iterator);
+extern struct symbol *mdict_iter_match_next (const lookup_name_info &name,
+                                            struct mdict_iterator *miterator);
 
-/* Return some notion of the size of the dictionary: the number of
+/* Return some notion of the size of the multidictionary: the number of
    symbols if we have that, the number of hash buckets otherwise.  */
 
-extern int dict_size (const struct dictionary *dict);
+extern int mdict_size (const struct multidictionary *mdict);
 
 /* Macro to loop through all symbols in a dictionary DICT, in no
    particular order.  ITER is a struct dict_iterator (NOTE: __not__ a
@@ -175,8 +176,8 @@ extern int dict_size (const struct dictionary *dict);
    early by a break if you desire.  */
 
 #define ALL_DICT_SYMBOLS(dict, iter, sym)                      \
-       for ((sym) = dict_iterator_first ((dict), &(iter));     \
+       for ((sym) = mdict_iterator_first ((dict), &(iter));    \
             (sym);                                             \
-            (sym) = dict_iterator_next (&(iter)))
+            (sym) = mdict_iterator_next (&(iter)))
 
 #endif /* DICTIONARY_H */
index 8b7f715..35e44e3 100644 (file)
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -651,14 +651,12 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
   size_t blockvector_size;
   CORE_ADDR begin, end;
   struct blockvector *bv;
-  enum language language;
 
   actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
 
   cust = allocate_compunit_symtab (objfile, stab->file_name);
   allocate_symtab (cust, stab->file_name);
   add_compunit_symtab_to_objfile (cust);
-  language = compunit_language (cust);
 
   /* JIT compilers compile in memory.  */
   COMPUNIT_DIRNAME (cust) = NULL;
@@ -702,8 +700,8 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
                                           TARGET_CHAR_BIT,
                                           "void");
 
-      BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
-                                                  language, NULL);
+      BLOCK_MULTIDICT (new_block)
+       = mdict_create_linear (&objfile->objfile_obstack, NULL);
       /* The address range.  */
       BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
@@ -740,8 +738,8 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
       new_block = (i == GLOBAL_BLOCK
                   ? allocate_global_block (&objfile->objfile_obstack)
                   : allocate_block (&objfile->objfile_obstack));
-      BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
-                                                  language, NULL);
+      BLOCK_MULTIDICT (new_block)
+       = mdict_create_linear (&objfile->objfile_obstack, NULL);
       BLOCK_SUPERBLOCK (new_block) = block_iter;
       block_iter = new_block;
 
index 63cbb30..4bdf973 100644 (file)
@@ -4506,7 +4506,7 @@ static void
 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
 {
   symbol_set_symtab (s, symtab);
-  dict_add_symbol (BLOCK_DICT (b), s);
+  mdict_add_symbol (BLOCK_MULTIDICT (b), s);
 }
 
 /* Add a new block B to a symtab S.  */
@@ -4734,7 +4734,7 @@ new_bvect (int nblocks)
 }
 
 /* Allocate and zero a new block of language LANGUAGE, and set its
-   BLOCK_DICT.  If function is non-zero, assume the block is
+   BLOCK_MULTIDICT.  If function is non-zero, assume the block is
    associated to a function, and make sure that the symbols are stored
    linearly; otherwise, store them hashed.  */
 
@@ -4747,9 +4747,9 @@ new_block (enum block_type type, enum language language)
   struct block *retval = XCNEW (struct block);
 
   if (type == FUNCTION_BLOCK)
-    BLOCK_DICT (retval) = dict_create_linear_expandable (language);
+    BLOCK_MULTIDICT (retval) = mdict_create_linear_expandable (language);
   else
-    BLOCK_DICT (retval) = dict_create_hashed_expandable (language);
+    BLOCK_MULTIDICT (retval) = mdict_create_hashed_expandable (language);
 
   return retval;
 }
index 255a3d6..854e87d 100644 (file)
@@ -818,7 +818,7 @@ objfile_relocate1 (struct objfile *objfile,
          {
            struct block *b;
            struct symbol *sym;
-           struct dict_iterator iter;
+           struct mdict_iterator miter;
 
            b = BLOCKVECTOR_BLOCK (bv, i);
            BLOCK_START (b) += ANOFFSET (delta, block_line_section);
@@ -835,7 +835,7 @@ objfile_relocate1 (struct objfile *objfile,
 
            /* We only want to iterate over the local symbols, not any
               symbols in included symtabs.  */
-           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
+           ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
              {
                relocate_one_symbol (sym, objfile, delta);
              }
index f798c6f..92c054c 100644 (file)
@@ -276,7 +276,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
   struct objfile *objfile = SYMTAB_OBJFILE (symtab);
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   int i;
-  struct dict_iterator iter;
+  struct mdict_iterator miter;
   int len;
   struct linetable *l;
   const struct blockvector *bv;
@@ -332,7 +332,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
             even if we're using a hashtable, but nothing else but this message
             wants it.  */
          fprintf_filtered (outfile, ", %d syms/buckets in ",
-                           dict_size (BLOCK_DICT (b)));
+                           mdict_size (BLOCK_MULTIDICT (b)));
          fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
          fprintf_filtered (outfile, "..");
          fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
@@ -350,7 +350,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
          /* Now print each symbol in this block (in no particular order, if
             we're using a hashtable).  Note that we only want this
             block, not any blocks from included symtabs.  */
-         ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
+         ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
            {
              TRY
                {