X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fbuildsym.c;h=8e05706c4be7ead2ce8dbae8d76f7c7c2a60e6a7;hb=082cce059d78bdb4a9fadbbacc2cd1dc3668f084;hp=07bfbd5038946bbe09c4d689efda850300493574;hpb=5033013f17524964564dac5d422739ae5214729e;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index 07bfbd5038..8e05706c4b 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -1,5 +1,5 @@
 /* Support routines for building symbol tables in GDB's internal format.
-   Copyright (C) 1986-2017 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -16,60 +16,8 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-/* This module provides subroutines used for creating and adding to
-   the symbol table.  These routines are called from various symbol-
-   file-reading routines.
-
-   Routines to support specific debugging information formats (stabs,
-   DWARF, etc) belong somewhere else.
-
-   The basic way this module is used is as follows:
-
-   buildsym_init ();
-   cleanups = make_cleanup (really_free_pendings, NULL);
-   cust = start_symtab (...);
-   ... read debug info ...
-   cust = end_symtab (...);
-   do_cleanups (cleanups);
-
-   The compunit symtab pointer ("cust") is returned from both start_symtab
-   and end_symtab to simplify the debug info readers.
-
-   There are minor variations on this, e.g., dwarf2read.c splits end_symtab
-   into two calls: end_symtab_get_static_block, end_symtab_from_static_block,
-   but all debug info readers follow this basic flow.
-
-   Reading DWARF Type Units is another variation:
-
-   buildsym_init ();
-   cleanups = make_cleanup (really_free_pendings, NULL);
-   cust = start_symtab (...);
-   ... read debug info ...
-   cust = end_expandable_symtab (...);
-   do_cleanups (cleanups);
-
-   And then reading subsequent Type Units within the containing "Comp Unit"
-   will use a second flow:
-
-   buildsym_init ();
-   cleanups = make_cleanup (really_free_pendings, NULL);
-   cust = restart_symtab (...);
-   ... read debug info ...
-   cust = augment_type_symtab (...);
-   do_cleanups (cleanups);
-
-   dbxread.c and xcoffread.c use another variation:
-
-   buildsym_init ();
-   cleanups = make_cleanup (really_free_pendings, NULL);
-   cust = start_symtab (...);
-   ... read debug info ...
-   cust = end_symtab (...);
-   ... start_symtab + read + end_symtab repeated ...
-   do_cleanups (cleanups);
-*/
-
 #include "defs.h"
+#include "buildsym-legacy.h"
 #include "bfd.h"
 #include "gdb_obstack.h"
 #include "symtab.h"
@@ -78,7 +26,6 @@
 #include "gdbtypes.h"
 #include "complaints.h"
 #include "expression.h"		/* For "enum exp_opcode" used by...  */
-#include "bcache.h"
 #include "filenames.h"		/* For DOSish file names.  */
 #include "macrotab.h"
 #include "demangle.h"		/* Needed by SYMBOL_INIT_DEMANGLED_NAME.  */
@@ -88,83 +35,11 @@
 #include "addrmap.h"
 #include <algorithm>
 
-/* Ask buildsym.h to define the vars it normally declares `extern'.  */
-#define	EXTERN
-/**/
-#include "buildsym.h"		/* Our own declarations.  */
-#undef	EXTERN
-
 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
    questionable--see comment where we call them).  */
 
 #include "stabsread.h"
 
-/* Buildsym's counterpart to struct compunit_symtab.
-   TODO(dje): Move all related global state into here.  */
-
-struct buildsym_compunit
-{
-  /* The objfile we're reading debug info from.  */
-  struct objfile *objfile;
-
-  /* List of subfiles (source files).
-     Files are added to the front of the list.
-     This is important mostly for the language determination hacks we use,
-     which iterate over previously added files.  */
-  struct subfile *subfiles;
-
-  /* The subfile of the main source file.  */
-  struct subfile *main_subfile;
-
-  /* E.g., DW_AT_comp_dir if DWARF.  Space for this is malloc'd.  */
-  char *comp_dir;
-
-  /* Space for this is not malloc'd, and is assumed to have at least
-     the same lifetime as objfile.  */
-  const char *producer;
-
-  /* Space for this is not malloc'd, and is assumed to have at least
-     the same lifetime as objfile.  */
-  const char *debugformat;
-
-  /* The compunit we are building.  */
-  struct compunit_symtab *compunit_symtab;
-};
-
-/* The work-in-progress of the compunit we are building.
-   This is created first, before any subfiles by start_symtab.  */
-
-static struct buildsym_compunit *buildsym_compunit;
-
-/* List of free `struct pending' structures for reuse.  */
-
-static struct pending *free_pendings;
-
-/* Non-zero if symtab has line number info.  This prevents an
-   otherwise empty symtab from being tossed.  */
-
-static int have_line_numbers;
-
-/* The mutable address map for the compilation unit whose symbols
-   we're currently reading.  The symtabs' shared blockvector will
-   point to a fixed copy of this.  */
-static struct addrmap *pending_addrmap;
-
-/* The obstack on which we allocate pending_addrmap.
-   If pending_addrmap is NULL, this is uninitialized; otherwise, it is
-   initialized (and holds pending_addrmap).  */
-static struct obstack pending_addrmap_obstack;
-
-/* Non-zero if we recorded any ranges in the addrmap that are
-   different from those in the blockvector already.  We set this to
-   zero when we start processing a symfile, and if it's still zero at
-   the end, then we just toss the addrmap.  */
-static int pending_addrmap_interesting;
-
-/* An obstack used for allocating pending blocks.  */
-
-static struct obstack pending_block_obstack;
-
 /* List of blocks already made (lexical contexts already closed).
    This is used at the end to make the blockvector.  */
 
@@ -174,40 +49,83 @@ struct pending_block
     struct block *block;
   };
 
-/* Pointer to the head of a linked list of symbol blocks which have
-   already been finalized (lexical contexts already closed) and which
-   are just waiting to be built into a blockvector when finalizing the
-   associated symtab.  */
+static int compare_line_numbers (const void *ln1p, const void *ln2p);
 
-static struct pending_block *pending_blocks;
+/* Initial sizes of data structures.  These are realloc'd larger if
+   needed, and realloc'd down to the size actually used, when
+   completed.  */
 
-struct subfile_stack
-  {
-    struct subfile_stack *next;
-    char *name;
-  };
+#define	INITIAL_LINE_VECTOR_LENGTH	1000
+
 
-static struct subfile_stack *subfile_stack;
+buildsym_compunit::buildsym_compunit (struct objfile *objfile_,
+				      const char *name,
+				      const char *comp_dir_,
+				      enum language language_,
+				      CORE_ADDR last_addr)
+  : m_objfile (objfile_),
+    m_last_source_file (name == nullptr ? nullptr : xstrdup (name)),
+    m_comp_dir (comp_dir_ == nullptr ? nullptr : xstrdup (comp_dir_)),
+    m_language (language_),
+    m_last_source_start_addr (last_addr)
+{
+  /* Allocate the compunit symtab now.  The caller needs it to allocate
+     non-primary symtabs.  It is also needed by get_macro_table.  */
+  m_compunit_symtab = allocate_compunit_symtab (m_objfile, name);
 
-/* The macro table for the compilation unit whose symbols we're
-   currently reading.  */
-static struct macro_table *pending_macros;
+  /* Build the subfile for NAME (the main source file) so that we can record
+     a pointer to it for later.
+     IMPORTANT: Do not allocate a struct symtab for NAME here.
+     It can happen that the debug info provides a different path to NAME than
+     DIRNAME,NAME.  We cope with this in watch_main_source_file_lossage but
+     that only works if the main_subfile doesn't have a symtab yet.  */
+  start_subfile (name);
+  /* Save this so that we don't have to go looking for it at the end
+     of the subfiles list.  */
+  m_main_subfile = m_current_subfile;
+}
 
-static void free_buildsym_compunit (void);
+buildsym_compunit::~buildsym_compunit ()
+{
+  struct subfile *subfile, *nextsub;
 
-static int compare_line_numbers (const void *ln1p, const void *ln2p);
+  if (m_pending_macros != nullptr)
+    free_macro_table (m_pending_macros);
 
-static void record_pending_block (struct objfile *objfile,
-				  struct block *block,
-				  struct pending_block *opblock);
+  for (subfile = m_subfiles;
+       subfile != NULL;
+       subfile = nextsub)
+    {
+      nextsub = subfile->next;
+      xfree (subfile->name);
+      xfree (subfile->line_vector);
+      xfree (subfile);
+    }
 
-/* Initial sizes of data structures.  These are realloc'd larger if
-   needed, and realloc'd down to the size actually used, when
-   completed.  */
+  struct pending *next, *next1;
 
-#define	INITIAL_CONTEXT_STACK_SIZE	10
-#define	INITIAL_LINE_VECTOR_LENGTH	1000
-
+  for (next = m_file_symbols; next != NULL; next = next1)
+    {
+      next1 = next->next;
+      xfree ((void *) next);
+    }
+
+  for (next = m_global_symbols; next != NULL; next = next1)
+    {
+      next1 = next->next;
+      xfree ((void *) next);
+    }
+}
+
+struct macro_table *
+buildsym_compunit::get_macro_table ()
+{
+  if (m_pending_macros == nullptr)
+    m_pending_macros = new_macro_table (&m_objfile->per_bfd->storage_obstack,
+					&m_objfile->per_bfd->macro_cache,
+					m_compunit_symtab);
+  return m_pending_macros;
+}
 
 /* Maintain the lists of symbols and blocks.  */
 
@@ -226,16 +144,7 @@ add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
      don't have a link with room in it, add a new link.  */
   if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE)
     {
-      if (free_pendings)
-	{
-	  link = free_pendings;
-	  free_pendings = link->next;
-	}
-      else
-	{
-	  link = XNEW (struct pending);
-	}
-
+      link = XNEW (struct pending);
       link->next = *listhead;
       *listhead = link;
       link->nsyms = 0;
@@ -269,61 +178,27 @@ find_symbol_in_list (struct pending *list, char *name, int length)
   return (NULL);
 }
 
-/* At end of reading syms, or in case of quit, ensure everything associated
-   with building symtabs is freed.  This is intended to be registered as a
-   cleanup before doing psymtab->symtab expansion.
-
-   N.B. This is *not* intended to be used when building psymtabs.  Some debug
-   info readers call this anyway, which is harmless if confusing.  */
+/* 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.  */
 
 void
-really_free_pendings (void *dummy)
+buildsym_compunit::record_pending_block (struct block *block,
+					 struct pending_block *opblock)
 {
-  struct pending *next, *next1;
-
-  for (next = free_pendings; next; next = next1)
-    {
-      next1 = next->next;
-      xfree ((void *) next);
-    }
-  free_pendings = NULL;
-
-  free_pending_blocks ();
-
-  for (next = file_symbols; next != NULL; next = next1)
-    {
-      next1 = next->next;
-      xfree ((void *) next);
-    }
-  file_symbols = NULL;
+  struct pending_block *pblock;
 
-  for (next = global_symbols; next != NULL; next = next1)
+  pblock = XOBNEW (&m_pending_block_obstack, struct pending_block);
+  pblock->block = block;
+  if (opblock)
     {
-      next1 = next->next;
-      xfree ((void *) next);
+      pblock->next = opblock->next;
+      opblock->next = pblock;
     }
-  global_symbols = NULL;
-
-  if (pending_macros)
-    free_macro_table (pending_macros);
-  pending_macros = NULL;
-
-  if (pending_addrmap)
-    obstack_free (&pending_addrmap_obstack, NULL);
-  pending_addrmap = NULL;
-
-  free_buildsym_compunit ();
-}
-
-/* This function is called to discard any pending blocks.  */
-
-void
-free_pending_blocks (void)
-{
-  if (pending_blocks != NULL)
+  else
     {
-      obstack_free (&pending_block_obstack, NULL);
-      pending_blocks = NULL;
+      pblock->next = m_pending_blocks;
+      m_pending_blocks = pblock;
     }
 }
 
@@ -331,41 +206,41 @@ free_pending_blocks (void)
    the order the symbols have in the list (reversed from the input
    file).  Put the block on the list of pending blocks.  */
 
-static struct block *
-finish_block_internal (struct symbol *symbol,
-		       struct pending **listhead,
-		       struct pending_block *old_blocks,
-		       const struct dynamic_prop *static_link,
-		       CORE_ADDR start, CORE_ADDR end,
-		       int is_global, int expandable)
+struct block *
+buildsym_compunit::finish_block_internal
+    (struct symbol *symbol,
+     struct pending **listhead,
+     struct pending_block *old_blocks,
+     const struct dynamic_prop *static_link,
+     CORE_ADDR start, CORE_ADDR end,
+     int is_global, int expandable)
 {
-  struct objfile *objfile = buildsym_compunit->objfile;
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = get_objfile_arch (m_objfile);
   struct pending *next, *next1;
   struct block *block;
   struct pending_block *pblock;
   struct pending_block *opblock;
 
   block = (is_global
-	   ? allocate_global_block (&objfile->objfile_obstack)
-	   : allocate_block (&objfile->objfile_obstack));
+	   ? allocate_global_block (&m_objfile->objfile_obstack)
+	   : allocate_block (&m_objfile->objfile_obstack));
 
   if (symbol)
     {
-      BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack,
-					       *listhead);
+      BLOCK_MULTIDICT (block)
+	= mdict_create_linear (&m_objfile->objfile_obstack, *listhead);
     }
   else
     {
       if (expandable)
 	{
-	  BLOCK_DICT (block) = dict_create_hashed_expandable ();
-	  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 (&objfile->objfile_obstack, *listhead);
+	  BLOCK_MULTIDICT (block) =
+	    mdict_create_hashed (&m_objfile->objfile_obstack, *listhead);
 	}
     }
 
@@ -377,7 +252,7 @@ finish_block_internal (struct symbol *symbol,
   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;
 
@@ -391,7 +266,7 @@ finish_block_internal (struct symbol *symbol,
 
 	  /* Here we want to directly access the dictionary, because
 	     we haven't fully initialized the block yet.  */
-	  ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+	  ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
 	    {
 	      if (SYMBOL_IS_ARGUMENT (sym))
 		nparams++;
@@ -405,7 +280,7 @@ finish_block_internal (struct symbol *symbol,
 	      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;
@@ -426,15 +301,14 @@ finish_block_internal (struct symbol *symbol,
     }
 
   if (static_link != NULL)
-    objfile_register_static_link (objfile, block, static_link);
+    objfile_register_static_link (m_objfile, block, static_link);
 
-  /* Now "free" the links of the list, and empty the list.  */
+  /* Now free the links of the list, and empty the list.  */
 
   for (next = *listhead; next; next = next1)
     {
       next1 = next->next;
-      next->next = free_pendings;
-      free_pendings = next;
+      xfree (next);
     }
   *listhead = NULL;
 
@@ -445,15 +319,13 @@ finish_block_internal (struct symbol *symbol,
     {
       if (symbol)
 	{
-	  complaint (&symfile_complaints,
-		     _("block end address less than block "
+	  complaint (_("block end address less than block "
 		       "start address in %s (patched it)"),
 		     SYMBOL_PRINT_NAME (symbol));
 	}
       else
 	{
-	  complaint (&symfile_complaints,
-		     _("block end address %s less than block "
+	  complaint (_("block end address %s less than block "
 		       "start address %s (patched it)"),
 		     paddress (gdbarch, BLOCK_END (block)),
 		     paddress (gdbarch, BLOCK_START (block)));
@@ -466,7 +338,7 @@ finish_block_internal (struct symbol *symbol,
      start of this scope that don't have superblocks yet.  */
 
   opblock = NULL;
-  for (pblock = pending_blocks; 
+  for (pblock = m_pending_blocks;
        pblock && pblock != old_blocks; 
        pblock = pblock->next)
     {
@@ -485,14 +357,12 @@ finish_block_internal (struct symbol *symbol,
 	    {
 	      if (symbol)
 		{
-		  complaint (&symfile_complaints,
-			     _("inner block not inside outer block in %s"),
+		  complaint (_("inner block not inside outer block in %s"),
 			     SYMBOL_PRINT_NAME (symbol));
 		}
 	      else
 		{
-		  complaint (&symfile_complaints,
-			     _("inner block (%s-%s) not "
+		  complaint (_("inner block (%s-%s) not "
 			       "inside outer block (%s-%s)"),
 			     paddress (gdbarch, BLOCK_START (pblock->block)),
 			     paddress (gdbarch, BLOCK_END (pblock->block)),
@@ -511,61 +381,29 @@ finish_block_internal (struct symbol *symbol,
 
   block_set_using (block,
 		   (is_global
-		    ? global_using_directives
-		    : local_using_directives),
-		   &objfile->objfile_obstack);
+		    ? m_global_using_directives
+		    : m_local_using_directives),
+		   &m_objfile->objfile_obstack);
   if (is_global)
-    global_using_directives = NULL;
+    m_global_using_directives = NULL;
   else
-    local_using_directives = NULL;
+    m_local_using_directives = NULL;
 
-  record_pending_block (objfile, block, opblock);
+  record_pending_block (block, opblock);
 
   return block;
 }
 
 struct block *
-finish_block (struct symbol *symbol,
-	      struct pending **listhead,
-	      struct pending_block *old_blocks,
-	      const struct dynamic_prop *static_link,
-	      CORE_ADDR start, CORE_ADDR end)
+buildsym_compunit::finish_block (struct symbol *symbol,
+				 struct pending_block *old_blocks,
+				 const struct dynamic_prop *static_link,
+				 CORE_ADDR start, CORE_ADDR end)
 {
-  return finish_block_internal (symbol, listhead, old_blocks, static_link,
-				start, end, 0, 0);
+  return finish_block_internal (symbol, &m_local_symbols,
+				old_blocks, static_link, start, end, 0, 0);
 }
 
-/* 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.
-
-   Allocate the pending block struct in the objfile_obstack to save
-   time.  This wastes a little space.  FIXME: Is it worth it?  */
-
-static void
-record_pending_block (struct objfile *objfile, struct block *block,
-		      struct pending_block *opblock)
-{
-  struct pending_block *pblock;
-
-  if (pending_blocks == NULL)
-    obstack_init (&pending_block_obstack);
-
-  pblock = XOBNEW (&pending_block_obstack, struct pending_block);
-  pblock->block = block;
-  if (opblock)
-    {
-      pblock->next = opblock->next;
-      opblock->next = pblock;
-    }
-  else
-    {
-      pblock->next = pending_blocks;
-      pending_blocks = pblock;
-    }
-}
-
-
 /* Record that the range of addresses from START to END_INCLUSIVE
    (inclusive, like it says) belongs to BLOCK.  BLOCK's start and end
    addresses must be set already.  You must apply this function to all
@@ -575,8 +413,9 @@ record_pending_block (struct objfile *objfile, struct block *block,
    already provided by BLOCK_START and BLOCK_END, then we create an
    address map for the block.  */
 void
-record_block_range (struct block *block,
-                    CORE_ADDR start, CORE_ADDR end_inclusive)
+buildsym_compunit::record_block_range (struct block *block,
+				       CORE_ADDR start,
+				       CORE_ADDR end_inclusive)
 {
   /* If this is any different from the range recorded in the block's
      own BLOCK_START and BLOCK_END, then note that the address map has
@@ -585,33 +424,29 @@ record_block_range (struct block *block,
      need to record this block in the addrmap.  */
   if (start != BLOCK_START (block)
       || end_inclusive + 1 != BLOCK_END (block))
-    pending_addrmap_interesting = 1;
+    m_pending_addrmap_interesting = true;
 
-  if (! pending_addrmap)
-    {
-      obstack_init (&pending_addrmap_obstack);
-      pending_addrmap = addrmap_create_mutable (&pending_addrmap_obstack);
-    }
+  if (m_pending_addrmap == nullptr)
+    m_pending_addrmap = addrmap_create_mutable (&m_pending_addrmap_obstack);
 
-  addrmap_set_empty (pending_addrmap, start, end_inclusive, block);
+  addrmap_set_empty (m_pending_addrmap, start, end_inclusive, block);
 }
 
-static struct blockvector *
-make_blockvector (void)
+struct blockvector *
+buildsym_compunit::make_blockvector ()
 {
-  struct objfile *objfile = buildsym_compunit->objfile;
   struct pending_block *next;
   struct blockvector *blockvector;
   int i;
 
   /* Count the length of the list of blocks.  */
 
-  for (next = pending_blocks, i = 0; next; next = next->next, i++)
-    {;
+  for (next = m_pending_blocks, i = 0; next; next = next->next, i++)
+    {
     }
 
   blockvector = (struct blockvector *)
-    obstack_alloc (&objfile->objfile_obstack,
+    obstack_alloc (&m_objfile->objfile_obstack,
 		   (sizeof (struct blockvector)
 		    + (i - 1) * sizeof (struct block *)));
 
@@ -622,7 +457,7 @@ make_blockvector (void)
      sure this is true.  */
 
   BLOCKVECTOR_NBLOCKS (blockvector) = i;
-  for (next = pending_blocks; next; next = next->next)
+  for (next = m_pending_blocks; next; next = next->next)
     {
       BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
     }
@@ -631,9 +466,9 @@ make_blockvector (void)
 
   /* If we needed an address map for this symtab, record it in the
      blockvector.  */
-  if (pending_addrmap && pending_addrmap_interesting)
+  if (m_pending_addrmap != nullptr && m_pending_addrmap_interesting)
     BLOCKVECTOR_MAP (blockvector)
-      = addrmap_create_fixed (pending_addrmap, &objfile->objfile_obstack);
+      = addrmap_create_fixed (m_pending_addrmap, &m_objfile->objfile_obstack);
   else
     BLOCKVECTOR_MAP (blockvector) = 0;
 
@@ -653,7 +488,7 @@ make_blockvector (void)
 	      CORE_ADDR start
 		= BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i));
 
-	      complaint (&symfile_complaints, _("block at %s out of order"),
+	      complaint (_("block at %s out of order"),
 			 hex_string ((LONGEST) start));
 	    }
 	}
@@ -667,18 +502,16 @@ make_blockvector (void)
    name.  NAME is the name of the file (cannot be NULL).  */
 
 void
-start_subfile (const char *name)
+buildsym_compunit::start_subfile (const char *name)
 {
   const char *subfile_dirname;
   struct subfile *subfile;
 
-  gdb_assert (buildsym_compunit != NULL);
-
-  subfile_dirname = buildsym_compunit->comp_dir;
+  subfile_dirname = m_comp_dir.get ();
 
   /* See if this subfile is already registered.  */
 
-  for (subfile = buildsym_compunit->subfiles; subfile; subfile = subfile->next)
+  for (subfile = m_subfiles; subfile; subfile = subfile->next)
     {
       char *subfile_name;
 
@@ -694,7 +527,7 @@ start_subfile (const char *name)
 
       if (FILENAME_CMP (subfile_name, name) == 0)
 	{
-	  current_subfile = subfile;
+	  m_current_subfile = subfile;
 	  if (subfile_name != subfile->name)
 	    xfree (subfile_name);
 	  return;
@@ -707,12 +540,12 @@ start_subfile (const char *name)
 
   subfile = XNEW (struct subfile);
   memset (subfile, 0, sizeof (struct subfile));
-  subfile->buildsym_compunit = buildsym_compunit;
+  subfile->buildsym_compunit = this;
 
-  subfile->next = buildsym_compunit->subfiles;
-  buildsym_compunit->subfiles = subfile;
+  subfile->next = m_subfiles;
+  m_subfiles = subfile;
 
-  current_subfile = subfile;
+  m_current_subfile = subfile;
 
   subfile->name = xstrdup (name);
 
@@ -748,7 +581,7 @@ start_subfile (const char *name)
       enum language sublang = deduce_language_from_filename (subfile->name);
 
       if (sublang == language_cplus || sublang == language_fortran)
-	for (s = buildsym_compunit->subfiles; s != NULL; s = s->next)
+	for (s = m_subfiles; s != NULL; s = s->next)
 	  if (s->language == language_c)
 	    s->language = sublang;
     }
@@ -763,56 +596,6 @@ start_subfile (const char *name)
     }
 }
 
-/* Start recording information about a primary source file (IOW, not an
-   included source file).
-   COMP_DIR is the directory in which the compilation unit was compiled
-   (or NULL if not known).  */
-
-static struct buildsym_compunit *
-start_buildsym_compunit (struct objfile *objfile, const char *comp_dir)
-{
-  struct buildsym_compunit *bscu;
-
-  bscu = XNEW (struct buildsym_compunit);
-  memset (bscu, 0, sizeof (struct buildsym_compunit));
-
-  bscu->objfile = objfile;
-  bscu->comp_dir = (comp_dir == NULL) ? NULL : xstrdup (comp_dir);
-
-  /* Initialize the debug format string to NULL.  We may supply it
-     later via a call to record_debugformat.  */
-  bscu->debugformat = NULL;
-
-  /* Similarly for the producer.  */
-  bscu->producer = NULL;
-
-  return bscu;
-}
-
-/* Delete the buildsym compunit.  */
-
-static void
-free_buildsym_compunit (void)
-{
-  struct subfile *subfile, *nextsub;
-
-  if (buildsym_compunit == NULL)
-    return;
-  for (subfile = buildsym_compunit->subfiles;
-       subfile != NULL;
-       subfile = nextsub)
-    {
-      nextsub = subfile->next;
-      xfree (subfile->name);
-      xfree (subfile->line_vector);
-      xfree (subfile);
-    }
-  xfree (buildsym_compunit->comp_dir);
-  xfree (buildsym_compunit);
-  buildsym_compunit = NULL;
-  current_subfile = NULL;
-}
-
 /* For stabs readers, the first N_SO symbol is assumed to be the
    source file name, and the subfile struct is initialized using that
    assumption.  If another N_SO symbol is later seen, immediately
@@ -826,14 +609,15 @@ free_buildsym_compunit (void)
    directory name actually is (by checking for a trailing '/').  */
 
 void
-patch_subfile_names (struct subfile *subfile, const char *name)
+buildsym_compunit::patch_subfile_names (struct subfile *subfile,
+					const char *name)
 {
   if (subfile != NULL
-      && buildsym_compunit->comp_dir == NULL
+      && m_comp_dir == NULL
       && subfile->name != NULL
       && IS_DIR_SEPARATOR (subfile->name[strlen (subfile->name) - 1]))
     {
-      buildsym_compunit->comp_dir = subfile->name;
+      m_comp_dir.reset (subfile->name);
       subfile->name = xstrdup (name);
       set_last_source_file (name);
 
@@ -863,42 +647,28 @@ patch_subfile_names (struct subfile *subfile, const char *name)
    order.  */
 
 void
-push_subfile (void)
+buildsym_compunit::push_subfile ()
 {
-  struct subfile_stack *tem = XNEW (struct subfile_stack);
-
-  tem->next = subfile_stack;
-  subfile_stack = tem;
-  if (current_subfile == NULL || current_subfile->name == NULL)
-    {
-      internal_error (__FILE__, __LINE__, 
-		      _("failed internal consistency check"));
-    }
-  tem->name = current_subfile->name;
+  gdb_assert (m_current_subfile != NULL);
+  gdb_assert (m_current_subfile->name != NULL);
+  m_subfile_stack.push_back (m_current_subfile->name);
 }
 
-char *
-pop_subfile (void)
+const char *
+buildsym_compunit::pop_subfile ()
 {
-  char *name;
-  struct subfile_stack *link = subfile_stack;
-
-  if (link == NULL)
-    {
-      internal_error (__FILE__, __LINE__,
-		      _("failed internal consistency check"));
-    }
-  name = link->name;
-  subfile_stack = link->next;
-  xfree ((void *) link);
-  return (name);
+  gdb_assert (!m_subfile_stack.empty ());
+  const char *name = m_subfile_stack.back ();
+  m_subfile_stack.pop_back ();
+  return name;
 }
 
 /* Add a linetable entry for line number LINE and address PC to the
    line vector for SUBFILE.  */
 
 void
-record_line (struct subfile *subfile, int line, CORE_ADDR pc)
+buildsym_compunit::record_line (struct subfile *subfile, int line,
+				CORE_ADDR pc)
 {
   struct linetable_entry *e;
 
@@ -916,7 +686,7 @@ record_line (struct subfile *subfile, int line, CORE_ADDR pc)
 	xmalloc (sizeof (struct linetable)
 	   + subfile->line_vector_length * sizeof (struct linetable_entry));
       subfile->line_vector->nitems = 0;
-      have_line_numbers = 1;
+      m_have_line_numbers = true;
     }
 
   if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
@@ -978,121 +748,6 @@ compare_line_numbers (const void *ln1p, const void *ln2p)
   return ln1->line - ln2->line;
 }
 
-/* See buildsym.h.  */
-
-struct compunit_symtab *
-buildsym_compunit_symtab (void)
-{
-  gdb_assert (buildsym_compunit != NULL);
-
-  return buildsym_compunit->compunit_symtab;
-}
-
-/* See buildsym.h.  */
-
-struct macro_table *
-get_macro_table (void)
-{
-  struct objfile *objfile;
-
-  gdb_assert (buildsym_compunit != NULL);
-
-  objfile = buildsym_compunit->objfile;
-
-  if (! pending_macros)
-    {
-      pending_macros = new_macro_table (&objfile->per_bfd->storage_obstack,
-					objfile->per_bfd->macro_cache,
-					buildsym_compunit->compunit_symtab);
-    }
-
-  return pending_macros;
-}
-
-/* Init state to prepare for building a symtab.
-   Note: This can't be done in buildsym_init because dbxread.c and xcoffread.c
-   can call start_symtab+end_symtab multiple times after one call to
-   buildsym_init.  */
-
-static void
-prepare_for_building (const char *name, CORE_ADDR start_addr)
-{
-  set_last_source_file (name);
-  last_source_start_addr = start_addr;
-
-  local_symbols = NULL;
-  local_using_directives = NULL;
-  within_function = 0;
-  have_line_numbers = 0;
-
-  context_stack_depth = 0;
-
-  /* These should have been reset either by successful completion of building
-     a symtab, or by the really_free_pendings cleanup.  */
-  gdb_assert (file_symbols == NULL);
-  gdb_assert (global_symbols == NULL);
-  gdb_assert (global_using_directives == NULL);
-  gdb_assert (pending_macros == NULL);
-  gdb_assert (pending_addrmap == NULL);
-  gdb_assert (current_subfile == NULL);
-}
-
-/* Start a new symtab for a new source file in OBJFILE.  Called, for example,
-   when a stabs symbol of type N_SO is seen, or when a DWARF
-   TAG_compile_unit DIE is seen.  It indicates the start of data for
-   one original source file.
-
-   NAME is the name of the file (cannot be NULL).  COMP_DIR is the directory in
-   which the file was compiled (or NULL if not known).  START_ADDR is the
-   lowest address of objects in the file (or 0 if not known).  */
-
-struct compunit_symtab *
-start_symtab (struct objfile *objfile, const char *name, const char *comp_dir,
-	      CORE_ADDR start_addr)
-{
-  prepare_for_building (name, start_addr);
-
-  buildsym_compunit = start_buildsym_compunit (objfile, comp_dir);
-
-  /* Allocate the compunit symtab now.  The caller needs it to allocate
-     non-primary symtabs.  It is also needed by get_macro_table.  */
-  buildsym_compunit->compunit_symtab = allocate_compunit_symtab (objfile,
-								 name);
-
-  /* Build the subfile for NAME (the main source file) so that we can record
-     a pointer to it for later.
-     IMPORTANT: Do not allocate a struct symtab for NAME here.
-     It can happen that the debug info provides a different path to NAME than
-     DIRNAME,NAME.  We cope with this in watch_main_source_file_lossage but
-     that only works if the main_subfile doesn't have a symtab yet.  */
-  start_subfile (name);
-  /* Save this so that we don't have to go looking for it at the end
-     of the subfiles list.  */
-  buildsym_compunit->main_subfile = current_subfile;
-
-  return buildsym_compunit->compunit_symtab;
-}
-
-/* Restart compilation for a symtab.
-   CUST is the result of end_expandable_symtab.
-   NAME, START_ADDR are the source file we are resuming with.
-
-   This is used when a symtab is built from multiple sources.
-   The symtab is first built with start_symtab/end_expandable_symtab
-   and then for each additional piece call restart_symtab/augment_*_symtab.
-   Note: At the moment there is only augment_type_symtab.  */
-
-void
-restart_symtab (struct compunit_symtab *cust,
-		const char *name, CORE_ADDR start_addr)
-{
-  prepare_for_building (name, start_addr);
-
-  buildsym_compunit = start_buildsym_compunit (COMPUNIT_OBJFILE (cust),
-					       COMPUNIT_DIRNAME (cust));
-  buildsym_compunit->compunit_symtab = cust;
-}
-
 /* Subroutine of end_symtab to simplify it.  Look for a subfile that
    matches the main source file's basename.  If there is only one, and
    if the main source file doesn't have any symbol or line number
@@ -1103,18 +758,13 @@ restart_symtab (struct compunit_symtab *cust,
    manipulates the debug info.  This can also happen from an innocent
    symlink in the paths, we don't canonicalize paths here.  */
 
-static void
-watch_main_source_file_lossage (void)
+void
+buildsym_compunit::watch_main_source_file_lossage ()
 {
   struct subfile *mainsub, *subfile;
 
-  /* We have to watch for buildsym_compunit == NULL here.  It's a quirk of
-     end_symtab, it can return NULL so there may not be a main subfile.  */
-  if (buildsym_compunit == NULL)
-    return;
-
   /* Get the main source file.  */
-  mainsub = buildsym_compunit->main_subfile;
+  mainsub = m_main_subfile;
 
   /* If the main source file doesn't have any line number or symbol
      info, look for an alias in another subfile.  */
@@ -1129,7 +779,7 @@ watch_main_source_file_lossage (void)
       struct subfile *prev_mainsub_alias = NULL;
 
       prevsub = NULL;
-      for (subfile = buildsym_compunit->subfiles;
+      for (subfile = m_subfiles;
 	   subfile != NULL;
 	   subfile = subfile->next)
 	{
@@ -1157,7 +807,7 @@ watch_main_source_file_lossage (void)
 	  mainsub->symtab = mainsub_alias->symtab;
 
 	  if (prev_mainsub_alias == NULL)
-	    buildsym_compunit->subfiles = mainsub_alias->next;
+	    m_subfiles = mainsub_alias->next;
 	  else
 	    prev_mainsub_alias->next = mainsub_alias->next;
 	  xfree (mainsub_alias->name);
@@ -1166,34 +816,6 @@ watch_main_source_file_lossage (void)
     }
 }
 
-/* Reset state after a successful building of a symtab.
-   This exists because dbxread.c and xcoffread.c can call
-   start_symtab+end_symtab multiple times after one call to buildsym_init,
-   and before the really_free_pendings cleanup is called.
-   We keep the free_pendings list around for dbx/xcoff sake.  */
-
-static void
-reset_symtab_globals (void)
-{
-  set_last_source_file (NULL);
-
-  local_symbols = NULL;
-  local_using_directives = NULL;
-  file_symbols = NULL;
-  global_symbols = NULL;
-  global_using_directives = NULL;
-
-  /* We don't free pending_macros here because if the symtab was successfully
-     built then ownership was transferred to the symtab.  */
-  pending_macros = NULL;
-
-  if (pending_addrmap)
-    obstack_free (&pending_addrmap_obstack, NULL);
-  pending_addrmap = NULL;
-
-  free_buildsym_compunit ();
-}
-
 /* Implementation of the first part of end_symtab.  It allows modifying
    STATIC_BLOCK before it gets finalized by end_symtab_from_static_block.
    If the returned value is NULL there is no blockvector created for
@@ -1209,44 +831,42 @@ reset_symtab_globals (void)
    not contain any symbols.  */
 
 struct block *
-end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
+buildsym_compunit::end_symtab_get_static_block (CORE_ADDR end_addr,
+						int expandable, int required)
 {
-  struct objfile *objfile = buildsym_compunit->objfile;
-
   /* Finish the lexical context of the last function in the file; pop
      the context stack.  */
 
-  if (context_stack_depth > 0)
+  if (!m_context_stack.empty ())
     {
-      struct context_stack *cstk = pop_context ();
+      struct context_stack cstk = pop_context ();
 
       /* Make a block for the local symbols within.  */
-      finish_block (cstk->name, &local_symbols, cstk->old_blocks, NULL,
-		    cstk->start_addr, end_addr);
+      finish_block (cstk.name, cstk.old_blocks, NULL,
+		    cstk.start_addr, end_addr);
 
-      if (context_stack_depth > 0)
+      if (!m_context_stack.empty ())
 	{
 	  /* This is said to happen with SCO.  The old coffread.c
 	     code simply emptied the context stack, so we do the
 	     same.  FIXME: Find out why it is happening.  This is not
 	     believed to happen in most cases (even for coffread.c);
 	     it used to be an abort().  */
-	  complaint (&symfile_complaints,
-	             _("Context stack not empty in end_symtab"));
-	  context_stack_depth = 0;
+	  complaint (_("Context stack not empty in end_symtab"));
+	  m_context_stack.clear ();
 	}
     }
 
   /* Reordered executables may have out of order pending blocks; if
      OBJF_REORDERED is true, then sort the pending blocks.  */
 
-  if ((objfile->flags & OBJF_REORDERED) && pending_blocks)
+  if ((m_objfile->flags & OBJF_REORDERED) && m_pending_blocks)
     {
       struct pending_block *pb;
 
       std::vector<block *> barray;
 
-      for (pb = pending_blocks; pb != NULL; pb = pb->next)
+      for (pb = m_pending_blocks; pb != NULL; pb = pb->next)
 	barray.push_back (pb->block);
 
       /* Sort blocks by start address in descending order.  Blocks with the
@@ -1259,7 +879,7 @@ end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
 			});
 
       int i = 0;
-      for (pb = pending_blocks; pb != NULL; pb = pb->next)
+      for (pb = m_pending_blocks; pb != NULL; pb = pb->next)
 	pb->block = barray[i++];
     }
 
@@ -1273,16 +893,16 @@ end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
      are no-ops.  FIXME: Is this handled right in case of QUIT?  Can
      we make this cleaner?  */
 
-  cleanup_undefined_stabs_types (objfile);
-  finish_global_stabs (objfile);
+  cleanup_undefined_stabs_types (m_objfile);
+  finish_global_stabs (m_objfile);
 
   if (!required
-      && pending_blocks == NULL
-      && file_symbols == NULL
-      && global_symbols == NULL
-      && have_line_numbers == 0
-      && pending_macros == NULL
-      && global_using_directives == NULL)
+      && m_pending_blocks == NULL
+      && m_file_symbols == NULL
+      && m_global_symbols == NULL
+      && !m_have_line_numbers
+      && m_pending_macros == NULL
+      && m_global_using_directives == NULL)
     {
       /* Ignore symtabs that have no functions with real debugging info.  */
       return NULL;
@@ -1290,9 +910,9 @@ end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
   else
     {
       /* Define the STATIC_BLOCK.  */
-      return finish_block_internal (NULL, &file_symbols, NULL, NULL,
-				    last_source_start_addr, end_addr,
-				    0, expandable);
+      return finish_block_internal (NULL, get_file_symbols (), NULL, NULL,
+				    m_last_source_start_addr,
+				    end_addr, 0, expandable);
     }
 }
 
@@ -1300,33 +920,30 @@ end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
    Handle the "have blockvector" case.
    See end_symtab_from_static_block for a description of the arguments.  */
 
-static struct compunit_symtab *
-end_symtab_with_blockvector (struct block *static_block,
-			     int section, int expandable)
+struct compunit_symtab *
+buildsym_compunit::end_symtab_with_blockvector (struct block *static_block,
+						int section, int expandable)
 {
-  struct objfile *objfile = buildsym_compunit->objfile;
-  struct compunit_symtab *cu = buildsym_compunit->compunit_symtab;
-  struct symtab *symtab;
+  struct compunit_symtab *cu = m_compunit_symtab;
   struct blockvector *blockvector;
   struct subfile *subfile;
   CORE_ADDR end_addr;
 
   gdb_assert (static_block != NULL);
-  gdb_assert (buildsym_compunit != NULL);
-  gdb_assert (buildsym_compunit->subfiles != NULL);
+  gdb_assert (m_subfiles != NULL);
 
   end_addr = BLOCK_END (static_block);
 
   /* Create the GLOBAL_BLOCK and build the blockvector.  */
-  finish_block_internal (NULL, &global_symbols, NULL, NULL,
-			 last_source_start_addr, end_addr,
+  finish_block_internal (NULL, get_global_symbols (), NULL, NULL,
+			 m_last_source_start_addr, end_addr,
 			 1, expandable);
   blockvector = make_blockvector ();
 
   /* Read the line table if it has to be read separately.
      This is only used by xcoffread.c.  */
-  if (objfile->sf->sym_read_linetable != NULL)
-    objfile->sf->sym_read_linetable (objfile);
+  if (m_objfile->sf->sym_read_linetable != NULL)
+    m_objfile->sf->sym_read_linetable (m_objfile);
 
   /* Handle the case where the debug info specifies a different path
      for the main source file.  It can cause us to lose track of its
@@ -1336,7 +953,7 @@ end_symtab_with_blockvector (struct block *static_block,
   /* Now create the symtab objects proper, if not already done,
      one for each subfile.  */
 
-  for (subfile = buildsym_compunit->subfiles;
+  for (subfile = m_subfiles;
        subfile != NULL;
        subfile = subfile->next)
     {
@@ -1350,7 +967,7 @@ end_symtab_with_blockvector (struct block *static_block,
 	  /* Like the pending blocks, the line table may be
 	     scrambled in reordered executables.  Sort it if
 	     OBJF_REORDERED is true.  */
-	  if (objfile->flags & OBJF_REORDERED)
+	  if (m_objfile->flags & OBJF_REORDERED)
 	    qsort (subfile->line_vector->item,
 		   subfile->line_vector->nitems,
 		   sizeof (struct linetable_entry), compare_line_numbers);
@@ -1359,7 +976,7 @@ end_symtab_with_blockvector (struct block *static_block,
       /* Allocate a symbol table if necessary.  */
       if (subfile->symtab == NULL)
 	subfile->symtab = allocate_symtab (cu, subfile->name);
-      symtab = subfile->symtab;
+      struct symtab *symtab = subfile->symtab;
 
       /* Fill in its components.  */
 
@@ -1367,7 +984,7 @@ end_symtab_with_blockvector (struct block *static_block,
 	{
 	  /* Reallocate the line table on the symbol obstack.  */
 	  SYMTAB_LINETABLE (symtab) = (struct linetable *)
-	    obstack_alloc (&objfile->objfile_obstack, linetablesize);
+	    obstack_alloc (&m_objfile->objfile_obstack, linetablesize);
 	  memcpy (SYMTAB_LINETABLE (symtab), subfile->line_vector,
 		  linetablesize);
 	}
@@ -1389,9 +1006,9 @@ end_symtab_with_blockvector (struct block *static_block,
   {
     struct symtab *main_symtab, *prev_symtab;
 
-    main_symtab = buildsym_compunit->main_subfile->symtab;
+    main_symtab = m_main_subfile->symtab;
     prev_symtab = NULL;
-    ALL_COMPUNIT_FILETABS (cu, symtab)
+    for (symtab *symtab : compunit_filetabs (cu))
       {
 	if (symtab == main_symtab)
 	  {
@@ -1410,20 +1027,19 @@ end_symtab_with_blockvector (struct block *static_block,
 
   /* Fill out the compunit symtab.  */
 
-  if (buildsym_compunit->comp_dir != NULL)
+  if (m_comp_dir != NULL)
     {
       /* Reallocate the dirname on the symbol obstack.  */
-      COMPUNIT_DIRNAME (cu)
-	= (const char *) obstack_copy0 (&objfile->objfile_obstack,
-					buildsym_compunit->comp_dir,
-					strlen (buildsym_compunit->comp_dir));
+      const char *comp_dir = m_comp_dir.get ();
+      COMPUNIT_DIRNAME (cu) = obstack_strdup (&m_objfile->objfile_obstack,
+					      comp_dir);
     }
 
   /* Save the debug format string (if any) in the symtab.  */
-  COMPUNIT_DEBUGFORMAT (cu) = buildsym_compunit->debugformat;
+  COMPUNIT_DEBUGFORMAT (cu) = m_debugformat;
 
   /* Similarly for the producer.  */
-  COMPUNIT_PRODUCER (cu) = buildsym_compunit->producer;
+  COMPUNIT_PRODUCER (cu) = m_producer;
 
   COMPUNIT_BLOCKVECTOR (cu) = blockvector;
   {
@@ -1434,20 +1050,20 @@ end_symtab_with_blockvector (struct block *static_block,
 
   COMPUNIT_BLOCK_LINE_SECTION (cu) = section;
 
-  COMPUNIT_MACRO_TABLE (cu) = pending_macros;
+  COMPUNIT_MACRO_TABLE (cu) = release_macros ();
 
   /* Default any symbols without a specified symtab to the primary symtab.  */
   {
     int block_i;
 
     /* The main source file's symtab.  */
-    symtab = COMPUNIT_FILETABS (cu);
+    struct symtab *symtab = COMPUNIT_FILETABS (cu);
 
     for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++)
       {
 	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.  */
@@ -1458,7 +1074,7 @@ 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);
       }
@@ -1479,8 +1095,8 @@ end_symtab_with_blockvector (struct block *static_block,
    expandable.  */
 
 struct compunit_symtab *
-end_symtab_from_static_block (struct block *static_block,
-			      int section, int expandable)
+buildsym_compunit::end_symtab_from_static_block (struct block *static_block,
+						 int section, int expandable)
 {
   struct compunit_symtab *cu;
 
@@ -1500,8 +1116,6 @@ end_symtab_from_static_block (struct block *static_block,
   else
     cu = end_symtab_with_blockvector (static_block, section, expandable);
 
-  reset_symtab_globals ();
-
   return cu;
 }
 
@@ -1527,7 +1141,7 @@ end_symtab_from_static_block (struct block *static_block,
    yourself.  */
 
 struct compunit_symtab *
-end_symtab (CORE_ADDR end_addr, int section)
+buildsym_compunit::end_symtab (CORE_ADDR end_addr, int section)
 {
   struct block *static_block;
 
@@ -1538,7 +1152,7 @@ end_symtab (CORE_ADDR end_addr, int section)
 /* Same as end_symtab except create a symtab that can be later added to.  */
 
 struct compunit_symtab *
-end_expandable_symtab (CORE_ADDR end_addr, int section)
+buildsym_compunit::end_expandable_symtab (CORE_ADDR end_addr, int section)
 {
   struct block *static_block;
 
@@ -1572,48 +1186,42 @@ set_missing_symtab (struct pending *pending_list,
    This is the case for DWARF4 Type Units.  */
 
 void
-augment_type_symtab (void)
+buildsym_compunit::augment_type_symtab ()
 {
-  struct compunit_symtab *cust = buildsym_compunit->compunit_symtab;
+  struct compunit_symtab *cust = m_compunit_symtab;
   const struct blockvector *blockvector = COMPUNIT_BLOCKVECTOR (cust);
 
-  if (context_stack_depth > 0)
-    {
-      complaint (&symfile_complaints,
-		 _("Context stack not empty in augment_type_symtab"));
-      context_stack_depth = 0;
-    }
-  if (pending_blocks != NULL)
-    complaint (&symfile_complaints, _("Blocks in a type symtab"));
-  if (pending_macros != NULL)
-    complaint (&symfile_complaints, _("Macro in a type symtab"));
-  if (have_line_numbers)
-    complaint (&symfile_complaints,
-	       _("Line numbers recorded in a type symtab"));
-
-  if (file_symbols != NULL)
+  if (!m_context_stack.empty ())
+    complaint (_("Context stack not empty in augment_type_symtab"));
+  if (m_pending_blocks != NULL)
+    complaint (_("Blocks in a type symtab"));
+  if (m_pending_macros != NULL)
+    complaint (_("Macro in a type symtab"));
+  if (m_have_line_numbers)
+    complaint (_("Line numbers recorded in a type symtab"));
+
+  if (m_file_symbols != NULL)
     {
       struct block *block = BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK);
 
       /* First mark any symbols without a specified symtab as belonging
 	 to the primary symtab.  */
-      set_missing_symtab (file_symbols, cust);
+      set_missing_symtab (m_file_symbols, cust);
 
-      dict_add_pending (BLOCK_DICT (block), file_symbols);
+      mdict_add_pending (BLOCK_MULTIDICT (block), m_file_symbols);
     }
 
-  if (global_symbols != NULL)
+  if (m_global_symbols != NULL)
     {
       struct block *block = BLOCKVECTOR_BLOCK (blockvector, GLOBAL_BLOCK);
 
       /* First mark any symbols without a specified symtab as belonging
 	 to the primary symtab.  */
-      set_missing_symtab (global_symbols, cust);
+      set_missing_symtab (m_global_symbols, cust);
 
-      dict_add_pending (BLOCK_DICT (block), global_symbols);
+      mdict_add_pending (BLOCK_MULTIDICT (block),
+			m_global_symbols);
     }
-
-  reset_symtab_globals ();
 }
 
 /* Push a context block.  Args are an identifying nesting level
@@ -1621,28 +1229,20 @@ augment_type_symtab (void)
    context.  */
 
 struct context_stack *
-push_context (int desc, CORE_ADDR valu)
+buildsym_compunit::push_context (int desc, CORE_ADDR valu)
 {
-  struct context_stack *newobj;
-
-  if (context_stack_depth == context_stack_size)
-    {
-      context_stack_size *= 2;
-      context_stack = (struct context_stack *)
-	xrealloc ((char *) context_stack,
-		  (context_stack_size * sizeof (struct context_stack)));
-    }
+  m_context_stack.emplace_back ();
+  struct context_stack *newobj = &m_context_stack.back ();
 
-  newobj = &context_stack[context_stack_depth++];
   newobj->depth = desc;
-  newobj->locals = local_symbols;
-  newobj->old_blocks = pending_blocks;
+  newobj->locals = m_local_symbols;
+  newobj->old_blocks = m_pending_blocks;
   newobj->start_addr = valu;
-  newobj->local_using_directives = local_using_directives;
+  newobj->local_using_directives = m_local_using_directives;
   newobj->name = NULL;
 
-  local_symbols = NULL;
-  local_using_directives = NULL;
+  m_local_symbols = NULL;
+  m_local_using_directives = NULL;
 
   return newobj;
 }
@@ -1650,127 +1250,11 @@ push_context (int desc, CORE_ADDR valu)
 /* Pop a context block.  Returns the address of the context block just
    popped.  */
 
-struct context_stack *
-pop_context (void)
-{
-  gdb_assert (context_stack_depth > 0);
-  return (&context_stack[--context_stack_depth]);
-}
-
-
-
-/* Compute a small integer hash code for the given name.  */
-
-int
-hashname (const char *name)
-{
-    return (hash(name,strlen(name)) % HASHSIZE);
-}
-
-
-void
-record_debugformat (const char *format)
-{
-  buildsym_compunit->debugformat = format;
-}
-
-void
-record_producer (const char *producer)
-{
-  buildsym_compunit->producer = producer;
-}
-
-/* Merge the first symbol list SRCLIST into the second symbol list
-   TARGETLIST by repeated calls to add_symbol_to_list().  This
-   procedure "frees" each link of SRCLIST by adding it to the
-   free_pendings list.  Caller must set SRCLIST to a null list after
-   calling this function.
-
-   Void return.  */
-
-void
-merge_symbol_lists (struct pending **srclist, struct pending **targetlist)
-{
-  int i;
-
-  if (!srclist || !*srclist)
-    return;
-
-  /* Merge in elements from current link.  */
-  for (i = 0; i < (*srclist)->nsyms; i++)
-    add_symbol_to_list ((*srclist)->symbol[i], targetlist);
-
-  /* Recurse on next.  */
-  merge_symbol_lists (&(*srclist)->next, targetlist);
-
-  /* "Free" the current link.  */
-  (*srclist)->next = free_pendings;
-  free_pendings = (*srclist);
-}
-
-
-/* Name of source file whose symbol data we are now processing.  This
-   comes from a symbol of type N_SO for stabs.  For Dwarf it comes
-   from the DW_AT_name attribute of a DW_TAG_compile_unit DIE.  */
-
-static char *last_source_file;
-
-/* See buildsym.h.  */
-
-void
-set_last_source_file (const char *name)
-{
-  xfree (last_source_file);
-  last_source_file = name == NULL ? NULL : xstrdup (name);
-}
-
-/* See buildsym.h.  */
-
-const char *
-get_last_source_file (void)
-{
-  return last_source_file;
-}
-
-
-
-/* Initialize anything that needs initializing when starting to read a
-   fresh piece of a symbol file, e.g. reading in the stuff
-   corresponding to a psymtab.  */
-
-void
-buildsym_init (void)
-{
-  subfile_stack = NULL;
-
-  pending_addrmap_interesting = 0;
-
-  /* Context stack is initially empty.  Allocate first one with room
-     for a few levels; reuse it forever afterward.  */
-  if (context_stack == NULL)
-    {
-      context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
-      context_stack = XNEWVEC (struct context_stack, context_stack_size);
-    }
-
-  /* Ensure the really_free_pendings cleanup was called after
-     the last time.  */
-  gdb_assert (free_pendings == NULL);
-  gdb_assert (pending_blocks == NULL);
-  gdb_assert (file_symbols == NULL);
-  gdb_assert (global_symbols == NULL);
-  gdb_assert (global_using_directives == NULL);
-  gdb_assert (pending_macros == NULL);
-  gdb_assert (pending_addrmap == NULL);
-  gdb_assert (buildsym_compunit == NULL);
-}
-
-/* Initialize anything that needs initializing when a completely new
-   symbol file is specified (not just adding some symbols from another
-   file, e.g. a shared library).  */
-
-void
-buildsym_new_init (void)
+struct context_stack
+buildsym_compunit::pop_context ()
 {
-  buildsym_init ();
+  gdb_assert (!m_context_stack.empty ());
+  struct context_stack result = m_context_stack.back ();
+  m_context_stack.pop_back ();
+  return result;
 }