diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ccf5dbdf88..27e08d30cf 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,20 @@
+YYYY-MM-DD  Keith Seitz  <keiths@redhat.com>
+
+	PR gdb/23712
+	* dictionary.h: Replace declaration of dictionary 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.
+
 YYYY-MM-DD  Keith Seitz  <keiths@redhat.com>
 
 	PR gdb/23712
diff --git a/gdb/block.c b/gdb/block.c
index 85e6c618d7..f0dbfbec89 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -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;
diff --git a/gdb/block.h b/gdb/block.h
index 0050eacf8d..0c78a3af46 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -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
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index a9d2698584..a3a067cccf 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -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;
@@ -1067,7 +1065,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.  */
@@ -1078,7 +1076,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);
       }
@@ -1212,7 +1210,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)
@@ -1223,7 +1221,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);
     }
 }
diff --git a/gdb/dictionary.h b/gdb/dictionary.h
index d9c4ad491c..ef99a65099 100644
--- a/gdb/dictionary.h
+++ b/gdb/dictionary.h
@@ -25,10 +25,10 @@
 
 #include "symfile.h"
 
-/* An opaque type for dictionaries; only dictionary.c should know
-   about its innards.  */
+/* An opaque type for multi-language dictionaries; only dictionary.c should
+   know about its innards.  */
 
-struct dictionary;
+struct multidictionary;
 
 /* Other types needed for declarations.  */
 
@@ -38,65 +38,64 @@ struct pending;
 struct language_defn;
 
 /* The creation functions for various implementations of
-   dictionaries.  */
+   multi-language dictionaries.  */
 
-/* Create a dictionary of symbols of language LANGUAGE implemented via
+/* Create a multi-language dictionary of symbols implemented via
    a fixed-size hashtable.  All memory it uses is allocated on
    OBSTACK; the environment is initialized from SYMBOL_LIST.  */
 
-extern struct dictionary *dict_create_hashed (struct obstack *obstack,
-					      enum language language,
-					      const struct pending
-					      *symbol_list);
+extern struct multidictionary *
+  mdict_create_hashed (struct obstack *obstack,
+		       const struct pending *symbol_list);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
-   via a hashtable that grows as necessary.  The dictionary is
-   initially empty; to add symbols to it, call dict_add_symbol().
-   Call dict_free() when you're done with it.  */
+/* Create a multi-language dictionary of symbols, implemented
+   via a hashtable that grows as necessary.  The initial dictionary of
+   LANGUAGE is empty; to add symbols to it, call mdict_add_symbol().
+   Call mdict_free() when you're done with it.  */
 
-extern struct dictionary *
-  dict_create_hashed_expandable (enum language language);
+extern struct multidictionary *
+  mdict_create_hashed_expandable (enum language language);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
+/* Create a multi-language dictionary of symbols, implemented
    via a fixed-size array.  All memory it uses is allocated on
    OBSTACK; the environment is initialized from the SYMBOL_LIST.  The
    symbols are ordered in the same order that they're found in
    SYMBOL_LIST.  */
 
-extern struct dictionary *dict_create_linear (struct obstack *obstack,
-					      enum language language,
-					      const struct pending
-					      *symbol_list);
+extern struct multidictionary *
+  mdict_create_linear (struct obstack *obstack,
+		       const struct pending *symbol_list);
 
-/* Create a dictionary of symbols of language LANGUAGE, implemented
-   via an array that grows as necessary.  The dictionary is initially
-   empty; to add symbols to it, call dict_add_symbol().  Call
-   dict_free() when you're done with it.  */
+/* Create a multi-language dictionary of symbols, implemented
+   via an array that grows as necessary.  The multidictionary initially
+   contains a single empty dictionary of LANGUAGE; to add symbols to it,
+   call mdict_add_symbol().  Call mdict_free() when you're done with it.  */
 
-extern struct dictionary *
-  dict_create_linear_expandable (enum language language);
+extern struct multidictionary *
+  mdict_create_linear_expandable (enum language language);
 
-/* The functions providing the interface to dictionaries.  Note that
-   the most common parts of the interface, namely symbol lookup, are
-   only provided via iterator functions.  */
+/* The functions providing the interface to multi-language dictionaries.
+   Note that the most common parts of the interface, namely symbol lookup,
+   are only provided via iterator functions.  */
 
-/* Free the memory used by a dictionary that's not on an obstack.  (If
+/* Free the memory used by a multidictionary that's not on an obstack.  (If
    any.)  */
 
-extern void dict_free (struct dictionary *dict);
+extern void mdict_free (struct multidictionary *mdict);
 
-/* Add a symbol to an expandable dictionary.  */
+/* Add a symbol to an expandable multidictionary.  */
 
-extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym);
+extern void mdict_add_symbol (struct multidictionary *mdict,
+			      struct symbol *sym);
 
-/* Utility to add a list of symbols to a dictionary.  */
+/* Utility to add a list of symbols to a multidictionary.  */
 
-extern void dict_add_pending (struct dictionary *dict,
-			      const struct pending *symbol_list);
+extern void mdict_add_pending (struct multidictionary *mdict,
+			       const struct pending *symbol_list);
 
-/* Is the dictionary empty?  */
+/* Is the multidictionary empty?  */
 
-extern int dict_empty (struct dictionary *dict);
+extern int mdict_empty (struct multidictionary *mdict);
 
 /* A type containing data that is used when iterating over all symbols
    in a dictionary.  Don't ever look at its innards; this type would
@@ -128,44 +127,46 @@ struct mdict_iterator
   unsigned short current_idx;
 };
 
-/* Initialize ITERATOR to point at the first symbol in DICT, and
-   return that first symbol, or NULL if DICT is empty.  */
+/* Initialize ITERATOR to point at the first symbol in MDICT, and
+   return that first symbol, or NULL if MDICT is empty.  */
 
-extern struct symbol *dict_iterator_first (const struct dictionary *dict,
-					   struct dict_iterator *iterator);
+extern struct symbol *
+  mdict_iterator_first (const struct multidictionary *mdict,
+			struct mdict_iterator *miterator);
 
-/* Advance ITERATOR, and return the next symbol, or NULL if there are
+/* Advance MITERATOR, and return the next symbol, or NULL if there are
    no more symbols.  Don't call this if you've previously received
-   NULL from dict_iterator_first or dict_iterator_next on this
+   NULL from mdict_iterator_first or mdict_iterator_next on this
    iteration.  */
 
-extern struct symbol *dict_iterator_next (struct dict_iterator *iterator);
+extern struct symbol *mdict_iterator_next (struct mdict_iterator *miterator);
 
-/* Initialize ITERATOR to point at the first symbol in DICT whose
+/* Initialize MITERATOR to point at the first symbol in MDICT whose
    SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use
    the same conventions as strcmp_iw and be compatible with any
    dictionary hashing function), and return that first symbol, or NULL
    if there are no such symbols.  */
 
-extern struct symbol *dict_iter_match_first (const struct dictionary *dict,
-					     const lookup_name_info &name,
-					     struct dict_iterator *iterator);
+extern struct symbol *
+  mdict_iter_match_first (const struct multidictionary *mdict,
+			  const lookup_name_info &name,
+			  struct mdict_iterator *miterator);
 
-/* Advance ITERATOR to point at the next symbol in DICT whose
+/* Advance MITERATOR to point at the next symbol in MDICT whose
    SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see
    dict_iter_match_first), or NULL if there are no more such symbols.
    Don't call this if you've previously received NULL from 
-   dict_iterator_match_first or dict_iterator_match_next on this
-   iteration.  And don't call it unless ITERATOR was created by a
-   previous call to dict_iter_match_first with the same NAME and COMPARE.  */
+   mdict_iterator_match_first or mdict_iterator_match_next on this
+   iteration.  And don't call it unless MITERATOR was created by a
+   previous call to mdict_iter_match_first with the same NAME and COMPARE.  */
 
-extern struct symbol *dict_iter_match_next (const lookup_name_info &name,
-					    struct dict_iterator *iterator);
+extern struct symbol *mdict_iter_match_next (const lookup_name_info &name,
+					     struct mdict_iterator *miterator);
 
-/* Return some notion of the size of the dictionary: the number of
+/* Return some notion of the size of the multidictionary: the number of
    symbols if we have that, the number of hash buckets otherwise.  */
 
-extern int dict_size (const struct dictionary *dict);
+extern int mdict_size (const struct multidictionary *mdict);
 
 /* Macro to loop through all symbols in a dictionary DICT, in no
    particular order.  ITER is a struct dict_iterator (NOTE: __not__ a
@@ -175,8 +176,8 @@ extern int dict_size (const struct dictionary *dict);
    early by a break if you desire.  */
 
 #define ALL_DICT_SYMBOLS(dict, iter, sym)			\
-	for ((sym) = dict_iterator_first ((dict), &(iter));	\
+	for ((sym) = mdict_iterator_first ((dict), &(iter));	\
 	     (sym);						\
-	     (sym) = dict_iterator_next (&(iter)))
+	     (sym) = mdict_iterator_next (&(iter)))
 
 #endif /* DICTIONARY_H */
diff --git a/gdb/jit.c b/gdb/jit.c
index e6b3cc25ca..ea067c7b33 100644
--- 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;
 
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 26687f6c8d..54dba80449 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -4502,7 +4502,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.  */
@@ -4730,7 +4730,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.  */
 
@@ -4743,9 +4743,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;
 }
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index a9b8fa7c58..5e2fc826d5 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -822,7 +822,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);
@@ -838,7 +838,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);
 	    }
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index d30a35481e..83bd6464da 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -275,7 +275,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;
@@ -331,7 +331,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);
@@ -349,7 +349,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
 		{
