Break out symbol-table-building routines

from dbxread.c, so they can be shared with xcoffread.c.

4 files changed, 3099 insertions, 2595 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 139a924..2a50492 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+Sat Oct 26 00:16:32 1991  John Gilmore  (gnu at cygus.com)
+
+	* buildsym.c:  New file.  Breaks out symbol-table-building routines
+	from dbxread.c, so they can be shared with xcoffread.c.
+	* buildsym.h:  New file.  Declarations for buildsym.c users.
+	* dbxread.c:  Remove large chunks into buildsym.c.
+
 Fri Oct 25 18:59:32 1991  Per Bothner  (bothner at cygnus.com)
 
 	Various fixes to improve g++ debugging.
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
new file mode 100644
index 0000000..2920b86
--- /dev/null
+++ b/gdb/buildsym.c
@@ -0,0 +1,2791 @@
+/* Build symbol tables in GDB's internal format.
+   Copyright (C) 1986-1991 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This module provides subroutines used for creating and adding to
+   the symbol table.  These routines are called from various symbol-
+   file-reading routines.  
+
+   They originated in dbxread.c of gdb-4.2, and were split out to
+   make xcoffread.c more maintainable by sharing code.  */
+
+#include "defs.h"
+#include "param.h"
+#include "obstack.h"
+#include "symtab.h"
+#include "breakpoint.h"
+#include "gdbcore.h"		/* for bfd stuff for symfile.h */
+#include "symfile.h"		/* Needed for "struct complaint" */
+#include "stab.gnu.h"		/* We always use GNU stabs, not native */
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+/* Ask buildsym.h to define the vars it normally declares `extern'.  */
+#define	EXTERN	/**/
+#include "buildsym.h"		/* Our own declarations */
+#undef	EXTERN
+
+extern void qsort ();
+extern double atof ();
+
+/* Things we export from outside, and probably shouldn't.  FIXME.  */
+extern void new_object_header_files ();
+extern void start_subfile ();
+extern char *next_symbol_text ();
+extern int hashname ();
+
+static struct symbol *define_symbol ();
+static void cleanup_undefined_types ();
+static void fix_common_block ();
+
+static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
+static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
+
+/* Define this as 1 if a pcc declaration of a char or short argument
+   gives the correct address.  Otherwise assume pcc gives the
+   address of the corresponding int, which is not the same on a
+   big-endian machine.  */
+
+#ifndef BELIEVE_PCC_PROMOTION
+#define BELIEVE_PCC_PROMOTION 0
+#endif
+
+/* Make a list of forward references which haven't been defined.  */
+static struct type **undef_types;
+static int undef_types_allocated, undef_types_length;
+
+
+/* Complaints about the symbols we have encountered.  */
+
+struct complaint innerblock_complaint =
+  {"inner block not inside outer block in %s", 0, 0};
+
+struct complaint blockvector_complaint = 
+  {"block at %x out of order", 0, 0};
+
+#if 0
+struct complaint dbx_class_complaint =
+  {"encountered DBX-style class variable debugging information.\n\
+You seem to have compiled your program with \
+\"g++ -g0\" instead of \"g++ -g\".\n\
+Therefore GDB will not know about your class variables", 0, 0};
+#endif
+
+struct complaint const_vol_complaint =
+  {"const/volatile indicator missing (ok if using g++ v1.x), got '%c'", 0, 0};
+
+struct complaint error_type_complaint =
+  {"debug info mismatch between compiler and debugger", 0, 0};
+
+struct complaint invalid_member_complaint =
+  {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
+
+struct complaint range_type_base_complaint =
+  {"base type %d of range type is not defined", 0, 0};
+
+/* Look up a dbx type-number pair.  Return the address of the slot
+   where the type for that number-pair is stored.
+   The number-pair is in TYPENUMS.
+
+   This can be used for finding the type associated with that pair
+   or for associating a new type with the pair.  */
+
+struct type **
+dbx_lookup_type (typenums)
+     int typenums[2];
+{
+  register int filenum = typenums[0], index = typenums[1];
+
+  if (filenum < 0 || filenum >= n_this_object_header_files)
+    error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
+	   filenum, index, symnum);
+
+  if (filenum == 0)
+    {
+      /* Type is defined outside of header files.
+	 Find it in this object file's type vector.  */
+      while (index >= type_vector_length)
+	{
+	  type_vector_length *= 2;
+	  type_vector = (struct type **)
+	    xrealloc (type_vector,
+		      (type_vector_length * sizeof (struct type *)));
+	  bzero (&type_vector[type_vector_length / 2],
+		 type_vector_length * sizeof (struct type *) / 2);
+	}
+      return &type_vector[index];
+    }
+  else
+    {
+      register int real_filenum = this_object_header_files[filenum];
+      register struct header_file *f;
+      int f_orig_length;
+
+      if (real_filenum >= n_header_files)
+	abort ();
+
+      f = &header_files[real_filenum];
+
+      f_orig_length = f->length;
+      if (index >= f_orig_length)
+	{
+	  while (index >= f->length)
+	    f->length *= 2;
+	  f->vector = (struct type **)
+	    xrealloc (f->vector, f->length * sizeof (struct type *));
+	  bzero (&f->vector[f_orig_length],
+		 (f->length - f_orig_length) * sizeof (struct type *));
+	}
+      return &f->vector[index];
+    }
+}
+
+/* Create a type object.  Occaisionally used when you need a type
+   which isn't going to be given a type number.  */
+
+struct type *
+dbx_create_type ()
+{
+  register struct type *type =
+    (struct type *) obstack_alloc (symbol_obstack, sizeof (struct type));
+
+  bzero (type, sizeof (struct type));
+  TYPE_VPTR_FIELDNO (type) = -1;
+  TYPE_VPTR_BASETYPE (type) = 0;
+  return type;
+}
+
+/* Make sure there is a type allocated for type numbers TYPENUMS
+   and return the type object.
+   This can create an empty (zeroed) type object.
+   TYPENUMS may be (-1, -1) to return a new type object that is not
+   put into the type vector, and so may not be referred to by number. */
+
+struct type *
+dbx_alloc_type (typenums)
+     int typenums[2];
+{
+  register struct type **type_addr;
+  register struct type *type;
+
+  if (typenums[1] != -1)
+    {
+      type_addr = dbx_lookup_type (typenums);
+      type = *type_addr;
+    }
+  else
+    {
+      type_addr = 0;
+      type = 0;
+    }
+
+  /* If we are referring to a type not known at all yet,
+     allocate an empty type for it.
+     We will fill it in later if we find out how.  */
+  if (type == 0)
+    {
+      type = dbx_create_type ();
+      if (type_addr)
+	*type_addr = type;
+    }
+  
+  return type;
+}
+
+/* maintain the lists of symbols and blocks */
+
+/* Add a symbol to one of the lists of symbols.  */
+void
+add_symbol_to_list (symbol, listhead)
+     struct symbol *symbol;
+     struct pending **listhead;
+{
+  /* We keep PENDINGSIZE symbols in each link of the list.
+     If we don't have a link with room in it, add a new link.  */
+  if (*listhead == 0 || (*listhead)->nsyms == PENDINGSIZE)
+    {
+      register struct pending *link;
+      if (free_pendings)
+	{
+	  link = free_pendings;
+	  free_pendings = link->next;
+	}
+      else
+	link = (struct pending *) xmalloc (sizeof (struct pending));
+
+      link->next = *listhead;
+      *listhead = link;
+      link->nsyms = 0;
+    }
+
+  (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
+}
+
+/* At end of reading syms, or in case of quit,
+   really free as many `struct pending's as we can easily find.  */
+
+/* ARGSUSED */
+void
+really_free_pendings (foo)
+     int foo;
+{
+  struct pending *next, *next1;
+#if 0
+  struct pending_block *bnext, *bnext1;
+#endif
+
+  for (next = free_pendings; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  free_pendings = 0;
+
+#if 0 /* Now we make the links in the symbol_obstack, so don't free them.  */
+  for (bnext = pending_blocks; bnext; bnext = bnext1)
+    {
+      bnext1 = bnext->next;
+      free (bnext);
+    }
+#endif
+  pending_blocks = 0;
+
+  for (next = file_symbols; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  file_symbols = 0;
+
+  for (next = global_symbols; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+  global_symbols = 0;
+}
+
+/* Take one of the lists of symbols and make a block from it.
+   Keep the order the symbols have in the list (reversed from the input file).
+   Put the block on the list of pending blocks.  */
+
+void
+finish_block (symbol, listhead, old_blocks, start, end)
+     struct symbol *symbol;
+     struct pending **listhead;
+     struct pending_block *old_blocks;
+     CORE_ADDR start, end;
+{
+  register struct pending *next, *next1;
+  register struct block *block;
+  register struct pending_block *pblock;
+  struct pending_block *opblock;
+  register int i;
+
+  /* Count the length of the list of symbols.  */
+
+  for (next = *listhead, i = 0; next; i += next->nsyms, next = next->next)
+    /*EMPTY*/;
+
+  block = (struct block *) obstack_alloc (symbol_obstack,
+					  (sizeof (struct block)
+					   + ((i - 1)
+					      * sizeof (struct symbol *))));
+
+  /* Copy the symbols into the block.  */
+
+  BLOCK_NSYMS (block) = i;
+  for (next = *listhead; next; next = next->next)
+    {
+      register int j;
+      for (j = next->nsyms - 1; j >= 0; j--)
+	BLOCK_SYM (block, --i) = next->symbol[j];
+    }
+
+  BLOCK_START (block) = start;
+  BLOCK_END (block) = end;
+  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
+  BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
+
+  /* Put the block in as the value of the symbol that names it.  */
+
+  if (symbol)
+    {
+      SYMBOL_BLOCK_VALUE (symbol) = block;
+      BLOCK_FUNCTION (block) = symbol;
+    }
+  else
+    BLOCK_FUNCTION (block) = 0;
+
+  /* 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;
+    }
+  *listhead = 0;
+
+  /* Install this block as the superblock
+     of all blocks made since the start of this scope
+     that don't have superblocks yet.  */
+
+  opblock = 0;
+  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
+    {
+      if (BLOCK_SUPERBLOCK (pblock->block) == 0) {
+#if 1
+	/* Check to be sure the blocks are nested as we receive them. 
+	   If the compiler/assembler/linker work, this just burns a small
+	   amount of time.  */
+	if (BLOCK_START (pblock->block) < BLOCK_START (block)
+	 || BLOCK_END   (pblock->block) > BLOCK_END   (block)) {
+	  complain(&innerblock_complaint, symbol? SYMBOL_NAME (symbol):
+						 "(don't know)");
+	  BLOCK_START (pblock->block) = BLOCK_START (block);
+	  BLOCK_END   (pblock->block) = BLOCK_END   (block);
+	}
+#endif
+	BLOCK_SUPERBLOCK (pblock->block) = block;
+      }
+      opblock = pblock;
+    }
+
+  /* Record this block on the list of all blocks in the file.
+     Put it after opblock, or at the beginning if opblock is 0.
+     This puts the block in the list after all its subblocks.  */
+
+  /* Allocate in the symbol_obstack to save time.
+     It wastes a little space.  */
+  pblock = (struct pending_block *)
+    obstack_alloc (symbol_obstack,
+		   sizeof (struct pending_block));
+  pblock->block = block;
+  if (opblock)
+    {
+      pblock->next = opblock->next;
+      opblock->next = pblock;
+    }
+  else
+    {
+      pblock->next = pending_blocks;
+      pending_blocks = pblock;
+    }
+}
+
+struct blockvector *
+make_blockvector ()
+{
+  register struct pending_block *next;
+  register struct blockvector *blockvector;
+  register int i;
+
+  /* Count the length of the list of blocks.  */
+
+  for (next = pending_blocks, i = 0; next; next = next->next, i++);
+
+  blockvector = (struct blockvector *)
+    obstack_alloc (symbol_obstack,
+		   (sizeof (struct blockvector)
+		    + (i - 1) * sizeof (struct block *)));
+
+  /* Copy the blocks into the blockvector.
+     This is done in reverse order, which happens to put
+     the blocks into the proper order (ascending starting address).
+     finish_block has hair to insert each block into the list
+     after its subblocks in order to make sure this is true.  */
+
+  BLOCKVECTOR_NBLOCKS (blockvector) = i;
+  for (next = pending_blocks; next; next = next->next) {
+    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
+  }
+
+#if 0 /* Now we make the links in the obstack, so don't free them.  */
+  /* Now free the links of the list, and empty the list.  */
+
+  for (next = pending_blocks; next; next = next1)
+    {
+      next1 = next->next;
+      free (next);
+    }
+#endif
+  pending_blocks = 0;
+
+#if 1  /* FIXME, shut this off after a while to speed up symbol reading.  */
+  /* Some compilers output blocks in the wrong order, but we depend
+     on their being in the right order so we can binary search. 
+     Check the order and moan about it.  FIXME.  */
+  if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
+    for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) {
+      if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
+	  > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))) {
+	complain (&blockvector_complaint, 
+	  BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
+      }
+    }
+#endif
+
+  return blockvector;
+}
+
+/* Manage the vector of line numbers.  */
+
+void
+record_line (line, pc)
+     int line;
+     CORE_ADDR pc;
+{
+  struct linetable_entry *e;
+  /* Ignore the dummy line number in libg.o */
+
+  if (line == 0xffff)
+    return;
+
+  /* Make sure line vector is big enough.  */
+
+  if (line_vector_index + 1 >= line_vector_length)
+    {
+      line_vector_length *= 2;
+      line_vector = (struct linetable *)
+	xrealloc (line_vector,
+		  (sizeof (struct linetable)
+		   + line_vector_length * sizeof (struct linetable_entry)));
+      current_subfile->line_vector = line_vector;
+    }
+
+  e = line_vector->item + line_vector_index++;
+  e->line = line; e->pc = pc;
+}
+
+/* Start a new symtab for a new source file.
+   This is called when a dbx symbol of type N_SO is seen;
+   it indicates the start of data for one original source file.  */
+
+void
+start_symtab (name, dirname, start_addr)
+     char *name;
+     char *dirname;
+     CORE_ADDR start_addr;
+{
+
+  last_source_file = name;
+  last_source_start_addr = start_addr;
+  file_symbols = 0;
+  global_symbols = 0;
+  within_function = 0;
+
+  /* Context stack is initially empty, with room for 10 levels.  */
+  context_stack
+    = (struct context_stack *) xmalloc (10 * sizeof (struct context_stack));
+  context_stack_size = 10;
+  context_stack_depth = 0;
+
+  new_object_header_files ();
+
+  type_vector_length = 160;
+  type_vector = (struct type **)
+    xmalloc (type_vector_length * sizeof (struct type *));
+  bzero (type_vector, type_vector_length * sizeof (struct type *));
+
+  /* Initialize the list of sub source files with one entry
+     for this file (the top-level source file).  */
+
+  subfiles = 0;
+  current_subfile = 0;
+  start_subfile (name, dirname);
+}
+
+/* Finish the symbol definitions for one main source file,
+   close off all the lexical contexts for that file
+   (creating struct block's for them), then make the struct symtab
+   for that file and put it in the list of all such.
+
+   END_ADDR is the address of the end of the file's text.  */
+
+struct symtab *
+end_symtab (end_addr)
+     CORE_ADDR end_addr;
+{
+  register struct symtab *symtab;
+  register struct blockvector *blockvector;
+  register struct subfile *subfile;
+  register struct linetable *lv;
+  struct subfile *nextsub;
+
+  /* Finish the lexical context of the last function in the file;
+     pop the context stack.  */
+
+  if (context_stack_depth > 0)
+    {
+      register struct context_stack *cstk;
+      context_stack_depth--;
+      cstk = &context_stack[context_stack_depth];
+      /* Make a block for the local symbols within.  */
+      finish_block (cstk->name, &local_symbols, cstk->old_blocks,
+		    cstk->start_addr, end_addr);
+    }
+
+  /* Cleanup any undefined types that have been left hanging around
+     (this needs to be done before the finish_blocks so that
+     file_symbols is still good).  */
+  cleanup_undefined_types ();
+
+  /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector.  */
+  finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
+  finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
+  blockvector = make_blockvector ();
+
+  current_subfile->line_vector_index = line_vector_index;
+
+  /* Now create the symtab objects proper, one for each subfile.  */
+  /* (The main file is the last one on the chain.)  */
+
+  for (subfile = subfiles; subfile; subfile = nextsub)
+    {
+      symtab = allocate_symtab (subfile->name);
+
+      /* Fill in its components.  */
+      symtab->blockvector = blockvector;
+      lv = subfile->line_vector;
+      lv->nitems = subfile->line_vector_index;
+      symtab->linetable = (struct linetable *)
+	xrealloc (lv, (sizeof (struct linetable)
+		       + lv->nitems * sizeof (struct linetable_entry)));
+
+      symtab->dirname = subfile->dirname;
+
+      symtab->free_code = free_linetable;
+      symtab->free_ptr = 0;
+
+      /* There should never already be a symtab for this name, since
+	 any prev dups have been removed when the psymtab was read in.
+  	 FIXME, there ought to be a way to check this here.  */
+      /* FIXME blewit |= free_named_symtabs (symtab->filename);  */
+
+      /* Link the new symtab into the list of such.  */
+      symtab->next = symtab_list;
+      symtab_list = symtab;
+
+      nextsub = subfile->next;
+      free (subfile);
+    }
+
+  free ((char *) type_vector);
+  type_vector = 0;
+  type_vector_length = -1;
+  line_vector = 0;
+  line_vector_length = -1;
+  last_source_file = 0;
+
+  return symtab;
+}
+
+/* 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 ()
+{
+  free_pendings = 0;
+  file_symbols = 0;
+  global_symbols = 0;
+  pending_blocks = 0;
+}
+
+/* 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 ()
+{
+  /* Empty the hash table of global syms looking for values.  */
+  bzero (global_sym_chain, sizeof global_sym_chain);
+
+  buildsym_init ();
+}
+
+/* Scan through all of the global symbols defined in the object file,
+   assigning values to the debugging symbols that need to be assigned
+   to.  Get these symbols from the misc function list.  */
+
+void
+scan_file_globals ()
+{
+  int hash;
+  int mf;
+
+  for (mf = 0; mf < misc_function_count; mf++)
+    {
+      char *namestring = misc_function_vector[mf].name;
+      struct symbol *sym, *prev;
+
+      QUIT;
+
+      prev = (struct symbol *) 0;
+
+      /* Get the hash index and check all the symbols
+	 under that hash index. */
+
+      hash = hashname (namestring);
+
+      for (sym = global_sym_chain[hash]; sym;)
+	{
+	  if (*namestring == SYMBOL_NAME (sym)[0]
+	      && !strcmp(namestring + 1, SYMBOL_NAME (sym) + 1))
+	    {
+	      /* Splice this symbol out of the hash chain and
+		 assign the value we have to it. */
+	      if (prev)
+		SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
+	      else
+		global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
+	      
+	      /* Check to see whether we need to fix up a common block.  */
+	      /* Note: this code might be executed several times for
+		 the same symbol if there are multiple references.  */
+	      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
+		fix_common_block (sym, misc_function_vector[mf].address);
+	      else
+		SYMBOL_VALUE_ADDRESS (sym) = misc_function_vector[mf].address;
+	      
+	      if (prev)
+		sym = SYMBOL_VALUE_CHAIN (prev);
+	      else
+		sym = global_sym_chain[hash];
+	    }
+	  else
+	    {
+	      prev = sym;
+	      sym = SYMBOL_VALUE_CHAIN (sym);
+	    }
+	}
+    }
+}
+
+
+/* Read a number by which a type is referred to in dbx data,
+   or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
+   Just a single number N is equivalent to (0,N).
+   Return the two numbers by storing them in the vector TYPENUMS.
+   TYPENUMS will then be used as an argument to dbx_lookup_type.  */
+
+void
+read_type_number (pp, typenums)
+     register char **pp;
+     register int *typenums;
+{
+  if (**pp == '(')
+    {
+      (*pp)++;
+      typenums[0] = read_number (pp, ',');
+      typenums[1] = read_number (pp, ')');
+    }
+  else
+    {
+      typenums[0] = 0;
+      typenums[1] = read_number (pp, 0);
+    }
+}
+
+/* To handle GNU C++ typename abbreviation, we need to be able to
+   fill in a type's name as soon as space for that type is allocated.
+   `type_synonym_name' is the name of the type being allocated.
+   It is cleared as soon as it is used (lest all allocated types
+   get this name).  */
+static char *type_synonym_name;
+
+/* ARGSUSED */
+static struct symbol *
+define_symbol (valu, string, desc, type)
+     unsigned int valu;
+     char *string;
+     int desc;
+     int type;
+{
+  register struct symbol *sym;
+  char *p = (char *) strchr (string, ':');
+  int deftype;
+  int synonym = 0;
+  register int i;
+
+  /* Ignore syms with empty names.  */
+  if (string[0] == 0)
+    return 0;
+
+  /* Ignore old-style symbols from cc -go  */
+  if (p == 0)
+    return 0;
+
+  sym = (struct symbol *)obstack_alloc (symbol_obstack, sizeof (struct symbol));
+
+  if (processing_gcc_compilation) {
+    /* GCC 2.x puts the line number in desc.  SunOS apparently puts in the
+       number of bytes occupied by a type or object, which we ignore.  */
+    SYMBOL_LINE(sym) = desc;
+  } else {
+    SYMBOL_LINE(sym) = 0;			/* unknown */
+  }
+
+  if (string[0] == CPLUS_MARKER)
+    {
+      /* Special GNU C++ names.  */
+      switch (string[1])
+	{
+	case 't':
+	  SYMBOL_NAME (sym) = "this";
+	  break;
+	case 'v': /* $vtbl_ptr_type */
+	  /* Was: SYMBOL_NAME (sym) = "vptr"; */
+	  goto normal;
+	case 'e':
+	  SYMBOL_NAME (sym) = "eh_throw";
+	  break;
+
+	case '_':
+	  /* This was an anonymous type that was never fixed up.  */
+	  goto normal;
+
+	default:
+	  abort ();
+	}
+    }
+  else
+    {
+    normal:
+      SYMBOL_NAME (sym)
+	= (char *) obstack_alloc (symbol_obstack, ((p - string) + 1));
+      /* Open-coded bcopy--saves function call time.  */
+      {
+	register char *p1 = string;
+	register char *p2 = SYMBOL_NAME (sym);
+	while (p1 != p)
+	  *p2++ = *p1++;
+	*p2++ = '\0';
+      }
+    }
+  p++;
+  /* Determine the type of name being defined.  */
+  /* The Acorn RISC machine's compiler can put out locals that don't
+     start with "234=" or "(3,4)=", so assume anything other than the
+     deftypes we know how to handle is a local.  */
+  /* (Peter Watkins @ Computervision)
+     Handle Sun-style local fortran array types 'ar...' . 
+     (gnu@cygnus.com) -- this strchr() handles them properly?
+     (tiemann@cygnus.com) -- 'C' is for catch.  */
+  if (!strchr ("cfFGpPrStTvVXC", *p))
+    deftype = 'l';
+  else
+    deftype = *p++;
+
+  /* c is a special case, not followed by a type-number.
+     SYMBOL:c=iVALUE for an integer constant symbol.
+     SYMBOL:c=rVALUE for a floating constant symbol.
+     SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
+        e.g. "b:c=e6,0" for "const b = blob1"
+	(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
+  if (deftype == 'c')
+    {
+      if (*p++ != '=')
+	error ("Invalid symbol data at symtab pos %d.", symnum);
+      switch (*p++)
+	{
+	case 'r':
+	  {
+	    double d = atof (p);
+	    char *dbl_valu;
+
+	    SYMBOL_TYPE (sym) = builtin_type_double;
+	    dbl_valu =
+	      (char *) obstack_alloc (symbol_obstack, sizeof (double));
+	    bcopy (&d, dbl_valu, sizeof (double));
+	    SWAP_TARGET_AND_HOST (dbl_valu, sizeof (double));
+	    SYMBOL_VALUE_BYTES (sym) = dbl_valu;
+	    SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
+	  }
+	  break;
+	case 'i':
+	  {
+	    SYMBOL_TYPE (sym) = builtin_type_int;
+	    SYMBOL_VALUE (sym) = atoi (p);
+	    SYMBOL_CLASS (sym) = LOC_CONST;
+	  }
+	  break;
+	case 'e':
+	  /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
+	     e.g. "b:c=e6,0" for "const b = blob1"
+	     (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
+	  {
+	    int typenums[2];
+	    
+	    read_type_number (&p, typenums);
+	    if (*p++ != ',')
+	      error ("Invalid symbol data: no comma in enum const symbol");
+	    
+	    SYMBOL_TYPE (sym) = *dbx_lookup_type (typenums);
+	    SYMBOL_VALUE (sym) = atoi (p);
+	    SYMBOL_CLASS (sym) = LOC_CONST;
+	  }
+	  break;
+	default:
+	  error ("Invalid symbol data at symtab pos %d.", symnum);
+	}
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      return sym;
+    }
+
+  /* Now usually comes a number that says which data type,
+     and possibly more stuff to define the type
+     (all of which is handled by read_type)  */
+
+  if (deftype == 'p' && *p == 'F')
+    /* pF is a two-letter code that means a function parameter in Fortran.
+       The type-number specifies the type of the return value.
+       Translate it into a pointer-to-function type.  */
+    {
+      p++;
+      SYMBOL_TYPE (sym)
+	= lookup_pointer_type (lookup_function_type (read_type (&p)));
+    }
+  else
+    {
+      struct type *type_read;
+      synonym = *p == 't';
+
+      if (synonym)
+	{
+	  p += 1;
+	  type_synonym_name = obsavestring (SYMBOL_NAME (sym),
+					    strlen (SYMBOL_NAME (sym)));
+	}
+
+      type_read = read_type (&p);
+
+      if ((deftype == 'F' || deftype == 'f')
+	  && TYPE_CODE (type_read) != TYPE_CODE_FUNC)
+      {
+#if 0
+/* This code doesn't work -- it needs to realloc and can't.  */
+	struct type *new = (struct type *)
+	      obstack_alloc (symbol_obstack, sizeof (struct type));
+
+	/* Generate a template for the type of this function.  The 
+	   types of the arguments will be added as we read the symbol 
+	   table. */
+	*new = *lookup_function_type (type_read);
+	SYMBOL_TYPE(sym) = new;
+	in_function_type = new;
+#else
+	SYMBOL_TYPE (sym) = lookup_function_type (type_read);
+#endif
+      }
+      else
+	SYMBOL_TYPE (sym) = type_read;
+    }
+
+  switch (deftype)
+    {
+    case 'C':
+      /* The name of a caught exception.  */
+      SYMBOL_CLASS (sym) = LOC_LABEL;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      SYMBOL_VALUE_ADDRESS (sym) = valu;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'f':
+      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 'F':
+      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &global_symbols);
+      break;
+
+    case 'G':
+      /* For a class G (global) symbol, it appears that the
+	 value is not correct.  It is necessary to search for the
+	 corresponding linker definition to find the value.
+	 These definitions appear at the end of the namelist.  */
+      i = hashname (SYMBOL_NAME (sym));
+      SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
+      global_sym_chain[i] = sym;
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &global_symbols);
+      break;
+
+      /* This case is faked by a conditional above,
+	 when there is no code letter in the dbx data.
+	 Dbx data never actually contains 'l'.  */
+    case 'l':
+      SYMBOL_CLASS (sym) = LOC_LOCAL;
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'p':
+      /* Normally this is a parameter, a LOC_ARG.  On the i960, it
+	 can also be a LOC_LOCAL_ARG depending on symbol type.  */
+#ifndef DBX_PARM_SYMBOL_CLASS
+#define	DBX_PARM_SYMBOL_CLASS(type)	LOC_ARG
+#endif
+      SYMBOL_CLASS (sym) = DBX_PARM_SYMBOL_CLASS (type);
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+#if 0
+      /* This doesn't work yet.  */
+      add_param_to_type (&in_function_type, sym);
+#endif
+      add_symbol_to_list (sym, &local_symbols);
+
+      /* If it's gcc-compiled, if it says `short', believe it.  */
+      if (processing_gcc_compilation || BELIEVE_PCC_PROMOTION)
+	break;
+
+#if defined(BELIEVE_PCC_PROMOTION_TYPE)
+      /* This macro is defined on machines (e.g. sparc) where
+	 we should believe the type of a PCC 'short' argument,
+	 but shouldn't believe the address (the address is
+	 the address of the corresponding int).  Note that
+	 this is only different from the BELIEVE_PCC_PROMOTION
+	 case on big-endian machines.
+
+	 My guess is that this correction, as opposed to changing
+	 the parameter to an 'int' (as done below, for PCC
+	 on most machines), is the right thing to do
+	 on all machines, but I don't want to risk breaking
+	 something that already works.  On most PCC machines,
+	 the sparc problem doesn't come up because the calling
+	 function has to zero the top bytes (not knowing whether
+	 the called function wants an int or a short), so there
+	 is no practical difference between an int and a short
+	 (except perhaps what happens when the GDB user types
+	 "print short_arg = 0x10000;"). 
+
+	 Hacked for SunOS 4.1 by gnu@cygnus.com.  In 4.1, the compiler
+	 actually produces the correct address (we don't need to fix it
+	 up).  I made this code adapt so that it will offset the symbol
+	 if it was pointing at an int-aligned location and not
+	 otherwise.  This way you can use the same gdb for 4.0.x and
+	 4.1 systems.  */
+
+      if (0 == SYMBOL_VALUE (sym) % sizeof (int))
+	{
+	  if (SYMBOL_TYPE (sym) == builtin_type_char
+	      || SYMBOL_TYPE (sym) == builtin_type_unsigned_char)
+	    SYMBOL_VALUE (sym) += 3;
+	  else if (SYMBOL_TYPE (sym) == builtin_type_short
+	      || SYMBOL_TYPE (sym) == builtin_type_unsigned_short)
+	    SYMBOL_VALUE (sym) += 2;
+	}
+      break;
+
+#else /* no BELIEVE_PCC_PROMOTION_TYPE.  */
+
+      /* If PCC says a parameter is a short or a char,
+	 it is really an int.  */
+      if (SYMBOL_TYPE (sym) == builtin_type_char
+	  || SYMBOL_TYPE (sym) == builtin_type_short)
+	SYMBOL_TYPE (sym) = builtin_type_int;
+      else if (SYMBOL_TYPE (sym) == builtin_type_unsigned_char
+	       || SYMBOL_TYPE (sym) == builtin_type_unsigned_short)
+	SYMBOL_TYPE (sym) = builtin_type_unsigned_int;
+      break;
+
+#endif /* no BELIEVE_PCC_PROMOTION_TYPE.  */
+
+    case 'P':
+      SYMBOL_CLASS (sym) = LOC_REGPARM;
+      SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'r':
+      SYMBOL_CLASS (sym) = LOC_REGISTER;
+      SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'S':
+      /* Static symbol at top level of file */
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_VALUE_ADDRESS (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 't':
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
+	  && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	TYPE_NAME (SYMBOL_TYPE (sym)) =
+	  obsavestring (SYMBOL_NAME (sym),
+			strlen (SYMBOL_NAME (sym)));
+       /* C++ vagaries: we may have a type which is derived from
+ 	 a base type which did not have its name defined when the
+ 	 derived class was output.  We fill in the derived class's
+ 	 base part member's name here in that case.  */
+       else if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+		 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
+		&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
+	 {
+	   int j;
+	   for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
+	     if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
+	       TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
+		 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
+	 }
+
+      add_symbol_to_list (sym, &file_symbols);
+      break;
+
+    case 'T':
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0
+	  && (TYPE_FLAGS (SYMBOL_TYPE (sym)) & TYPE_FLAG_PERM) == 0)
+	TYPE_NAME (SYMBOL_TYPE (sym))
+	  = obconcat ("",
+		      (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM
+		       ? "enum "
+		       : (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
+			  ? "struct " : "union ")),
+		      SYMBOL_NAME (sym));
+      add_symbol_to_list (sym, &file_symbols);
+
+      if (synonym)
+	{
+	  register struct symbol *typedef_sym
+	    = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
+	  SYMBOL_NAME (typedef_sym) = SYMBOL_NAME (sym);
+	  SYMBOL_TYPE (typedef_sym) = SYMBOL_TYPE (sym);
+
+	  SYMBOL_CLASS (typedef_sym) = LOC_TYPEDEF;
+	  SYMBOL_VALUE (typedef_sym) = valu;
+	  SYMBOL_NAMESPACE (typedef_sym) = VAR_NAMESPACE;
+	  add_symbol_to_list (typedef_sym, &file_symbols);
+	}
+      break;
+
+    case 'V':
+      /* Static symbol of local scope */
+      SYMBOL_CLASS (sym) = LOC_STATIC;
+      SYMBOL_VALUE_ADDRESS (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'v':
+      /* Reference parameter */
+      SYMBOL_CLASS (sym) = LOC_REF_ARG;
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    case 'X':
+      /* This is used by Sun FORTRAN for "function result value".
+	 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
+	 that Pascal uses it too, but when I tried it Pascal used
+	 "x:3" (local symbol) instead.  */
+      SYMBOL_CLASS (sym) = LOC_LOCAL;
+      SYMBOL_VALUE (sym) = valu;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      add_symbol_to_list (sym, &local_symbols);
+      break;
+
+    default:
+      error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
+    }
+  return sym;
+}
+
+/* What about types defined as forward references inside of a small lexical
+   scope?  */
+/* Add a type to the list of undefined types to be checked through
+   once this file has been read in.  */
+static void
+add_undefined_type (type)
+     struct type *type;
+{
+  if (undef_types_length == undef_types_allocated)
+    {
+      undef_types_allocated *= 2;
+      undef_types = (struct type **)
+	xrealloc (undef_types,
+		  undef_types_allocated * sizeof (struct type *));
+    }
+  undef_types[undef_types_length++] = type;
+}
+
+/* Add here something to go through each undefined type, see if it's
+   still undefined, and do a full lookup if so.  */
+static void
+cleanup_undefined_types ()
+{
+  struct type **type;
+
+  for (type = undef_types; type < undef_types + undef_types_length; type++)
+    {
+      /* Reasonable test to see if it's been defined since.  */
+      if (TYPE_NFIELDS (*type) == 0)
+	{
+	  struct pending *ppt;
+	  int i;
+	  /* Name of the type, without "struct" or "union" */
+	  char *typename = TYPE_NAME (*type);
+
+	  if (!strncmp (typename, "struct ", 7))
+	    typename += 7;
+	  if (!strncmp (typename, "union ", 6))
+	    typename += 6;
+
+	  for (ppt = file_symbols; ppt; ppt = ppt->next)
+	    for (i = 0; i < ppt->nsyms; i++)
+	      {
+		struct symbol *sym = ppt->symbol[i];
+
+		if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+		    && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
+		    && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
+			TYPE_CODE (*type))
+		    && !strcmp (SYMBOL_NAME (sym), typename))
+		  bcopy (SYMBOL_TYPE (sym), *type, sizeof (struct type));
+	      }
+	}
+      else
+	/* It has been defined; don't mark it as a stub.  */
+	TYPE_FLAGS (*type) &= ~TYPE_FLAG_STUB;
+    }
+  undef_types_length = 0;
+}
+
+/* Skip rest of this symbol and return an error type.
+
+   General notes on error recovery:  error_type always skips to the
+   end of the symbol (modulo cretinous dbx symbol name continuation).
+   Thus code like this:
+
+   if (*(*pp)++ != ';')
+     return error_type (pp);
+
+   is wrong because if *pp starts out pointing at '\0' (typically as the
+   result of an earlier error), it will be incremented to point to the
+   start of the next symbol, which might produce strange results, at least
+   if you run off the end of the string table.  Instead use
+
+   if (**pp != ';')
+     return error_type (pp);
+   ++*pp;
+
+   or
+
+   if (**pp != ';')
+     foo = error_type (pp);
+   else
+     ++*pp;
+
+   And in case it isn't obvious, the point of all this hair is so the compiler
+   can define new types and new syntaxes, and old versions of the
+   debugger will be able to read the new symbol tables.  */
+
+struct type *
+error_type (pp)
+     char **pp;
+{
+  complain (&error_type_complaint, 0);
+  while (1)
+    {
+      /* Skip to end of symbol.  */
+      while (**pp != '\0')
+	(*pp)++;
+
+      /* Check for and handle cretinous dbx symbol name continuation!  */
+      if ((*pp)[-1] == '\\')
+	*pp = next_symbol_text ();
+      else
+	break;
+    }
+  return builtin_type_error;
+}
+
+/* Read a dbx type reference or definition;
+   return the type that is meant.
+   This can be just a number, in which case it references
+   a type already defined and placed in type_vector.
+   Or the number can be followed by an =, in which case
+   it means to define a new type according to the text that
+   follows the =.  */
+
+struct type *
+read_type (pp)
+     register char **pp;
+{
+  register struct type *type = 0;
+  struct type *type1;
+  int typenums[2];
+  int xtypenums[2];
+
+  /* Read type number if present.  The type number may be omitted.
+     for instance in a two-dimensional array declared with type
+     "ar1;1;10;ar1;1;10;4".  */
+  if ((**pp >= '0' && **pp <= '9')
+      || **pp == '(')
+    {
+      read_type_number (pp, typenums);
+      
+      /* Detect random reference to type not yet defined.
+	 Allocate a type object but leave it zeroed.  */
+      if (**pp != '=')
+	return dbx_alloc_type (typenums);
+
+      *pp += 2;
+    }
+  else
+    {
+      /* 'typenums=' not present, type is anonymous.  Read and return
+	 the definition, but don't put it in the type vector.  */
+      typenums[0] = typenums[1] = -1;
+      *pp += 1;
+    }
+      
+  switch ((*pp)[-1])
+    {
+    case 'x':
+      {
+	enum type_code code;
+
+	/* Used to index through file_symbols.  */
+	struct pending *ppt;
+	int i;
+	
+	/* Name including "struct", etc.  */
+	char *type_name;
+	
+	/* Name without "struct", etc.  */
+	char *type_name_only;
+
+	{
+	  char *prefix;
+	  char *from, *to;
+	  
+	  /* Set the type code according to the following letter.  */
+	  switch ((*pp)[0])
+	    {
+	    case 's':
+	      code = TYPE_CODE_STRUCT;
+	      prefix = "struct ";
+	      break;
+	    case 'u':
+	      code = TYPE_CODE_UNION;
+	      prefix = "union ";
+	      break;
+	    case 'e':
+	      code = TYPE_CODE_ENUM;
+	      prefix = "enum ";
+	      break;
+	    default:
+	      return error_type (pp);
+	    }
+	  
+	  to = type_name = (char *)
+	    obstack_alloc (symbol_obstack,
+			   (strlen (prefix) +
+			    ((char *) strchr (*pp, ':') - (*pp)) + 1));
+	
+	  /* Copy the prefix.  */
+	  from = prefix;
+	  while (*to++ = *from++)
+	    ;
+	  to--; 
+	
+	  type_name_only = to;
+
+	  /* Copy the name.  */
+	  from = *pp + 1;
+	  while ((*to++ = *from++) != ':')
+	    ;
+	  *--to = '\0';
+	  
+	  /* Set the pointer ahead of the name which we just read.  */
+	  *pp = from;
+	
+#if 0
+	  /* The following hack is clearly wrong, because it doesn't
+	     check whether we are in a baseclass.  I tried to reproduce
+	     the case that it is trying to fix, but I couldn't get
+	     g++ to put out a cross reference to a basetype.  Perhaps
+	     it doesn't do it anymore.  */
+	  /* Note: for C++, the cross reference may be to a base type which
+	     has not yet been seen.  In this case, we skip to the comma,
+	     which will mark the end of the base class name.  (The ':'
+	     at the end of the base class name will be skipped as well.)
+	     But sometimes (ie. when the cross ref is the last thing on
+	     the line) there will be no ','.  */
+	  from = (char *) strchr (*pp, ',');
+	  if (from)
+	    *pp = from;
+#endif /* 0 */
+	}
+
+	/* Now check to see whether the type has already been declared.  */
+	/* This is necessary at least in the case where the
+	   program says something like
+	     struct foo bar[5];
+	   The compiler puts out a cross-reference; we better find
+	   set the length of the structure correctly so we can
+	   set the length of the array.  */
+	for (ppt = file_symbols; ppt; ppt = ppt->next)
+	  for (i = 0; i < ppt->nsyms; i++)
+	    {
+	      struct symbol *sym = ppt->symbol[i];
+
+	      if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
+		  && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
+		  && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
+		  && !strcmp (SYMBOL_NAME (sym), type_name_only))
+		{
+		  obstack_free (symbol_obstack, type_name);
+		  type = SYMBOL_TYPE (sym);
+		  return type;
+		}
+	    }
+	
+	/* Didn't find the type to which this refers, so we must
+	   be dealing with a forward reference.  Allocate a type
+	   structure for it, and keep track of it so we can
+	   fill in the rest of the fields when we get the full
+	   type.  */
+	type = dbx_alloc_type (typenums);
+	TYPE_CODE (type) = code;
+	TYPE_NAME (type) = type_name;
+
+	TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
+
+	add_undefined_type (type);
+	return type;
+      }
+
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '(':
+      (*pp)--;
+      read_type_number (pp, xtypenums);
+      type = *dbx_lookup_type (xtypenums);
+      if (type == 0)
+	type = builtin_type_void;
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
+      break;
+
+    case '*':
+      type1 = read_type (pp);
+      type = lookup_pointer_type (type1);
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
+      break;
+
+    case '@':
+      {
+	struct type *domain = read_type (pp);
+	struct type *memtype;
+
+	if (**pp != ',')
+	  /* Invalid member type data format.  */
+	  return error_type (pp);
+	++*pp;
+
+	memtype = read_type (pp);
+	type = dbx_alloc_type (typenums);
+	smash_to_member_type (type, domain, memtype);
+      }
+      break;
+
+    case '#':
+      if ((*pp)[0] == '#')
+	{
+	  /* We'll get the parameter types from the name.  */
+	  struct type *return_type;
+
+	  *pp += 1;
+	  return_type = read_type (pp);
+	  if (*(*pp)++ != ';')
+	    complain (&invalid_member_complaint, symnum);
+	  type = allocate_stub_method (return_type);
+	  if (typenums[0] != -1)
+	    *dbx_lookup_type (typenums) = type;
+	}
+      else
+	{
+	  struct type *domain = read_type (pp);
+	  struct type *return_type;
+	  struct type **args;
+
+	  if (*(*pp)++ != ',')
+	    error ("invalid member type data format, at symtab pos %d.",
+		   symnum);
+
+	  return_type = read_type (pp);
+	  args = read_args (pp, ';');
+	  type = dbx_alloc_type (typenums);
+	  smash_to_method_type (type, domain, return_type, args);
+	}
+      break;
+
+    case '&':
+      type1 = read_type (pp);
+      type = lookup_reference_type (type1);
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
+      break;
+
+    case 'f':
+      type1 = read_type (pp);
+      type = lookup_function_type (type1);
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
+      break;
+
+    case 'r':
+      type = read_range_type (pp, typenums);
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
+      break;
+
+    case 'e':
+      type = dbx_alloc_type (typenums);
+      type = read_enum_type (pp, type);
+      *dbx_lookup_type (typenums) = type;
+      break;
+
+    case 's':
+      type = dbx_alloc_type (typenums);
+      TYPE_NAME (type) = type_synonym_name;
+      type_synonym_name = 0;
+      type = read_struct_type (pp, type);
+      break;
+
+    case 'u':
+      type = dbx_alloc_type (typenums);
+      TYPE_NAME (type) = type_synonym_name;
+      type_synonym_name = 0;
+      type = read_struct_type (pp, type);
+      TYPE_CODE (type) = TYPE_CODE_UNION;
+      break;
+
+    case 'a':
+      if (**pp != 'r')
+	return error_type (pp);
+      ++*pp;
+      
+      type = dbx_alloc_type (typenums);
+      type = read_array_type (pp, type);
+      break;
+
+    default:
+      --*pp;			/* Go back to the symbol in error */
+				/* Particularly important if it was \0! */
+      return error_type (pp);
+    }
+
+  if (type == 0)
+    abort ();
+
+#if 0
+  /* If this is an overriding temporary alteration for a header file's
+     contents, and this type number is unknown in the global definition,
+     put this type into the global definition at this type number.  */
+  if (header_file_prev_index >= 0)
+    {
+      register struct type **tp
+        = explicit_lookup_type (header_file_prev_index, typenums[1]);
+      if (*tp == 0)
+	*tp = type;
+    }
+#endif
+  return type;
+}
+
+/* This page contains subroutines of read_type.  */
+
+/* Read the description of a structure (or union type)
+   and return an object describing the type.  */
+
+struct type *
+read_struct_type (pp, type)
+     char **pp;
+     register struct type *type;
+{
+  /* Total number of methods defined in this class.
+     If the class defines two `f' methods, and one `g' method,
+     then this will have the value 3.  */
+  int total_length = 0;
+
+  struct nextfield
+    {
+      struct nextfield *next;
+      int visibility;			/* 0=public, 1=protected, 2=public */
+      struct field field;
+    };
+
+  struct next_fnfield
+    {
+      struct next_fnfield *next;
+      int visibility;			/* 0=public, 1=protected, 2=public */
+      struct fn_field fn_field;
+    };
+
+  struct next_fnfieldlist
+    {
+      struct next_fnfieldlist *next;
+      struct fn_fieldlist fn_fieldlist;
+    };
+
+  register struct nextfield *list = 0;
+  struct nextfield *new;
+  register char *p;
+  int nfields = 0;
+  register int n;
+
+  register struct next_fnfieldlist *mainlist = 0;
+  int nfn_fields = 0;
+
+  if (TYPE_MAIN_VARIANT (type) == 0)
+    {
+      TYPE_MAIN_VARIANT (type) = type;
+    }
+
+  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+
+  /* First comes the total size in bytes.  */
+
+  TYPE_LENGTH (type) = read_number (pp, 0);
+
+  /* C++: Now, if the class is a derived class, then the next character
+     will be a '!', followed by the number of base classes derived from.
+     Each element in the list contains visibility information,
+     the offset of this base class in the derived structure,
+     and then the base type. */
+  if (**pp == '!')
+    {
+      int i, n_baseclasses, offset;
+      struct type *baseclass;
+      int via_public;
+
+      /* Nonzero if it is a virtual baseclass, i.e.,
+
+	 struct A{};
+	 struct B{};
+	 struct C : public B, public virtual A {};
+
+	 B is a baseclass of C; A is a virtual baseclass for C.  This is a C++
+	 2.0 language feature.  */
+      int via_virtual;
+
+      *pp += 1;
+
+      n_baseclasses = read_number (pp, ',');
+      TYPE_FIELD_VIRTUAL_BITS (type) =
+	  (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (n_baseclasses));
+      B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), n_baseclasses);
+
+      for (i = 0; i < n_baseclasses; i++)
+	{
+	  if (**pp == '\\')
+	    *pp = next_symbol_text ();
+
+	  switch (**pp)
+	    {
+	    case '0':
+	      via_virtual = 0;
+	      break;
+	    case '1':
+	      via_virtual = 1;
+	      break;
+	    default:
+	      /* Bad visibility format.  */
+	      return error_type (pp);
+	    }
+	  ++*pp;
+
+	  switch (**pp)
+	    {
+	    case '0':
+	      via_public = 0;
+	      break;
+	    case '2':
+	      via_public = 2;
+	      break;
+	    default:
+	      /* Bad visibility format.  */
+	      return error_type (pp);
+	    }
+	  if (via_virtual) 
+	    SET_TYPE_FIELD_VIRTUAL (type, i);
+	  ++*pp;
+
+	  /* Offset of the portion of the object corresponding to
+	     this baseclass.  Always zero in the absence of
+	     multiple inheritance.  */
+	  offset = read_number (pp, ',');
+	  baseclass = read_type (pp);
+	  *pp += 1;		/* skip trailing ';' */
+
+	  /* Make this baseclass visible for structure-printing purposes.  */
+	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	  new->next = list;
+	  list = new;
+	  list->visibility = via_public;
+	  list->field.type = baseclass;
+	  list->field.name = type_name_no_tag (baseclass);
+	  list->field.bitpos = offset;
+	  list->field.bitsize = 0;	/* this should be an unpacked field! */
+	  nfields++;
+	}
+      TYPE_N_BASECLASSES (type) = n_baseclasses;
+    }
+
+  /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
+     At the end, we see a semicolon instead of a field.
+
+     In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
+     a static field.
+
+     The `?' is a placeholder for one of '/2' (public visibility),
+     '/1' (protected visibility), '/0' (private visibility), or nothing
+     (C style symbol table, public visibility).  */
+
+  /* We better set p right now, in case there are no fields at all...    */
+  p = *pp;
+
+  while (**pp != ';')
+    {
+      /* Check for and handle cretinous dbx symbol name continuation!  */
+      if (**pp == '\\') *pp = next_symbol_text ();
+
+      /* Get space to record the next field's data.  */
+      new = (struct nextfield *) alloca (sizeof (struct nextfield));
+      new->next = list;
+      list = new;
+
+      /* Get the field name.  */
+      p = *pp;
+      if (*p == CPLUS_MARKER)
+	{
+	  /* Special GNU C++ name.  */
+	  if (*++p == 'v')
+	    {
+	      const char *prefix;
+	      char *name = 0;
+	      struct type *context;
+
+	      switch (*++p)
+		{
+		case 'f':
+		  prefix = vptr_name;
+		  break;
+		case 'b':
+		  prefix = vb_name;
+		  break;
+		default:
+		  error ("invalid abbreviation at symtab pos %d.", symnum);
+		}
+	      *pp = p + 1;
+	      context = read_type (pp);
+	      if (type_name_no_tag (context) == 0)
+		{
+		  if (name == 0)
+		    error ("type name unknown at symtab pos %d.", symnum);
+		  /* FIXME-tiemann: when is `name' ever non-0?  */
+		  TYPE_NAME (context) = obsavestring (name, p - name - 1);
+		}
+	      list->field.name = obconcat (prefix, type_name_no_tag (context), "");
+	      p = ++(*pp);
+	      if (p[-1] != ':')
+		error ("invalid abbreviation at symtab pos %d.", symnum);
+	      list->field.type = read_type (pp);
+	      (*pp)++;			/* Skip the comma.  */
+	      list->field.bitpos = read_number (pp, ';');
+	      /* This field is unpacked.  */
+	      list->field.bitsize = 0;
+	    }
+	  /* GNU C++ anonymous type.  */
+	  else if (*p == '_')
+	    break;
+	  else
+	    error ("invalid abbreviation at symtab pos %d.", symnum);
+
+	  nfields++;
+	  continue;
+	}
+
+      while (*p != ':') p++;
+      list->field.name = obsavestring (*pp, p - *pp);
+
+      /* C++: Check to see if we have hit the methods yet.  */
+      if (p[1] == ':')
+	break;
+
+      *pp = p + 1;
+
+      /* This means we have a visibility for a field coming. */
+      if (**pp == '/')
+	{
+	  switch (*++*pp)
+	    {
+	    case '0':
+	      list->visibility = 0;	/* private */
+	      *pp += 1;
+	      break;
+
+ 	    case '1':
+ 	      list->visibility = 1;	/* protected */
+ 	      *pp += 1;
+ 	      break;
+
+ 	    case '2':
+ 	      list->visibility = 2;	/* public */
+ 	      *pp += 1;
+ 	      break;
+ 	    }
+ 	}
+       else /* normal dbx-style format.  */
+	list->visibility = 2;		/* public */
+
+      list->field.type = read_type (pp);
+      if (**pp == ':')
+ 	{
+	  /* Static class member.  */
+ 	  list->field.bitpos = (long)-1;
+ 	  p = ++(*pp);
+ 	  while (*p != ';') p++;
+ 	  list->field.bitsize = (long) savestring (*pp, p - *pp);
+ 	  *pp = p + 1;
+ 	  nfields++;
+ 	  continue;
+ 	}
+       else if (**pp != ',')
+	 /* Bad structure-type format.  */
+	 return error_type (pp);
+
+      (*pp)++;			/* Skip the comma.  */
+      list->field.bitpos = read_number (pp, ',');
+      list->field.bitsize = read_number (pp, ';');
+
+#if 0
+      /* FIXME-tiemann: Can't the compiler put out something which
+	 lets us distinguish these? (or maybe just not put out anything
+	 for the field).  What is the story here?  What does the compiler
+	really do?  Also, patch gdb.texinfo for this case; I document
+	it as a possible problem there.  Search for "DBX-style".  */
+
+      /* This is wrong because this is identical to the symbols
+	 produced for GCC 0-size arrays.  For example:
+         typedef union {
+	   int num;
+	   char str[0];
+	 } foo;
+	 The code which dumped core in such circumstances should be
+	 fixed not to dump core.  */
+
+      /* g++ -g0 can put out bitpos & bitsize zero for a static
+	 field.  This does not give us any way of getting its
+	 class, so we can't know its name.  But we can just
+	 ignore the field so we don't dump core and other nasty
+	 stuff.  */
+      if (list->field.bitpos == 0
+	  && list->field.bitsize == 0)
+	{
+	  complain (&dbx_class_complaint, 0);
+	  /* Ignore this field.  */
+	  list = list->next;
+	}
+      else
+#endif /* 0 */
+	{
+	  /* Detect an unpacked field and mark it as such.
+	     dbx gives a bit size for all fields.
+	     Note that forward refs cannot be packed,
+	     and treat enums as if they had the width of ints.  */
+	  if (TYPE_CODE (list->field.type) != TYPE_CODE_INT
+	      && TYPE_CODE (list->field.type) != TYPE_CODE_ENUM)
+	    list->field.bitsize = 0;
+	  if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
+	       || (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
+		   && (list->field.bitsize
+		       == 8 * TYPE_LENGTH (builtin_type_int))
+		   )
+	       )
+	      &&
+	      list->field.bitpos % 8 == 0)
+	    list->field.bitsize = 0;
+	  nfields++;
+	}
+    }
+
+  if (p[1] == ':')
+    /* chill the list of fields: the last entry (at the head)
+       is a partially constructed entry which we now scrub.  */
+    list = list->next;
+
+  /* Now create the vector of fields, and record how big it is.
+     We need this info to record proper virtual function table information
+     for this class's virtual functions.  */
+
+  TYPE_NFIELDS (type) = nfields;
+  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
+					       sizeof (struct field) * nfields);
+
+  TYPE_FIELD_PRIVATE_BITS (type) =
+    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
+  B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
+
+  TYPE_FIELD_PROTECTED_BITS (type) =
+    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
+  B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
+
+  /* Copy the saved-up fields into the field vector.  */
+
+  for (n = nfields; list; list = list->next)
+    {
+      n -= 1;
+      TYPE_FIELD (type, n) = list->field;
+      if (list->visibility == 0)
+	SET_TYPE_FIELD_PRIVATE (type, n);
+      else if (list->visibility == 1)
+	SET_TYPE_FIELD_PROTECTED (type, n);
+    }
+
+  /* Now come the method fields, as NAME::methods
+     where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
+     At the end, we see a semicolon instead of a field.
+
+     For the case of overloaded operators, the format is
+     OPERATOR::*.methods, where OPERATOR is the string "operator",
+     `*' holds the place for an operator name (such as `+=')
+     and `.' marks the end of the operator name.  */
+  if (p[1] == ':')
+    {
+      /* Now, read in the methods.  To simplify matters, we
+	 "unread" the name that has been read, so that we can
+	 start from the top.  */
+
+      /* For each list of method lists... */
+      do
+	{
+	  int i;
+	  struct next_fnfield *sublist = 0;
+	  struct type *look_ahead_type = NULL;
+	  int length = 0;
+	  struct next_fnfieldlist *new_mainlist =
+	    (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
+	  char *main_fn_name;
+
+	  p = *pp;
+
+	  /* read in the name.  */
+	  while (*p != ':') p++;
+	  if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == CPLUS_MARKER)
+	    {
+	      /* This lets the user type "break operator+".
+	         We could just put in "+" as the name, but that wouldn't
+		 work for "*".  */
+	      static char opname[32] = {'o', 'p', CPLUS_MARKER};
+	      char *o = opname + 3;
+
+	      /* Skip past '::'.  */
+	      p += 2;
+	      while (*p != '.')
+		*o++ = *p++;
+	     main_fn_name = savestring (opname, o - opname);
+	      /* Skip past '.'  */
+	      *pp = p + 1;
+	    }
+	  else
+	    {
+	      i = 0;
+	      main_fn_name = savestring (*pp, p - *pp);
+	      /* Skip past '::'.  */
+	      *pp = p + 2;
+	    }
+	  new_mainlist->fn_fieldlist.name = main_fn_name;
+
+	  do
+	    {
+	      struct next_fnfield *new_sublist =
+		(struct next_fnfield *)alloca (sizeof (struct next_fnfield));
+
+	      /* Check for and handle cretinous dbx symbol name continuation!  */
+	      if (look_ahead_type == NULL) /* Normal case. */
+		{
+		  if (**pp == '\\') *pp = next_symbol_text ();
+
+		  new_sublist->fn_field.type = read_type (pp);
+		  if (**pp != ':')
+		    /* Invalid symtab info for method.  */
+		    return error_type (pp);
+	        }
+	      else
+		{ /* g++ version 1 kludge */
+		  new_sublist->fn_field.type = look_ahead_type;
+		  look_ahead_type = NULL;
+	        }
+
+	      *pp += 1;
+	      p = *pp;
+	      while (*p != ';') p++;
+	      /* If this is just a stub, then we don't have the
+		 real name here.  */
+	      new_sublist->fn_field.physname = savestring (*pp, p - *pp);
+	      *pp = p + 1;
+	      new_sublist->visibility = *(*pp)++ - '0';
+	      if (**pp == '\\') *pp = next_symbol_text ();
+	      switch (**pp)
+		{
+		case 'A': /* Normal functions. */
+		  new_sublist->fn_field.is_const = 0;
+		  new_sublist->fn_field.is_volatile = 0;
+	          (*pp)++;
+		  break;
+		case 'B': /* `const' member functions. */
+		  new_sublist->fn_field.is_const = 1;
+		  new_sublist->fn_field.is_volatile = 0;
+	          (*pp)++;
+		  break;
+		case 'C': /* `volatile' member function. */
+		  new_sublist->fn_field.is_const = 0;
+		  new_sublist->fn_field.is_volatile = 1;
+	          (*pp)++;
+		  break;
+		case 'D': /* `const volatile' member function. */
+		  new_sublist->fn_field.is_const = 1;
+		  new_sublist->fn_field.is_volatile = 1;
+	          (*pp)++;
+		  break;
+		default:
+		  /* This probably just means we're processing a file compiled
+		     with g++ version 1.  */
+		  complain(&const_vol_complaint, **pp);
+		}
+
+	      switch (*(*pp)++)
+		{
+		case '*':
+		  /* virtual member function, followed by index.  */
+		  /* The sign bit is set to distinguish pointers-to-methods
+		     from virtual function indicies.  Since the array is
+		     in words, the quantity must be shifted left by 1
+		     on 16 bit machine, and by 2 on 32 bit machine, forcing
+		     the sign bit out, and usable as a valid index into
+		     the array.  Remove the sign bit here.  */
+		  new_sublist->fn_field.voffset =
+		      (0x7fffffff & read_number (pp, ';')) + 2;
+
+		  if (**pp == '\\') *pp = next_symbol_text ();
+
+		  if (**pp == ';' || **pp == '\0')
+		    /* Must be g++ version 1.  */
+		    new_sublist->fn_field.fcontext = 0;
+		  else
+		    {
+		      /* Figure out from whence this virtual function came.
+			 It may belong to virtual function table of
+			 one of its baseclasses.  */
+		      look_ahead_type = read_type (pp);
+		      if (**pp == ':')
+			{ /* g++ version 1 overloaded methods. */ }
+		      else
+			{
+			  new_sublist->fn_field.fcontext = look_ahead_type;
+			  if (**pp != ';')
+			    return error_type (pp);
+			  else
+			    ++*pp;
+			  look_ahead_type = NULL;
+		        }
+		    }
+		  break;
+
+		case '?':
+		  /* static member function.  */
+		  new_sublist->fn_field.voffset = VOFFSET_STATIC;
+		  break;
+		default:
+		  /* **pp == '.'.  */
+		  /* normal member function.  */
+		  new_sublist->fn_field.voffset = 0;
+		  new_sublist->fn_field.fcontext = 0;
+		  break;
+		}
+
+	      new_sublist->next = sublist;
+	      sublist = new_sublist;
+	      length++;
+	      if (**pp == '\\') *pp = next_symbol_text ();
+	    }
+	  while (**pp != ';' && **pp != '\0');
+
+	  *pp += 1;
+
+	  new_mainlist->fn_fieldlist.fn_fields =
+	    (struct fn_field *) obstack_alloc (symbol_obstack,
+					       sizeof (struct fn_field) * length);
+	  TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist) =
+	    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (length));
+	  B_CLRALL (TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist), length);
+
+	  TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist) =
+	    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (length));
+	  B_CLRALL (TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist), length);
+
+	  for (i = length; (i--, sublist); sublist = sublist->next)
+	    {
+	      new_mainlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
+	      if (sublist->visibility == 0)
+		B_SET (new_mainlist->fn_fieldlist.private_fn_field_bits, i);
+	      else if (sublist->visibility == 1)
+		B_SET (new_mainlist->fn_fieldlist.protected_fn_field_bits, i);
+	    }
+
+	  new_mainlist->fn_fieldlist.length = length;
+	  new_mainlist->next = mainlist;
+	  mainlist = new_mainlist;
+	  nfn_fields++;
+	  total_length += length;
+	}
+      while (**pp != ';');
+    }
+
+  *pp += 1;
+
+  TYPE_FN_FIELDLISTS (type) =
+    (struct fn_fieldlist *) obstack_alloc (symbol_obstack,
+				   sizeof (struct fn_fieldlist) * nfn_fields);
+
+  TYPE_NFN_FIELDS (type) = nfn_fields;
+  TYPE_NFN_FIELDS_TOTAL (type) = total_length;
+
+  {
+    int i;
+    for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
+      TYPE_NFN_FIELDS_TOTAL (type) +=
+	TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type, i));
+  }
+
+  for (n = nfn_fields; mainlist; mainlist = mainlist->next)
+    TYPE_FN_FIELDLISTS (type)[--n] = mainlist->fn_fieldlist;
+
+  if (**pp == '~')
+    {
+      *pp += 1;
+
+      if (**pp == '=')
+	{
+	  TYPE_FLAGS (type)
+	    |= TYPE_FLAG_HAS_CONSTRUCTOR | TYPE_FLAG_HAS_DESTRUCTOR;
+	  *pp += 1;
+	}
+      else if (**pp == '+')
+	{
+	  TYPE_FLAGS (type) |= TYPE_FLAG_HAS_CONSTRUCTOR;
+	  *pp += 1;
+	}
+      else if (**pp == '-')
+	{
+	  TYPE_FLAGS (type) |= TYPE_FLAG_HAS_DESTRUCTOR;
+	  *pp += 1;
+	}
+
+      /* Read either a '%' or the final ';'.  */
+      if (*(*pp)++ == '%')
+	{
+	  /* Now we must record the virtual function table pointer's
+	     field information.  */
+
+	  struct type *t;
+	  int i;
+
+	  t = read_type (pp);
+	  p = (*pp)++;
+	  while (*p != '\0' && *p != ';')
+	    p++;
+	  if (*p == '\0')
+	    /* Premature end of symbol.  */
+	    return error_type (pp);
+	  
+	  TYPE_VPTR_BASETYPE (type) = t;
+	  if (type == t)
+	    {
+	      if (TYPE_FIELD_NAME (t, TYPE_N_BASECLASSES (t)) == 0)
+		{
+		  /* FIXME-tiemann: what's this?  */
+#if 0
+		  TYPE_VPTR_FIELDNO (type) = i = TYPE_N_BASECLASSES (t);
+#else
+		  error_type (pp);
+#endif
+		}
+	      else for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); --i)
+		if (! strncmp (TYPE_FIELD_NAME (t, i), vptr_name, 
+			sizeof (vptr_name) -1))
+		  {
+		    TYPE_VPTR_FIELDNO (type) = i;
+		    break;
+		  }
+	      if (i < 0)
+		/* Virtual function table field not found.  */
+		return error_type (pp);
+	    }
+	  else
+	    TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
+	  *pp = p + 1;
+	}
+    }
+
+  return type;
+}
+
+/* Read a definition of an array type,
+   and create and return a suitable type object.
+   Also creates a range type which represents the bounds of that
+   array.  */
+struct type *
+read_array_type (pp, type)
+     register char **pp;
+     register struct type *type;
+{
+  struct type *index_type, *element_type, *range_type;
+  int lower, upper;
+  int adjustable = 0;
+
+  /* Format of an array type:
+     "ar<index type>;lower;upper;<array_contents_type>".  Put code in
+     to handle this.
+
+     Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
+     for these, produce a type like float[][].  */
+
+  index_type = read_type (pp);
+  if (**pp != ';')
+    /* Improper format of array type decl.  */
+    return error_type (pp);
+  ++*pp;
+
+  if (!(**pp >= '0' && **pp <= '9'))
+    {
+      *pp += 1;
+      adjustable = 1;
+    }
+  lower = read_number (pp, ';');
+
+  if (!(**pp >= '0' && **pp <= '9'))
+    {
+      *pp += 1;
+      adjustable = 1;
+    }
+  upper = read_number (pp, ';');
+  
+  element_type = read_type (pp);
+
+  if (adjustable)
+    {
+      lower = 0;
+      upper = -1;
+    }
+
+  {
+    /* Create range type.  */
+    range_type = (struct type *) obstack_alloc (symbol_obstack,
+						sizeof (struct type));
+    TYPE_CODE (range_type) = TYPE_CODE_RANGE;
+    TYPE_TARGET_TYPE (range_type) = index_type;
+
+    /* This should never be needed.  */
+    TYPE_LENGTH (range_type) = sizeof (int);
+
+    TYPE_NFIELDS (range_type) = 2;
+    TYPE_FIELDS (range_type) =
+      (struct field *) obstack_alloc (symbol_obstack,
+				      2 * sizeof (struct field));
+    TYPE_FIELD_BITPOS (range_type, 0) = lower;
+    TYPE_FIELD_BITPOS (range_type, 1) = upper;
+  }
+
+  TYPE_CODE (type) = TYPE_CODE_ARRAY;
+  TYPE_TARGET_TYPE (type) = element_type;
+  TYPE_LENGTH (type) = (upper - lower + 1) * TYPE_LENGTH (element_type);
+  TYPE_NFIELDS (type) = 1;
+  TYPE_FIELDS (type) =
+    (struct field *) obstack_alloc (symbol_obstack,
+				    sizeof (struct field));
+  TYPE_FIELD_TYPE (type, 0) = range_type;
+
+  return type;
+}
+
+
+/* Read a definition of an enumeration type,
+   and create and return a suitable type object.
+   Also defines the symbols that represent the values of the type.  */
+
+struct type *
+read_enum_type (pp, type)
+     register char **pp;
+     register struct type *type;
+{
+  register char *p;
+  char *name;
+  register long n;
+  register struct symbol *sym;
+  int nsyms = 0;
+  struct pending **symlist;
+  struct pending *osyms, *syms;
+  int o_nsyms;
+
+  if (within_function)
+    symlist = &local_symbols;
+  else
+    symlist = &file_symbols;
+  osyms = *symlist;
+  o_nsyms = osyms ? osyms->nsyms : 0;
+
+  /* Read the value-names and their values.
+     The input syntax is NAME:VALUE,NAME:VALUE, and so on.
+     A semicolon or comman instead of a NAME means the end.  */
+  while (**pp && **pp != ';' && **pp != ',')
+    {
+      /* Check for and handle cretinous dbx symbol name continuation!  */
+      if (**pp == '\\')	*pp = next_symbol_text ();
+
+      p = *pp;
+      while (*p != ':') p++;
+      name = obsavestring (*pp, p - *pp);
+      *pp = p + 1;
+      n = read_number (pp, ',');
+
+      sym = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
+      bzero (sym, sizeof (struct symbol));
+      SYMBOL_NAME (sym) = name;
+      SYMBOL_CLASS (sym) = LOC_CONST;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+      SYMBOL_VALUE (sym) = n;
+      add_symbol_to_list (sym, symlist);
+      nsyms++;
+    }
+
+  if (**pp == ';')
+    (*pp)++;			/* Skip the semicolon.  */
+
+  /* Now fill in the fields of the type-structure.  */
+
+  TYPE_LENGTH (type) = sizeof (int);
+  TYPE_CODE (type) = TYPE_CODE_ENUM;
+  TYPE_NFIELDS (type) = nsyms;
+  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
+
+  /* Find the symbols for the values and put them into the type.
+     The symbols can be found in the symlist that we put them on
+     to cause them to be defined.  osyms contains the old value
+     of that symlist; everything up to there was defined by us.  */
+  /* Note that we preserve the order of the enum constants, so
+     that in something like "enum {FOO, LAST_THING=FOO}" we print
+     FOO, not LAST_THING.  */
+
+  for (syms = *symlist, n = 0; syms; syms = syms->next)
+    {
+      int j = 0;
+      if (syms == osyms)
+	j = o_nsyms;
+      for (; j < syms->nsyms; j++,n++)
+	{
+	  struct symbol *xsym = syms->symbol[j];
+	  SYMBOL_TYPE (xsym) = type;
+	  TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
+	  TYPE_FIELD_VALUE (type, n) = 0;
+	  TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+	  TYPE_FIELD_BITSIZE (type, n) = 0;
+	}
+      if (syms == osyms)
+	break;
+    }
+
+#if 0
+  /* This screws up perfectly good C programs with enums.  FIXME.  */
+  /* Is this Modula-2's BOOLEAN type?  Flag it as such if so. */
+  if(TYPE_NFIELDS(type) == 2 &&
+     ((!strcmp(TYPE_FIELD_NAME(type,0),"TRUE") &&
+       !strcmp(TYPE_FIELD_NAME(type,1),"FALSE")) ||
+      (!strcmp(TYPE_FIELD_NAME(type,1),"TRUE") &&
+       !strcmp(TYPE_FIELD_NAME(type,0),"FALSE"))))
+     TYPE_CODE(type) = TYPE_CODE_BOOL;
+#endif
+
+  return type;
+}
+
+/* Read a number from the string pointed to by *PP.
+   The value of *PP is advanced over the number.
+   If END is nonzero, the character that ends the
+   number must match END, or an error happens;
+   and that character is skipped if it does match.
+   If END is zero, *PP is left pointing to that character.
+
+   If the number fits in a long, set *VALUE and set *BITS to 0.
+   If not, set *BITS to be the number of bits in the number.
+
+   If encounter garbage, set *BITS to -1.  */
+
+void
+read_huge_number (pp, end, valu, bits)
+     char **pp;
+     int end;
+     long *valu;
+     int *bits;
+{
+  char *p = *pp;
+  int sign = 1;
+  long n = 0;
+  int radix = 10;
+  char overflow = 0;
+  int nbits = 0;
+  int c;
+  long upper_limit;
+  
+  if (*p == '-')
+    {
+      sign = -1;
+      p++;
+    }
+
+  /* Leading zero means octal.  GCC uses this to output values larger
+     than an int (because that would be hard in decimal).  */
+  if (*p == '0')
+    {
+      radix = 8;
+      p++;
+    }
+
+  upper_limit = LONG_MAX / radix;
+  while ((c = *p++) >= '0' && c <= ('0' + radix))
+    {
+      if (n <= upper_limit)
+	{
+	  n *= radix;
+	  n += c - '0';		/* FIXME this overflows anyway */
+	}
+      else
+	overflow = 1;
+      
+      /* This depends on large values being output in octal, which is
+	 what GCC does. */
+      if (radix == 8)
+	{
+	  if (nbits == 0)
+	    {
+	      if (c == '0')
+		/* Ignore leading zeroes.  */
+		;
+	      else if (c == '1')
+		nbits = 1;
+	      else if (c == '2' || c == '3')
+		nbits = 2;
+	      else
+		nbits = 3;
+	    }
+	  else
+	    nbits += 3;
+	}
+    }
+  if (end)
+    {
+      if (c && c != end)
+	{
+	  if (bits != NULL)
+	    *bits = -1;
+	  return;
+	}
+    }
+  else
+    --p;
+
+  *pp = p;
+  if (overflow)
+    {
+      if (nbits == 0)
+	{
+	  /* Large decimal constants are an error (because it is hard to
+	     count how many bits are in them).  */
+	  if (bits != NULL)
+	    *bits = -1;
+	  return;
+	}
+      
+      /* -0x7f is the same as 0x80.  So deal with it by adding one to
+	 the number of bits.  */
+      if (sign == -1)
+	++nbits;
+      if (bits)
+	*bits = nbits;
+    }
+  else
+    {
+      if (valu)
+	*valu = n * sign;
+      if (bits)
+	*bits = 0;
+    }
+}
+
+#define	MAX_OF_C_TYPE(t)	((1 << (sizeof (t)*8 - 1)) - 1)
+#define	MIN_OF_C_TYPE(t)	(-(1 << (sizeof (t)*8 - 1)))
+
+struct type *
+read_range_type (pp, typenums)
+     char **pp;
+     int typenums[2];
+{
+  int rangenums[2];
+  long n2, n3;
+  int n2bits, n3bits;
+  int self_subrange;
+  struct type *result_type;
+
+  /* First comes a type we are a subrange of.
+     In C it is usually 0, 1 or the type being defined.  */
+  read_type_number (pp, rangenums);
+  self_subrange = (rangenums[0] == typenums[0] &&
+		   rangenums[1] == typenums[1]);
+
+  /* A semicolon should now follow; skip it.  */
+  if (**pp == ';')
+    (*pp)++;
+
+  /* The remaining two operands are usually lower and upper bounds
+     of the range.  But in some special cases they mean something else.  */
+  read_huge_number (pp, ';', &n2, &n2bits);
+  read_huge_number (pp, ';', &n3, &n3bits);
+
+  if (n2bits == -1 || n3bits == -1)
+    return error_type (pp);
+  
+  /* If limits are huge, must be large integral type.  */
+  if (n2bits != 0 || n3bits != 0)
+    {
+      char got_signed = 0;
+      char got_unsigned = 0;
+      /* Number of bits in the type.  */
+      int nbits;
+
+      /* Range from 0 to <large number> is an unsigned large integral type.  */
+      if ((n2bits == 0 && n2 == 0) && n3bits != 0)
+	{
+	  got_unsigned = 1;
+	  nbits = n3bits;
+	}
+      /* Range from <large number> to <large number>-1 is a large signed
+	 integral type.  */
+      else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
+	{
+	  got_signed = 1;
+	  nbits = n2bits;
+	}
+
+      /* Check for "long long".  */
+      if (got_signed && nbits == TARGET_LONG_LONG_BIT)
+	return builtin_type_long_long;
+      if (got_unsigned && nbits == TARGET_LONG_LONG_BIT)
+	return builtin_type_unsigned_long_long;
+
+      if (got_signed || got_unsigned)
+	{
+	  result_type = (struct type *) obstack_alloc (symbol_obstack,
+						       sizeof (struct type));
+	  bzero (result_type, sizeof (struct type));
+	  TYPE_LENGTH (result_type) = nbits / TARGET_CHAR_BIT;
+	  TYPE_MAIN_VARIANT (result_type) = result_type;
+	  TYPE_CODE (result_type) = TYPE_CODE_INT;
+	  if (got_unsigned)
+	    TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
+	  return result_type;
+	}
+      else
+	return error_type (pp);
+    }
+
+  /* A type defined as a subrange of itself, with bounds both 0, is void.  */
+  if (self_subrange && n2 == 0 && n3 == 0)
+    return builtin_type_void;
+
+  /* If n3 is zero and n2 is not, we want a floating type,
+     and n2 is the width in bytes.
+
+     Fortran programs appear to use this for complex types also,
+     and they give no way to distinguish between double and single-complex!
+     We don't have complex types, so we would lose on all fortran files!
+     So return type `double' for all of those.  It won't work right
+     for the complex values, but at least it makes the file loadable.  */
+
+  if (n3 == 0 && n2 > 0)
+    {
+      if (n2 == sizeof (float))
+	return builtin_type_float;
+      return builtin_type_double;
+    }
+
+  /* If the upper bound is -1, it must really be an unsigned int.  */
+
+  else if (n2 == 0 && n3 == -1)
+    {
+      if (sizeof (int) == sizeof (long))
+	return builtin_type_unsigned_int;
+      else
+	return builtin_type_unsigned_long;
+    }
+
+  /* Special case: char is defined (Who knows why) as a subrange of
+     itself with range 0-127.  */
+  else if (self_subrange && n2 == 0 && n3 == 127)
+    return builtin_type_char;
+
+  /* Assumptions made here: Subrange of self is equivalent to subrange
+     of int.  */
+  else if (n2 == 0
+	   && (self_subrange ||
+	       *dbx_lookup_type (rangenums) == builtin_type_int))
+    {
+      /* an unsigned type */
+#ifdef LONG_LONG
+      if (n3 == - sizeof (long long))
+	return builtin_type_unsigned_long_long;
+#endif
+      if (n3 == (unsigned int)~0L)
+	return builtin_type_unsigned_int;
+      if (n3 == (unsigned long)~0L)
+	return builtin_type_unsigned_long;
+      if (n3 == (unsigned short)~0L)
+	return builtin_type_unsigned_short;
+      if (n3 == (unsigned char)~0L)
+	return builtin_type_unsigned_char;
+    }
+#ifdef LONG_LONG
+  else if (n3 == 0 && n2 == -sizeof (long long))
+    return builtin_type_long_long;
+#endif  
+  else if (n2 == -n3 -1)
+    {
+      /* a signed type */
+      if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
+	return builtin_type_int;
+      if (n3 == (1 << (8 * sizeof (long) - 1)) - 1)
+	 return builtin_type_long;
+      if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
+	return builtin_type_short;
+      if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
+	return builtin_type_char;
+    }
+
+  /* We have a real range type on our hands.  Allocate space and
+     return a real pointer.  */
+
+  /* At this point I don't have the faintest idea how to deal with
+     a self_subrange type; I'm going to assume that this is used
+     as an idiom, and that all of them are special cases.  So . . .  */
+  if (self_subrange)
+    return error_type (pp);
+
+  result_type = (struct type *) obstack_alloc (symbol_obstack,
+					       sizeof (struct type));
+  bzero (result_type, sizeof (struct type));
+
+  TYPE_CODE (result_type) = TYPE_CODE_RANGE;
+
+  TYPE_TARGET_TYPE (result_type) = *dbx_lookup_type(rangenums);
+  if (TYPE_TARGET_TYPE (result_type) == 0) {
+    complain (&range_type_base_complaint, rangenums[1]);
+    TYPE_TARGET_TYPE (result_type) = builtin_type_int;
+  }
+
+  TYPE_NFIELDS (result_type) = 2;
+  TYPE_FIELDS (result_type) =
+     (struct field *) obstack_alloc (symbol_obstack,
+				     2 * sizeof (struct field));
+  bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
+  TYPE_FIELD_BITPOS (result_type, 0) = n2;
+  TYPE_FIELD_BITPOS (result_type, 1) = n3;
+
+#if 0
+/* Note that TYPE_LENGTH (result_type) is just overridden a few
+   statements down.  What do we really need here?  */
+  /* We have to figure out how many bytes it takes to hold this
+     range type.  I'm going to assume that anything that is pushing
+     the bounds of a long was taken care of above.  */
+  if (n2 >= MIN_OF_C_TYPE(char) && n3 <= MAX_OF_C_TYPE(char))
+    TYPE_LENGTH (result_type) = 1;
+  else if (n2 >= MIN_OF_C_TYPE(short) && n3 <= MAX_OF_C_TYPE(short))
+    TYPE_LENGTH (result_type) = sizeof (short);
+  else if (n2 >= MIN_OF_C_TYPE(int) && n3 <= MAX_OF_C_TYPE(int))
+    TYPE_LENGTH (result_type) = sizeof (int);
+  else if (n2 >= MIN_OF_C_TYPE(long) && n3 <= MAX_OF_C_TYPE(long))
+    TYPE_LENGTH (result_type) = sizeof (long);
+  else
+    /* Ranged type doesn't fit within known sizes.  */
+    /* FIXME -- use "long long" here.  */
+    return error_type (pp);
+#endif
+
+  TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
+
+  return result_type;
+}
+
+/* Read a number from the string pointed to by *PP.
+   The value of *PP is advanced over the number.
+   If END is nonzero, the character that ends the
+   number must match END, or an error happens;
+   and that character is skipped if it does match.
+   If END is zero, *PP is left pointing to that character.  */
+
+long
+read_number (pp, end)
+     char **pp;
+     int end;
+{
+  register char *p = *pp;
+  register long n = 0;
+  register int c;
+  int sign = 1;
+
+  /* Handle an optional leading minus sign.  */
+
+  if (*p == '-')
+    {
+      sign = -1;
+      p++;
+    }
+
+  /* Read the digits, as far as they go.  */
+
+  while ((c = *p++) >= '0' && c <= '9')
+    {
+      n *= 10;
+      n += c - '0';
+    }
+  if (end)
+    {
+      if (c && c != end)
+	error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
+    }
+  else
+    --p;
+
+  *pp = p;
+  return n * sign;
+}
+
+/* Read in an argument list.  This is a list of types, separated by commas
+   and terminated with END.  Return the list of types read in, or (struct type
+   **)-1 if there is an error.  */
+struct type **
+read_args (pp, end)
+     char **pp;
+     int end;
+{
+  struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
+  int n = 0;
+
+  while (**pp != end)
+    {
+      if (**pp != ',')
+	/* Invalid argument list: no ','.  */
+	return (struct type **)-1;
+      *pp += 1;
+
+      /* Check for and handle cretinous dbx symbol name continuation! */
+      if (**pp == '\\')
+	*pp = next_symbol_text ();
+
+      types[n++] = read_type (pp);
+    }
+  *pp += 1;			/* get past `end' (the ':' character) */
+
+  if (n == 1)
+    {
+      rval = (struct type **) xmalloc (2 * sizeof (struct type *));
+    }
+  else if (TYPE_CODE (types[n-1]) != TYPE_CODE_VOID)
+    {
+      rval = (struct type **) xmalloc ((n + 1) * sizeof (struct type *));
+      bzero (rval + n, sizeof (struct type *));
+    }
+  else
+    {
+      rval = (struct type **) xmalloc (n * sizeof (struct type *));
+    }
+  bcopy (types, rval, n * sizeof (struct type *));
+  return rval;
+}
+
+/* Add a common block's start address to the offset of each symbol
+   declared to be in it (by being between a BCOMM/ECOMM pair that uses
+   the common block name).  */
+
+static void
+fix_common_block (sym, valu)
+    struct symbol *sym;
+    int valu;
+{
+  struct pending *next = (struct pending *) SYMBOL_NAMESPACE (sym);
+  for ( ; next; next = next->next)
+    {
+      register int j;
+      for (j = next->nsyms - 1; j >= 0; j--)
+	SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
+    }
+}
+
+/* Initializer for this module */
+void
+_initialize_buildsym ()
+{
+  undef_types_allocated = 20;
+  undef_types_length = 0;
+  undef_types = (struct type **) xmalloc (undef_types_allocated *
+					  sizeof (struct type *));
+}
diff --git a/gdb/buildsym.h b/gdb/buildsym.h
new file mode 100644
index 0000000..7cef879
--- /dev/null
+++ b/gdb/buildsym.h
@@ -0,0 +1,274 @@
+/* Build symbol tables in GDB's internal format.
+   Copyright (C) 1986-1991 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* This module provides definitions used for creating and adding to
+   the symbol table.  These routines are called from various symbol-
+   file-reading routines.  
+
+   They originated in dbxread.c of gdb-4.2, and were split out to
+   make xcoffread.c more maintainable by sharing code.
+
+   Variables declared in this file can be defined by #define-ing
+   the name EXTERN to null.  It is used to declare variables that
+   are normally extern, but which get defined in a single module
+   using this technique.  */
+
+#ifndef EXTERN
+#define	EXTERN	extern
+#endif
+
+extern void add_symbol_to_list ();
+extern void process_one_symbol ();
+extern struct type *read_type ();
+extern struct type *read_range_type ();
+extern struct type *read_enum_type ();
+extern struct type *read_struct_type ();
+extern struct type *read_array_type ();
+extern struct type **read_args ();
+extern struct type **dbx_lookup_type ();
+extern long read_number ();
+extern void finish_block ();
+extern struct blockvector *make_blockvector ();
+extern void add_undefined_type ();
+extern void really_free_pendings ();
+extern struct symtab *end_symtab ();
+extern void scan_file_globals ();
+extern void buildsym_new_init ();
+extern void buildsym_init ();
+
+/* Convert stab register number (from `r' declaration) to a gdb REGNUM.  */
+
+#ifndef STAB_REG_TO_REGNUM
+#define STAB_REG_TO_REGNUM(VALUE) (VALUE)
+#endif
+
+/* Name of source file whose symbol data we are now processing.
+   This comes from a symbol of type N_SO.  */
+
+EXTERN char *last_source_file;
+
+/* Core address of start of text of current source file.
+   This too comes from the N_SO symbol.  */
+
+EXTERN CORE_ADDR last_source_start_addr;
+
+/* The list of sub-source-files within the current individual compilation.
+   Each file gets its own symtab with its own linetable and associated info,
+   but they all share one blockvector.  */
+
+struct subfile
+{
+  struct subfile *next;
+  char *name;
+  char *dirname;
+  struct linetable *line_vector;
+  int line_vector_length;
+  int line_vector_index;
+  int prev_line_number;
+};
+
+EXTERN struct subfile *subfiles;
+
+EXTERN struct subfile *current_subfile;
+
+/* Global variable which, when set, indicates that we are processing a
+   .o file compiled with gcc */
+
+EXTERN unsigned char processing_gcc_compilation;
+
+/* Count symbols as they are processed, for error messages.  */
+
+EXTERN unsigned int symnum;
+
+/* Vector of types defined so far, indexed by their dbx type numbers.
+   (In newer sun systems, dbx uses a pair of numbers in parens,
+    as in "(SUBFILENUM,NUMWITHINSUBFILE)".  Then these numbers must be
+    translated through the type_translations hash table to get
+    the index into the type vector.)  */
+
+EXTERN struct type **type_vector;
+
+/* Number of elements allocated for type_vector currently.  */
+
+EXTERN int type_vector_length;
+
+/* Vector of line number information.  */
+
+EXTERN struct linetable *line_vector;
+
+/* Index of next entry to go in line_vector_index.  */
+
+EXTERN int line_vector_index;
+
+/* Last line number recorded in the line vector.  */
+
+EXTERN int prev_line_number;
+
+/* Number of elements allocated for line_vector currently.  */
+
+EXTERN int line_vector_length;
+
+/* Hash table of global symbols whose values are not known yet.
+   They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
+   have the correct data for that slot yet.  */
+/* The use of the LOC_BLOCK code in this chain is nonstandard--
+   it refers to a FORTRAN common block rather than the usual meaning.  */
+
+#define HASHSIZE 127
+EXTERN struct symbol *global_sym_chain[HASHSIZE];
+
+/* Record the symbols defined for each context in a list.
+   We don't create a struct block for the context until we
+   know how long to make it.  */
+
+#define PENDINGSIZE 100
+
+struct pending
+{
+  struct pending *next;
+  int nsyms;
+  struct symbol *symbol[PENDINGSIZE];
+};
+
+/* List of free `struct pending' structures for reuse.  */
+EXTERN struct pending *free_pendings;
+
+/* Here are the three lists that symbols are put on.  */
+
+EXTERN struct pending *file_symbols;	/* static at top level, and types */
+
+EXTERN struct pending *global_symbols;	/* global functions and variables */
+
+EXTERN struct pending *local_symbols;	/* everything local to lexical context */
+
+/* List of symbols declared since the last BCOMM.  This list is a tail
+   of local_symbols.  When ECOMM is seen, the symbols on the list
+   are noted so their proper addresses can be filled in later,
+   using the common block base address gotten from the assembler
+   stabs.  */
+
+EXTERN struct pending *common_block;
+EXTERN int common_block_i;
+
+/* Stack representing unclosed lexical contexts
+   (that will become blocks, eventually).  */
+
+struct context_stack
+{
+  struct pending *locals;
+  struct pending_block *old_blocks;
+  struct symbol *name;
+  CORE_ADDR start_addr;
+  CORE_ADDR end_addr;		/* Temp slot for exception handling. */
+  int depth;
+};
+
+EXTERN struct context_stack *context_stack;
+
+/* Index of first unused entry in context stack.  */
+EXTERN int context_stack_depth;
+
+/* Currently allocated size of context stack.  */
+
+EXTERN int context_stack_size;
+
+/* Nonzero if within a function (so symbols should be local,
+   if nothing says specifically).  */
+
+EXTERN int within_function;
+
+/* List of blocks already made (lexical contexts already closed).
+   This is used at the end to make the blockvector.  */
+
+struct pending_block
+{
+  struct pending_block *next;
+  struct block *block;
+};
+
+EXTERN struct pending_block *pending_blocks;
+
+extern CORE_ADDR startup_file_start;	/* From blockframe.c */
+extern CORE_ADDR startup_file_end;	/* From blockframe.c */
+
+/* Global variable which, when set, indicates that we are processing a
+   .o file compiled with gcc */
+
+EXTERN unsigned char processing_gcc_compilation;
+
+/* Setup a define to deal cleanly with the underscore problem */
+
+#ifdef NAMES_HAVE_UNDERSCORE
+#define HASH_OFFSET 1
+#else
+#define HASH_OFFSET 0
+#endif
+
+/* Support for Sun changes to dbx symbol format */
+
+/* For each identified header file, we have a table of types defined
+   in that header file.
+
+   header_files maps header file names to their type tables.
+   It is a vector of n_header_files elements.
+   Each element describes one header file.
+   It contains a vector of types.
+
+   Sometimes it can happen that the same header file produces
+   different results when included in different places.
+   This can result from conditionals or from different
+   things done before including the file.
+   When this happens, there are multiple entries for the file in this table,
+   one entry for each distinct set of results.
+   The entries are distinguished by the INSTANCE field.
+   The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
+   used to match header-file references to their corresponding data.  */
+
+struct header_file
+{
+  char *name;			/* Name of header file */
+  int instance;			/* Numeric code distinguishing instances
+				   of one header file that produced
+				   different results when included.
+				   It comes from the N_BINCL or N_EXCL.  */
+  struct type **vector;		/* Pointer to vector of types */
+  int length;			/* Allocated length (# elts) of that vector */
+};
+
+EXTERN struct header_file *header_files;
+
+EXTERN int n_header_files;
+
+EXTERN int n_allocated_header_files;
+
+/* Within each object file, various header files are assigned numbers.
+   A type is defined or referred to with a pair of numbers
+   (FILENUM,TYPENUM) where FILENUM is the number of the header file
+   and TYPENUM is the number within that header file.
+   TYPENUM is the index within the vector of types for that header file.
+
+   FILENUM == 1 is special; it refers to the main source of the object file,
+   and not to any header file.  FILENUM != 1 is interpreted by looking it up
+   in the following table, which contains indices in header_files.  */
+
+EXTERN int *this_object_header_files;
+
+EXTERN int n_this_object_header_files;
+
+EXTERN int n_allocated_this_object_header_files;
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 7fb59c7..822a2f4 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -55,68 +55,15 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "gdbcore.h"		/* for bfd stuff */
 #include "libaout.h"	 	/* FIXME Secret internal BFD stuff for a.out */
 #include "symfile.h"
+#include "buildsym.h"
 
 #include "aout64.h"
 #include "stab.gnu.h"		/* We always use GNU stabs, not native, now */
 
-#ifndef NO_GNU_STABS
-/*
- * Define specifically gnu symbols here.
- */
-
-/* The following type indicates the definition of a symbol as being
-   an indirect reference to another symbol.  The other symbol
-   appears as an undefined reference, immediately following this symbol.
-
-   Indirection is asymmetrical.  The other symbol's value will be used
-   to satisfy requests for the indirect symbol, but not vice versa.
-   If the other symbol does not have a definition, libraries will
-   be searched to find a definition.  */
-#ifndef N_INDR
-#define N_INDR 0xa
-#endif
-
-/* The following symbols refer to set elements.
-   All the N_SET[ATDB] symbols with the same name form one set.
-   Space is allocated for the set in the text section, and each set
-   element's value is stored into one word of the space.
-   The first word of the space is the length of the set (number of elements).
-
-   The address of the set is made into an N_SETV symbol
-   whose name is the same as the name of the set.
-   This symbol acts like a N_DATA global symbol
-   in that it can satisfy undefined external references.  */
-
-#ifndef N_SETA
-#define	N_SETA	0x14		/* Absolute set element symbol */
-#endif				/* This is input to LD, in a .o file.  */
-
-#ifndef N_SETT
-#define	N_SETT	0x16		/* Text set element symbol */
-#endif				/* This is input to LD, in a .o file.  */
-
-#ifndef N_SETD
-#define	N_SETD	0x18		/* Data set element symbol */
-#endif				/* This is input to LD, in a .o file.  */
-
-#ifndef N_SETB
-#define	N_SETB	0x1A		/* Bss set element symbol */
-#endif				/* This is input to LD, in a .o file.  */
-
-/* Macros dealing with the set element symbols defined in a.out.h */
-#define	SET_ELEMENT_P(x)	((x)>=N_SETA&&(x)<=(N_SETB|N_EXT))
-#define TYPE_OF_SET_ELEMENT(x)	((x)-N_SETA+N_ABS)
-
-#ifndef N_SETV
-#define N_SETV	0x1C		/* Pointer to set vector in data area.  */
-#endif				/* This is output from LD.  */
-
-#ifndef N_WARNING
-#define N_WARNING 0x1E		/* Warning message to print if file included */
-#endif				/* This is input to ld */
-
-#endif /* NO_GNU_STABS */
-
+/* Information is passed among various dbxread routines for accessing
+   symbol files.  A pointer to this structure is kept in the sym_private
+   field of the struct sym_fns passed in by symfile.h.  */
+ 
 struct dbx_symfile_info {
   asection *text_sect;		/* Text section accessor */
   int symcount;			/* How many symbols are there in the file */
@@ -126,6 +73,7 @@ struct dbx_symfile_info {
   int desc;			/* File descriptor of symbol file */
 };
 
+
 /* Each partial symbol table entry contains a pointer to private data for the
    read_symtab() function to use when expanding a partial symbol table entry
    to a full symbol table entry.
@@ -147,38 +95,19 @@ struct symloc {
 
 extern void qsort ();
 extern double atof ();
-extern struct cmd_list_element *cmdlist;
-
-extern void symbol_file_command ();
 
 /* Forward declarations */
 
-static void add_symbol_to_list ();
 static void read_dbx_symtab ();
 static void init_psymbol_list ();
 static void process_one_symbol ();
-static struct type *read_type ();
-static struct type *read_range_type ();
-static struct type *read_enum_type ();
-static struct type *read_struct_type ();
-static struct type *read_array_type ();
-static long read_number ();
-static void finish_block ();
-static struct blockvector *make_blockvector ();
 static struct symbol *define_symbol ();
-static void start_subfile ();
-static int hashname ();
+void start_subfile ();
+int hashname ();
 static struct pending *copy_pending ();
-static void fix_common_block ();
-static void add_undefined_type ();
-static void cleanup_undefined_types ();
-static void scan_file_globals ();
 static struct symtab *read_ofile_symtab ();
 static void dbx_psymtab_to_symtab ();
 
-/* C++ */
-static struct type **read_args ();
-
 static const char vptr_name[] = { '_','v','p','t','r',CPLUS_MARKER,'\0' };
 static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
 
@@ -194,12 +123,6 @@ static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
 #endif
 
-/* Convert stab register number (from `r' declaration) to a gdb REGNUM.  */
-
-#ifndef STAB_REG_TO_REGNUM
-#define STAB_REG_TO_REGNUM(VALUE) (VALUE)
-#endif
-
 /* Define this as 1 if a pcc declaration of a char or short argument
    gives the correct address.  Otherwise assume pcc gives the
    address of the corresponding int, which is not the same on a
@@ -208,172 +131,14 @@ static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
 #ifndef BELIEVE_PCC_PROMOTION
 #define BELIEVE_PCC_PROMOTION 0
 #endif
-
+
 /* Nonzero means give verbose info on gdb action.  From main.c.  */
 extern int info_verbose;
 
-/* Name of source file whose symbol data we are now processing.
-   This comes from a symbol of type N_SO.  */
-
-static char *last_source_file;
-
-/* Core address of start of text of current source file.
-   This too comes from the N_SO symbol.  */
-
-static CORE_ADDR last_source_start_addr;
-
-/* The entry point of a file we are reading.  */
-CORE_ADDR entry_point;
-
-/* The list of sub-source-files within the current individual compilation.
-   Each file gets its own symtab with its own linetable and associated info,
-   but they all share one blockvector.  */
-
-struct subfile
-{
-  struct subfile *next;
-  char *name;
-  char *dirname;
-  struct linetable *line_vector;
-  int line_vector_length;
-  int line_vector_index;
-  int prev_line_number;
-};
-
-static struct subfile *subfiles;
-
-static struct subfile *current_subfile;
-
-/* Count symbols as they are processed, for error messages.  */
-
-static unsigned int symnum;
-
-/* Vector of types defined so far, indexed by their dbx type numbers.
-   (In newer sun systems, dbx uses a pair of numbers in parens,
-    as in "(SUBFILENUM,NUMWITHINSUBFILE)".  Then these numbers must be
-    translated through the type_translations hash table to get
-    the index into the type vector.)  */
-
-static struct type **type_vector;
-
-/* Number of elements allocated for type_vector currently.  */
-
-static int type_vector_length;
-
-/* Vector of line number information.  */
-
-static struct linetable *line_vector;
-
-/* Index of next entry to go in line_vector_index.  */
-
-static int line_vector_index;
-
-/* Last line number recorded in the line vector.  */
-
-static int prev_line_number;
-
-/* Number of elements allocated for line_vector currently.  */
-
-static int line_vector_length;
-
-/* Hash table of global symbols whose values are not known yet.
-   They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
-   have the correct data for that slot yet.  */
-/* The use of the LOC_BLOCK code in this chain is nonstandard--
-   it refers to a FORTRAN common block rather than the usual meaning.  */
-
-#define HASHSIZE 127
-static struct symbol *global_sym_chain[HASHSIZE];
-
-/* Record the symbols defined for each context in a list.
-   We don't create a struct block for the context until we
-   know how long to make it.  */
-
-#define PENDINGSIZE 100
-
-struct pending
-{
-  struct pending *next;
-  int nsyms;
-  struct symbol *symbol[PENDINGSIZE];
-};
-
-/* List of free `struct pending' structures for reuse.  */
-struct pending *free_pendings;
-
-/* Here are the three lists that symbols are put on.  */
-
-struct pending *file_symbols;	/* static at top level, and types */
-
-struct pending *global_symbols;	/* global functions and variables */
-
-struct pending *local_symbols;	/* everything local to lexical context */
-
-/* List of symbols declared since the last BCOMM.  This list is a tail
-   of local_symbols.  When ECOMM is seen, the symbols on the list
-   are noted so their proper addresses can be filled in later,
-   using the common block base address gotten from the assembler
-   stabs.  */
-
-struct pending *common_block;
-int common_block_i;
-
-/* Stack representing unclosed lexical contexts
-   (that will become blocks, eventually).  */
-
-struct context_stack
-{
-  struct pending *locals;
-  struct pending_block *old_blocks;
-  struct symbol *name;
-  CORE_ADDR start_addr;
-  CORE_ADDR end_addr;		/* Temp slot for exception handling. */
-  int depth;
-};
-
-struct context_stack *context_stack;
-
-/* Index of first unused entry in context stack.  */
-int context_stack_depth;
-
-/* Currently allocated size of context stack.  */
-
-int context_stack_size;
-
-/* Nonzero if within a function (so symbols should be local,
-   if nothing says specifically).  */
-
-int within_function;
-
-#if 0
-/* The type of the function we are currently reading in.  This is
-   used by define_symbol to record the type of arguments to a function. */
-
-static struct type *in_function_type;
-#endif
-
-/* List of blocks already made (lexical contexts already closed).
-   This is used at the end to make the blockvector.  */
-
-struct pending_block
-{
-  struct pending_block *next;
-  struct block *block;
-};
-
-struct pending_block *pending_blocks;
-
-extern CORE_ADDR startup_file_start;	/* From blockframe.c */
-extern CORE_ADDR startup_file_end;	/* From blockframe.c */
-
-/* Global variable which, when set, indicates that we are processing a
-   .o file compiled with gcc */
-
-static unsigned char processing_gcc_compilation;
+/* The BFD for this file -- only good while we're actively reading
+   symbols into a psymtab or a symtab.  */
 
-/* Make a list of forward references which haven't been defined.  */
-static struct type **undef_types;
-static int undef_types_allocated, undef_types_length;
+static bfd *symfile_bfd;
 
 /* String table for the main symbol file.  It is kept in memory
    permanently, to speed up symbol reading.  Other files' symbol tables
@@ -388,33 +153,11 @@ static int symfile_string_table_size;
 
 static unsigned symbol_size;
 
-/* Setup a define to deal cleanly with the underscore problem */
-
-#ifdef NAMES_HAVE_UNDERSCORE
-#define HASH_OFFSET 1
-#else
-#define HASH_OFFSET 0
-#endif
-
 /* Complaints about the symbols we have encountered.  */
 
-struct complaint innerblock_complaint =
-  {"inner block not inside outer block in %s", 0, 0};
-
-struct complaint blockvector_complaint = 
-  {"block at %x out of order", 0, 0};
-
 struct complaint lbrac_complaint = 
   {"bad block start address patched", 0, 0};
 
-#if 0
-struct complaint dbx_class_complaint =
-  {"encountered DBX-style class variable debugging information.\n\
-You seem to have compiled your program with \
-\"g++ -g0\" instead of \"g++ -g\".\n\
-Therefore GDB will not know about your class variables", 0, 0};
-#endif
-
 struct complaint string_table_offset_complaint =
   {"bad string table offset in symbol %d", 0, 0};
 
@@ -423,56 +166,7 @@ struct complaint unknown_symtype_complaint =
 
 struct complaint lbrac_rbrac_complaint =
   {"block start larger than block end", 0, 0};
-
-struct complaint const_vol_complaint =
-  {"const/volatile indicator missing (ok if using g++ v1.x), got '%c'", 0, 0};
-
-struct complaint error_type_complaint =
-  {"debug info mismatch between compiler and debugger", 0, 0};
-
-struct complaint invalid_member_complaint =
-  {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
-
-struct complaint range_type_base_complaint =
-  {"base type %d of range type is not defined", 0, 0};
 
-/* Support for Sun changes to dbx symbol format */
-
-/* For each identified header file, we have a table of types defined
-   in that header file.
-
-   header_files maps header file names to their type tables.
-   It is a vector of n_header_files elements.
-   Each element describes one header file.
-   It contains a vector of types.
-
-   Sometimes it can happen that the same header file produces
-   different results when included in different places.
-   This can result from conditionals or from different
-   things done before including the file.
-   When this happens, there are multiple entries for the file in this table,
-   one entry for each distinct set of results.
-   The entries are distinguished by the INSTANCE field.
-   The INSTANCE field appears in the N_BINCL and N_EXCL symbol table and is
-   used to match header-file references to their corresponding data.  */
-
-struct header_file
-{
-  char *name;			/* Name of header file */
-  int instance;			/* Numeric code distinguishing instances
-				   of one header file that produced
-				   different results when included.
-				   It comes from the N_BINCL or N_EXCL.  */
-  struct type **vector;		/* Pointer to vector of types */
-  int length;			/* Allocated length (# elts) of that vector */
-};
-
-static struct header_file *header_files = 0;
-
-static int n_header_files;
-
-static int n_allocated_header_files;
-
 /* During initial symbol readin, we need to have a structure to keep
    track of which psymtabs have which bincls in them.  This structure
    is used during readin to setup the list of dependencies within each
@@ -490,22 +184,6 @@ struct header_file_location
 static struct header_file_location *bincl_list, *next_bincl;
 static int bincls_allocated;
 
-/* Within each object file, various header files are assigned numbers.
-   A type is defined or referred to with a pair of numbers
-   (FILENUM,TYPENUM) where FILENUM is the number of the header file
-   and TYPENUM is the number within that header file.
-   TYPENUM is the index within the vector of types for that header file.
-
-   FILENUM == 1 is special; it refers to the main source of the object file,
-   and not to any header file.  FILENUM != 1 is interpreted by looking it up
-   in the following table, which contains indices in header_files.  */
-
-static int *this_object_header_files = 0;
-
-static int n_this_object_header_files;
-
-static int n_allocated_this_object_header_files;
-
 /* When a header file is getting special overriding definitions
    for one source file, record here the header_files index
    of its normal definition vector.
@@ -516,7 +194,7 @@ static int header_file_prev_index;
 /* Free up old header file tables, and allocate new ones.
    We're reading a new symbol file now.  */
 
-static void
+void
 free_and_init_header_files ()
 {
   register int i;
@@ -538,7 +216,7 @@ free_and_init_header_files ()
 /* Called at the start of each object file's symbols.
    Clear out the mapping of header file numbers to header files.  */
 
-static void
+void
 new_object_header_files ()
 {
   /* Leave FILENUM of 0 free for builtin types and this file's types.  */
@@ -630,115 +308,6 @@ add_new_header_file (name, instance)
   add_this_object_header_file (i);
 }
 
-/* Look up a dbx type-number pair.  Return the address of the slot
-   where the type for that number-pair is stored.
-   The number-pair is in TYPENUMS.
-
-   This can be used for finding the type associated with that pair
-   or for associating a new type with the pair.  */
-
-static struct type **
-dbx_lookup_type (typenums)
-     int typenums[2];
-{
-  register int filenum = typenums[0], index = typenums[1];
-
-  if (filenum < 0 || filenum >= n_this_object_header_files)
-    error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
-	   filenum, index, symnum);
-
-  if (filenum == 0)
-    {
-      /* Type is defined outside of header files.
-	 Find it in this object file's type vector.  */
-      while (index >= type_vector_length)
-	{
-	  type_vector_length *= 2;
-	  type_vector = (struct type **)
-	    xrealloc (type_vector,
-		      (type_vector_length * sizeof (struct type *)));
-	  bzero (&type_vector[type_vector_length / 2],
-		 type_vector_length * sizeof (struct type *) / 2);
-	}
-      return &type_vector[index];
-    }
-  else
-    {
-      register int real_filenum = this_object_header_files[filenum];
-      register struct header_file *f;
-      int f_orig_length;
-
-      if (real_filenum >= n_header_files)
-	abort ();
-
-      f = &header_files[real_filenum];
-
-      f_orig_length = f->length;
-      if (index >= f_orig_length)
-	{
-	  while (index >= f->length)
-	    f->length *= 2;
-	  f->vector = (struct type **)
-	    xrealloc (f->vector, f->length * sizeof (struct type *));
-	  bzero (&f->vector[f_orig_length],
-		 (f->length - f_orig_length) * sizeof (struct type *));
-	}
-      return &f->vector[index];
-    }
-}
-
-/* Create a type object.  Occaisionally used when you need a type
-   which isn't going to be given a type number.  */
-
-static struct type *
-dbx_create_type ()
-{
-  register struct type *type =
-    (struct type *) obstack_alloc (symbol_obstack, sizeof (struct type));
-
-  bzero (type, sizeof (struct type));
-  TYPE_VPTR_FIELDNO (type) = -1;
-  TYPE_VPTR_BASETYPE (type) = 0;
-  return type;
-}
-
-/* Make sure there is a type allocated for type numbers TYPENUMS
-   and return the type object.
-   This can create an empty (zeroed) type object.
-   TYPENUMS may be (-1, -1) to return a new type object that is not
-   put into the type vector, and so may not be referred to by number. */
-
-static struct type *
-dbx_alloc_type (typenums)
-     int typenums[2];
-{
-  register struct type **type_addr;
-  register struct type *type;
-
-  if (typenums[1] != -1)
-    {
-      type_addr = dbx_lookup_type (typenums);
-      type = *type_addr;
-    }
-  else
-    {
-      type_addr = 0;
-      type = 0;
-    }
-
-  /* If we are referring to a type not known at all yet,
-     allocate an empty type for it.
-     We will fill it in later if we find out how.  */
-  if (type == 0)
-    {
-      type = dbx_create_type ();
-      if (type_addr)
-	*type_addr = type;
-    }
-  
-  return type;
-}
-
 #if 0
 static struct type **
 explicit_lookup_type (real_filenum, index)
@@ -758,315 +327,11 @@ explicit_lookup_type (real_filenum, index)
 }
 #endif
 
-/* maintain the lists of symbols and blocks */
-
-/* Add a symbol to one of the lists of symbols.  */
-static void
-add_symbol_to_list (symbol, listhead)
-     struct symbol *symbol;
-     struct pending **listhead;
-{
-  /* We keep PENDINGSIZE symbols in each link of the list.
-     If we don't have a link with room in it, add a new link.  */
-  if (*listhead == 0 || (*listhead)->nsyms == PENDINGSIZE)
-    {
-      register struct pending *link;
-      if (free_pendings)
-	{
-	  link = free_pendings;
-	  free_pendings = link->next;
-	}
-      else
-	link = (struct pending *) xmalloc (sizeof (struct pending));
-
-      link->next = *listhead;
-      *listhead = link;
-      link->nsyms = 0;
-    }
-
-  (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
-}
-
-/* At end of reading syms, or in case of quit,
-   really free as many `struct pending's as we can easily find.  */
-
-/* ARGSUSED */
-static void
-really_free_pendings (foo)
-     int foo;
-{
-  struct pending *next, *next1;
-#if 0
-  struct pending_block *bnext, *bnext1;
-#endif
-
-  for (next = free_pendings; next; next = next1)
-    {
-      next1 = next->next;
-      free (next);
-    }
-  free_pendings = 0;
-
-#if 0 /* Now we make the links in the symbol_obstack, so don't free them.  */
-  for (bnext = pending_blocks; bnext; bnext = bnext1)
-    {
-      bnext1 = bnext->next;
-      free (bnext);
-    }
-#endif
-  pending_blocks = 0;
-
-  for (next = file_symbols; next; next = next1)
-    {
-      next1 = next->next;
-      free (next);
-    }
-  file_symbols = 0;
-
-  for (next = global_symbols; next; next = next1)
-    {
-      next1 = next->next;
-      free (next);
-    }
-  global_symbols = 0;
-}
-
-/* Take one of the lists of symbols and make a block from it.
-   Keep the order the symbols have in the list (reversed from the input file).
-   Put the block on the list of pending blocks.  */
-
-static void
-finish_block (symbol, listhead, old_blocks, start, end)
-     struct symbol *symbol;
-     struct pending **listhead;
-     struct pending_block *old_blocks;
-     CORE_ADDR start, end;
-{
-  register struct pending *next, *next1;
-  register struct block *block;
-  register struct pending_block *pblock;
-  struct pending_block *opblock;
-  register int i;
-
-  /* Count the length of the list of symbols.  */
-
-  for (next = *listhead, i = 0; next; i += next->nsyms, next = next->next)
-    /*EMPTY*/;
-
-  block = (struct block *) obstack_alloc (symbol_obstack,
-					  (sizeof (struct block)
-					   + ((i - 1)
-					      * sizeof (struct symbol *))));
-
-  /* Copy the symbols into the block.  */
-
-  BLOCK_NSYMS (block) = i;
-  for (next = *listhead; next; next = next->next)
-    {
-      register int j;
-      for (j = next->nsyms - 1; j >= 0; j--)
-	BLOCK_SYM (block, --i) = next->symbol[j];
-    }
-
-  BLOCK_START (block) = start;
-  BLOCK_END (block) = end;
-  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
-  BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
-
-  /* Put the block in as the value of the symbol that names it.  */
-
-  if (symbol)
-    {
-      SYMBOL_BLOCK_VALUE (symbol) = block;
-      BLOCK_FUNCTION (block) = symbol;
-    }
-  else
-    BLOCK_FUNCTION (block) = 0;
-
-  /* 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;
-    }
-  *listhead = 0;
-
-  /* Install this block as the superblock
-     of all blocks made since the start of this scope
-     that don't have superblocks yet.  */
-
-  opblock = 0;
-  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
-    {
-      if (BLOCK_SUPERBLOCK (pblock->block) == 0) {
-#if 1
-	/* Check to be sure the blocks are nested as we receive them. 
-	   If the compiler/assembler/linker work, this just burns a small
-	   amount of time.  */
-	if (BLOCK_START (pblock->block) < BLOCK_START (block)
-	 || BLOCK_END   (pblock->block) > BLOCK_END   (block)) {
-	  complain(&innerblock_complaint, symbol? SYMBOL_NAME (symbol):
-						 "(don't know)");
-	  BLOCK_START (pblock->block) = BLOCK_START (block);
-	  BLOCK_END   (pblock->block) = BLOCK_END   (block);
-	}
-#endif
-	BLOCK_SUPERBLOCK (pblock->block) = block;
-      }
-      opblock = pblock;
-    }
-
-  /* Record this block on the list of all blocks in the file.
-     Put it after opblock, or at the beginning if opblock is 0.
-     This puts the block in the list after all its subblocks.  */
-
-  /* Allocate in the symbol_obstack to save time.
-     It wastes a little space.  */
-  pblock = (struct pending_block *)
-    obstack_alloc (symbol_obstack,
-		   sizeof (struct pending_block));
-  pblock->block = block;
-  if (opblock)
-    {
-      pblock->next = opblock->next;
-      opblock->next = pblock;
-    }
-  else
-    {
-      pblock->next = pending_blocks;
-      pending_blocks = pblock;
-    }
-}
-
-static struct blockvector *
-make_blockvector ()
-{
-  register struct pending_block *next;
-  register struct blockvector *blockvector;
-  register int i;
-
-  /* Count the length of the list of blocks.  */
-
-  for (next = pending_blocks, i = 0; next; next = next->next, i++);
-
-  blockvector = (struct blockvector *)
-    obstack_alloc (symbol_obstack,
-		   (sizeof (struct blockvector)
-		    + (i - 1) * sizeof (struct block *)));
-
-  /* Copy the blocks into the blockvector.
-     This is done in reverse order, which happens to put
-     the blocks into the proper order (ascending starting address).
-     finish_block has hair to insert each block into the list
-     after its subblocks in order to make sure this is true.  */
-
-  BLOCKVECTOR_NBLOCKS (blockvector) = i;
-  for (next = pending_blocks; next; next = next->next) {
-    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
-  }
-
-#if 0 /* Now we make the links in the obstack, so don't free them.  */
-  /* Now free the links of the list, and empty the list.  */
-
-  for (next = pending_blocks; next; next = next1)
-    {
-      next1 = next->next;
-      free (next);
-    }
-#endif
-  pending_blocks = 0;
-
-#if 1  /* FIXME, shut this off after a while to speed up symbol reading.  */
-  /* Some compilers output blocks in the wrong order, but we depend
-     on their being in the right order so we can binary search. 
-     Check the order and moan about it.  FIXME.  */
-  if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
-    for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) {
-      if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
-	  > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))) {
-	complain (&blockvector_complaint, 
-	  BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
-      }
-    }
-#endif
-
-  return blockvector;
-}
-
-/* Manage the vector of line numbers.  */
-
-static void
-record_line (line, pc)
-     int line;
-     CORE_ADDR pc;
-{
-  struct linetable_entry *e;
-  /* Ignore the dummy line number in libg.o */
-
-  if (line == 0xffff)
-    return;
-
-  /* Make sure line vector is big enough.  */
-
-  if (line_vector_index + 1 >= line_vector_length)
-    {
-      line_vector_length *= 2;
-      line_vector = (struct linetable *)
-	xrealloc (line_vector,
-		  (sizeof (struct linetable)
-		   + line_vector_length * sizeof (struct linetable_entry)));
-      current_subfile->line_vector = line_vector;
-    }
-
-  e = line_vector->item + line_vector_index++;
-  e->line = line; e->pc = pc;
-}
-
-/* Start a new symtab for a new source file.
-   This is called when a dbx symbol of type N_SO is seen;
-   it indicates the start of data for one original source file.  */
-
-static void
-start_symtab (name, dirname, start_addr)
-     char *name;
-     char *dirname;
-     CORE_ADDR start_addr;
-{
-
-  last_source_file = name;
-  last_source_start_addr = start_addr;
-  file_symbols = 0;
-  global_symbols = 0;
-  within_function = 0;
-
-  /* Context stack is initially empty, with room for 10 levels.  */
-  context_stack
-    = (struct context_stack *) xmalloc (10 * sizeof (struct context_stack));
-  context_stack_size = 10;
-  context_stack_depth = 0;
-
-  new_object_header_files ();
-
-  type_vector_length = 160;
-  type_vector = (struct type **)
-    xmalloc (type_vector_length * sizeof (struct type *));
-  bzero (type_vector, type_vector_length * sizeof (struct type *));
-
-  /* Initialize the list of sub source files with one entry
-     for this file (the top-level source file).  */
-
-  subfiles = 0;
-  current_subfile = 0;
-  start_subfile (name, dirname);
-}
-
 /* Handle an N_SOL symbol, which indicates the start of
    code that came from an included (or otherwise merged-in)
    source file with a different name.  */
 
-static void
+void
 start_subfile (name, dirname)
      char *name;
      char *dirname;
@@ -1122,91 +387,6 @@ start_subfile (name, dirname)
   subfiles = subfile;
   current_subfile = subfile;
 }
-
-/* Finish the symbol definitions for one main source file,
-   close off all the lexical contexts for that file
-   (creating struct block's for them), then make the struct symtab
-   for that file and put it in the list of all such.
-
-   END_ADDR is the address of the end of the file's text.  */
-
-static struct symtab *
-end_symtab (end_addr)
-     CORE_ADDR end_addr;
-{
-  register struct symtab *symtab;
-  register struct blockvector *blockvector;
-  register struct subfile *subfile;
-  register struct linetable *lv;
-  struct subfile *nextsub;
-
-  /* Finish the lexical context of the last function in the file;
-     pop the context stack.  */
-
-  if (context_stack_depth > 0)
-    {
-      register struct context_stack *cstk;
-      context_stack_depth--;
-      cstk = &context_stack[context_stack_depth];
-      /* Make a block for the local symbols within.  */
-      finish_block (cstk->name, &local_symbols, cstk->old_blocks,
-		    cstk->start_addr, end_addr);
-    }
-
-  /* Cleanup any undefined types that have been left hanging around
-     (this needs to be done before the finish_blocks so that
-     file_symbols is still good).  */
-  cleanup_undefined_types ();
-
-  /* Define the STATIC_BLOCK and GLOBAL_BLOCK, and build the blockvector.  */
-  finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
-  finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
-  blockvector = make_blockvector ();
-
-  current_subfile->line_vector_index = line_vector_index;
-
-  /* Now create the symtab objects proper, one for each subfile.  */
-  /* (The main file is the last one on the chain.)  */
-
-  for (subfile = subfiles; subfile; subfile = nextsub)
-    {
-      symtab = allocate_symtab (subfile->name);
-
-      /* Fill in its components.  */
-      symtab->blockvector = blockvector;
-      lv = subfile->line_vector;
-      lv->nitems = subfile->line_vector_index;
-      symtab->linetable = (struct linetable *)
-	xrealloc (lv, (sizeof (struct linetable)
-		       + lv->nitems * sizeof (struct linetable_entry)));
-
-      symtab->dirname = subfile->dirname;
-
-      symtab->free_code = free_linetable;
-      symtab->free_ptr = 0;
-
-      /* There should never already be a symtab for this name, since
-	 any prev dups have been removed when the psymtab was read in.
-  	 FIXME, there ought to be a way to check this here.  */
-      /* FIXME blewit |= free_named_symtabs (symtab->filename);  */
-
-      /* Link the new symtab into the list of such.  */
-      symtab->next = symtab_list;
-      symtab_list = symtab;
-
-      nextsub = subfile->next;
-      free (subfile);
-    }
-
-  free ((char *) type_vector);
-  type_vector = 0;
-  type_vector_length = -1;
-  line_vector = 0;
-  line_vector_length = -1;
-  last_source_file = 0;
-
-  return symtab;
-}
 
 /* Handle the N_BINCL and N_EINCL symbol types
    that act like N_SOL for switching source files
@@ -1276,11 +456,6 @@ record_misc_function (name, address, type)
 			     address, misc_type);
 }
 
-/* The BFD for this file -- only good while we're actively reading
-   symbols into a psymtab or a symtab.  */
-
-static bfd *symfile_bfd;
-
 /* Scan and build partial symbols for a symbol file.
    We have been initialized by a call to dbx_symfile_init, which 
    put all the relevant info into a "struct dbx_symfile_info"
@@ -1364,12 +539,7 @@ dbx_symfile_read (sf, addr, mainline)
 static void
 dbx_new_init ()
 {
-  /* Empty the hash table of global syms looking for values.  */
-  bzero (global_sym_chain, sizeof global_sym_chain);
-
-  free_pendings = 0;
-  file_symbols = 0;
-  global_symbols = 0;
+  buildsym_new_init ();
 
   /* Don't put these on the cleanup chain; they need to stick around
      until the next call to dbx_new_init.  *Then* we'll free them. */
@@ -1409,7 +579,7 @@ dbx_symfile_init (sf)
   unsigned char size_temp[4];
 
   /* Allocate struct to keep track of the symfile */
-  sf->sym_private = xmalloc (sizeof (*info));   /* FIXME storage leak */
+  sf->sym_private = xmalloc (sizeof (*info));
   info = (struct dbx_symfile_info *)sf->sym_private;
 
   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
@@ -1513,7 +683,7 @@ fill_symbuf ()
    (a \ at the end of the text of a name)
    call this function to get the continuation.  */
 
-static char *
+char *
 next_symbol_text ()
 {
   if (symbuf_idx == symbuf_end)
@@ -2592,10 +1762,7 @@ psymtab_to_symtab_1 (pst, desc, stringtab, stringtab_size, sym_offset)
   if (LDSYMLEN(pst))		/* Otherwise it's a dummy */
     {
       /* Init stuff necessary for reading in symbols */
-      free_pendings = 0;
-      pending_blocks = 0;
-      file_symbols = 0;
-      global_symbols = 0;
+      buildsym_init ();
       old_chain = make_cleanup (really_free_pendings, 0);
 
       /* Read in this files symbols */
@@ -2736,65 +1903,6 @@ dbx_psymtab_to_symtab (pst)
     }
 }
 
-/*
- * Scan through all of the global symbols defined in the object file,
- * assigning values to the debugging symbols that need to be assigned
- * to.  Get these symbols from the misc function list.
- */
-static void
-scan_file_globals ()
-{
-  int hash;
-  int mf;
-
-  for (mf = 0; mf < misc_function_count; mf++)
-    {
-      char *namestring = misc_function_vector[mf].name;
-      struct symbol *sym, *prev;
-
-      QUIT;
-
-      prev = (struct symbol *) 0;
-
-      /* Get the hash index and check all the symbols
-	 under that hash index. */
-
-      hash = hashname (namestring);
-
-      for (sym = global_sym_chain[hash]; sym;)
-	{
-	  if (*namestring == SYMBOL_NAME (sym)[0]
-	      && !strcmp(namestring + 1, SYMBOL_NAME (sym) + 1))
-	    {
-	      /* Splice this symbol out of the hash chain and
-		 assign the value we have to it. */
-	      if (prev)
-		SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
-	      else
-		global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
-	      
-	      /* Check to see whether we need to fix up a common block.  */
-	      /* Note: this code might be executed several times for
-		 the same symbol if there are multiple references.  */
-	      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
-		fix_common_block (sym, misc_function_vector[mf].address);
-	      else
-		SYMBOL_VALUE_ADDRESS (sym) = misc_function_vector[mf].address;
-	      
-	      if (prev)
-		sym = SYMBOL_VALUE_CHAIN (prev);
-	      else
-		sym = global_sym_chain[hash];
-	    }
-	  else
-	    {
-	      prev = sym;
-	      sym = SYMBOL_VALUE_CHAIN (sym);
-	    }
-	}
-    }
-}
-
 /* Process a pair of symbols.  Currently they must both be N_SO's.  */
 /* ARGSUSED */
 static void
@@ -2902,17 +2010,20 @@ read_ofile_symtab (desc, stringtab, stringtab_size, sym_offset,
       bufp = &symbuf[symbuf_idx++];
       SWAP_SYMBOL (bufp);
 
-      type = bufp->n_type & N_TYPE;
+      type = bufp->n_type;
       if (type == (unsigned char)N_CATCH)
 	{
 	  /* N_CATCH is not fixed up by the linker, and unfortunately,
 	     there's no other place to put it in the .stab map.  */
 	  bufp->n_value += text_offset + offset;
 	}
-      else if (type == N_TEXT || type == N_DATA || type == N_BSS)
-	bufp->n_value += offset;
+      else {
+        type &= ~N_EXT;		/* Ignore external-bit */
+        if (type == N_TEXT || type == N_DATA || type == N_BSS)
+	  bufp->n_value += offset;
+        type = bufp->n_type;
+      }
 
-      type = bufp->n_type;
       SET_NAMESTRING ();
 
       if (type & N_STAB)
@@ -2975,7 +2086,7 @@ read_ofile_symtab (desc, stringtab, stringtab_size, sym_offset,
   return end_symtab (text_offset + text_size);
 }
 
-static int
+int
 hashname (name)
      char *name;
 {
@@ -3276,30 +2387,6 @@ process_one_symbol (type, desc, valu, name)
     }
 }
 
-/* Read a number by which a type is referred to in dbx data,
-   or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
-   Just a single number N is equivalent to (0,N).
-   Return the two numbers by storing them in the vector TYPENUMS.
-   TYPENUMS will then be used as an argument to dbx_lookup_type.  */
-
-static void
-read_type_number (pp, typenums)
-     register char **pp;
-     register int *typenums;
-{
-  if (**pp == '(')
-    {
-      (*pp)++;
-      typenums[0] = read_number (pp, ',');
-      typenums[1] = read_number (pp, ')');
-    }
-  else
-    {
-      typenums[0] = 0;
-      typenums[1] = read_number (pp, 0);
-    }
-}
-
 /* To handle GNU C++ typename abbreviation, we need to be able to
    fill in a type's name as soon as space for that type is allocated.
    `type_synonym_name' is the name of the type being allocated.
@@ -3723,421 +2810,6 @@ define_symbol (valu, string, desc, type)
   return sym;
 }
 
-/* What about types defined as forward references inside of a small lexical
-   scope?  */
-/* Add a type to the list of undefined types to be checked through
-   once this file has been read in.  */
-static void
-add_undefined_type (type)
-     struct type *type;
-{
-  if (undef_types_length == undef_types_allocated)
-    {
-      undef_types_allocated *= 2;
-      undef_types = (struct type **)
-	xrealloc (undef_types,
-		  undef_types_allocated * sizeof (struct type *));
-    }
-  undef_types[undef_types_length++] = type;
-}
-
-/* Add here something to go through each undefined type, see if it's
-   still undefined, and do a full lookup if so.  */
-static void
-cleanup_undefined_types ()
-{
-  struct type **type;
-
-  for (type = undef_types; type < undef_types + undef_types_length; type++)
-    {
-      /* Reasonable test to see if it's been defined since.  */
-      if (TYPE_NFIELDS (*type) == 0)
-	{
-	  struct pending *ppt;
-	  int i;
-	  /* Name of the type, without "struct" or "union" */
-	  char *typename = TYPE_NAME (*type);
-
-	  if (!strncmp (typename, "struct ", 7))
-	    typename += 7;
-	  if (!strncmp (typename, "union ", 6))
-	    typename += 6;
-
-	  for (ppt = file_symbols; ppt; ppt = ppt->next)
-	    for (i = 0; i < ppt->nsyms; i++)
-	      {
-		struct symbol *sym = ppt->symbol[i];
-
-		if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
-		    && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
-		    && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
-			TYPE_CODE (*type))
-		    && !strcmp (SYMBOL_NAME (sym), typename))
-		  bcopy (SYMBOL_TYPE (sym), *type, sizeof (struct type));
-	      }
-	}
-      else
-	/* It has been defined; don't mark it as a stub.  */
-	TYPE_FLAGS (*type) &= ~TYPE_FLAG_STUB;
-    }
-  undef_types_length = 0;
-}
-
-/* Skip rest of this symbol and return an error type.
-
-   General notes on error recovery:  error_type always skips to the
-   end of the symbol (modulo cretinous dbx symbol name continuation).
-   Thus code like this:
-
-   if (*(*pp)++ != ';')
-     return error_type (pp);
-
-   is wrong because if *pp starts out pointing at '\0' (typically as the
-   result of an earlier error), it will be incremented to point to the
-   start of the next symbol, which might produce strange results, at least
-   if you run off the end of the string table.  Instead use
-
-   if (**pp != ';')
-     return error_type (pp);
-   ++*pp;
-
-   or
-
-   if (**pp != ';')
-     foo = error_type (pp);
-   else
-     ++*pp;
-
-   And in case it isn't obvious, the point of all this hair is so the compiler
-   can define new types and new syntaxes, and old versions of the
-   debugger will be able to read the new symbol tables.  */
-
-static struct type *
-error_type (pp)
-     char **pp;
-{
-  complain (&error_type_complaint, 0);
-  while (1)
-    {
-      /* Skip to end of symbol.  */
-      while (**pp != '\0')
-	(*pp)++;
-
-      /* Check for and handle cretinous dbx symbol name continuation!  */
-      if ((*pp)[-1] == '\\')
-	*pp = next_symbol_text ();
-      else
-	break;
-    }
-  return builtin_type_error;
-}
-
-/* Read a dbx type reference or definition;
-   return the type that is meant.
-   This can be just a number, in which case it references
-   a type already defined and placed in type_vector.
-   Or the number can be followed by an =, in which case
-   it means to define a new type according to the text that
-   follows the =.  */
-
-static
-struct type *
-read_type (pp)
-     register char **pp;
-{
-  register struct type *type = 0;
-  struct type *type1;
-  int typenums[2];
-  int xtypenums[2];
-
-  /* Read type number if present.  The type number may be omitted.
-     for instance in a two-dimensional array declared with type
-     "ar1;1;10;ar1;1;10;4".  */
-  if ((**pp >= '0' && **pp <= '9')
-      || **pp == '(')
-    {
-      read_type_number (pp, typenums);
-      
-      /* Detect random reference to type not yet defined.
-	 Allocate a type object but leave it zeroed.  */
-      if (**pp != '=')
-	return dbx_alloc_type (typenums);
-
-      *pp += 2;
-    }
-  else
-    {
-      /* 'typenums=' not present, type is anonymous.  Read and return
-	 the definition, but don't put it in the type vector.  */
-      typenums[0] = typenums[1] = -1;
-      *pp += 1;
-    }
-      
-  switch ((*pp)[-1])
-    {
-    case 'x':
-      {
-	enum type_code code;
-
-	/* Used to index through file_symbols.  */
-	struct pending *ppt;
-	int i;
-	
-	/* Name including "struct", etc.  */
-	char *type_name;
-	
-	/* Name without "struct", etc.  */
-	char *type_name_only;
-
-	{
-	  char *prefix;
-	  char *from, *to;
-	  
-	  /* Set the type code according to the following letter.  */
-	  switch ((*pp)[0])
-	    {
-	    case 's':
-	      code = TYPE_CODE_STRUCT;
-	      prefix = "struct ";
-	      break;
-	    case 'u':
-	      code = TYPE_CODE_UNION;
-	      prefix = "union ";
-	      break;
-	    case 'e':
-	      code = TYPE_CODE_ENUM;
-	      prefix = "enum ";
-	      break;
-	    default:
-	      return error_type (pp);
-	    }
-	  
-	  to = type_name = (char *)
-	    obstack_alloc (symbol_obstack,
-			   (strlen (prefix) +
-			    ((char *) strchr (*pp, ':') - (*pp)) + 1));
-	
-	  /* Copy the prefix.  */
-	  from = prefix;
-	  while (*to++ = *from++)
-	    ;
-	  to--; 
-	
-	  type_name_only = to;
-
-	  /* Copy the name.  */
-	  from = *pp + 1;
-	  while ((*to++ = *from++) != ':')
-	    ;
-	  *--to = '\0';
-	  
-	  /* Set the pointer ahead of the name which we just read.  */
-	  *pp = from;
-	
-#if 0
-	  /* The following hack is clearly wrong, because it doesn't
-	     check whether we are in a baseclass.  I tried to reproduce
-	     the case that it is trying to fix, but I couldn't get
-	     g++ to put out a cross reference to a basetype.  Perhaps
-	     it doesn't do it anymore.  */
-	  /* Note: for C++, the cross reference may be to a base type which
-	     has not yet been seen.  In this case, we skip to the comma,
-	     which will mark the end of the base class name.  (The ':'
-	     at the end of the base class name will be skipped as well.)
-	     But sometimes (ie. when the cross ref is the last thing on
-	     the line) there will be no ','.  */
-	  from = (char *) strchr (*pp, ',');
-	  if (from)
-	    *pp = from;
-#endif /* 0 */
-	}
-
-	/* Now check to see whether the type has already been declared.  */
-	/* This is necessary at least in the case where the
-	   program says something like
-	     struct foo bar[5];
-	   The compiler puts out a cross-reference; we better find
-	   set the length of the structure correctly so we can
-	   set the length of the array.  */
-	for (ppt = file_symbols; ppt; ppt = ppt->next)
-	  for (i = 0; i < ppt->nsyms; i++)
-	    {
-	      struct symbol *sym = ppt->symbol[i];
-
-	      if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
-		  && SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE
-		  && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
-		  && !strcmp (SYMBOL_NAME (sym), type_name_only))
-		{
-		  obstack_free (symbol_obstack, type_name);
-		  type = SYMBOL_TYPE (sym);
-		  return type;
-		}
-	    }
-	
-	/* Didn't find the type to which this refers, so we must
-	   be dealing with a forward reference.  Allocate a type
-	   structure for it, and keep track of it so we can
-	   fill in the rest of the fields when we get the full
-	   type.  */
-	type = dbx_alloc_type (typenums);
-	TYPE_CODE (type) = code;
-	TYPE_NAME (type) = type_name;
-
-	TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
-
-	add_undefined_type (type);
-	return type;
-      }
-
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '(':
-      (*pp)--;
-      read_type_number (pp, xtypenums);
-      type = *dbx_lookup_type (xtypenums);
-      if (type == 0)
-	type = builtin_type_void;
-      if (typenums[0] != -1)
-	*dbx_lookup_type (typenums) = type;
-      break;
-
-    case '*':
-      type1 = read_type (pp);
-      type = lookup_pointer_type (type1);
-      if (typenums[0] != -1)
-	*dbx_lookup_type (typenums) = type;
-      break;
-
-    case '@':
-      {
-	struct type *domain = read_type (pp);
-	struct type *memtype;
-
-	if (**pp != ',')
-	  /* Invalid member type data format.  */
-	  return error_type (pp);
-	++*pp;
-
-	memtype = read_type (pp);
-	type = dbx_alloc_type (typenums);
-	smash_to_member_type (type, domain, memtype);
-      }
-      break;
-
-    case '#':
-      if ((*pp)[0] == '#')
-	{
-	  /* We'll get the parameter types from the name.  */
-	  struct type *return_type;
-
-	  *pp += 1;
-	  return_type = read_type (pp);
-	  if (*(*pp)++ != ';')
-	    complain (&invalid_member_complaint, symnum);
-	  type = allocate_stub_method (return_type);
-	  if (typenums[0] != -1)
-	    *dbx_lookup_type (typenums) = type;
-	}
-      else
-	{
-	  struct type *domain = read_type (pp);
-	  struct type *return_type;
-	  struct type **args;
-
-	  if (*(*pp)++ != ',')
-	    error ("invalid member type data format, at symtab pos %d.",
-		   symnum);
-
-	  return_type = read_type (pp);
-	  args = read_args (pp, ';');
-	  type = dbx_alloc_type (typenums);
-	  smash_to_method_type (type, domain, return_type, args);
-	}
-      break;
-
-    case '&':
-      type1 = read_type (pp);
-      type = lookup_reference_type (type1);
-      if (typenums[0] != -1)
-	*dbx_lookup_type (typenums) = type;
-      break;
-
-    case 'f':
-      type1 = read_type (pp);
-      type = lookup_function_type (type1);
-      if (typenums[0] != -1)
-	*dbx_lookup_type (typenums) = type;
-      break;
-
-    case 'r':
-      type = read_range_type (pp, typenums);
-      if (typenums[0] != -1)
-	*dbx_lookup_type (typenums) = type;
-      break;
-
-    case 'e':
-      type = dbx_alloc_type (typenums);
-      type = read_enum_type (pp, type);
-      *dbx_lookup_type (typenums) = type;
-      break;
-
-    case 's':
-      type = dbx_alloc_type (typenums);
-      TYPE_NAME (type) = type_synonym_name;
-      type_synonym_name = 0;
-      type = read_struct_type (pp, type);
-      break;
-
-    case 'u':
-      type = dbx_alloc_type (typenums);
-      TYPE_NAME (type) = type_synonym_name;
-      type_synonym_name = 0;
-      type = read_struct_type (pp, type);
-      TYPE_CODE (type) = TYPE_CODE_UNION;
-      break;
-
-    case 'a':
-      if (**pp != 'r')
-	return error_type (pp);
-      ++*pp;
-      
-      type = dbx_alloc_type (typenums);
-      type = read_array_type (pp, type);
-      break;
-
-    default:
-      --*pp;			/* Go back to the symbol in error */
-				/* Particularly important if it was \0! */
-      return error_type (pp);
-    }
-
-  if (type == 0)
-    abort ();
-
-#if 0
-  /* If this is an overriding temporary alteration for a header file's
-     contents, and this type number is unknown in the global definition,
-     put this type into the global definition at this type number.  */
-  if (header_file_prev_index >= 0)
-    {
-      register struct type **tp
-        = explicit_lookup_type (header_file_prev_index, typenums[1]);
-      if (*tp == 0)
-	*tp = type;
-    }
-#endif
-  return type;
-}
-
 #if 0
 /* This would be a good idea, but it doesn't really work.  The problem
    is that in order to get the virtual context for a particular type,
@@ -4195,1223 +2867,6 @@ virtual_context (for_type, type, name, fn_type, offset)
   return for_type;
 }
 #endif
-
-/* Read the description of a structure (or union type)
-   and return an object describing the type.  */
-
-static struct type *
-read_struct_type (pp, type)
-     char **pp;
-     register struct type *type;
-{
-  /* Total number of methods defined in this class.
-     If the class defines two `f' methods, and one `g' method,
-     then this will have the value 3.  */
-  int total_length = 0;
-
-  struct nextfield
-    {
-      struct nextfield *next;
-      int visibility;			/* 0=public, 1=protected, 2=public */
-      struct field field;
-    };
-
-  struct next_fnfield
-    {
-      struct next_fnfield *next;
-      int visibility;			/* 0=public, 1=protected, 2=public */
-      struct fn_field fn_field;
-    };
-
-  struct next_fnfieldlist
-    {
-      struct next_fnfieldlist *next;
-      struct fn_fieldlist fn_fieldlist;
-    };
-
-  register struct nextfield *list = 0;
-  struct nextfield *new;
-  register char *p;
-  int nfields = 0;
-  register int n;
-
-  register struct next_fnfieldlist *mainlist = 0;
-  int nfn_fields = 0;
-
-  if (TYPE_MAIN_VARIANT (type) == 0)
-    {
-      TYPE_MAIN_VARIANT (type) = type;
-    }
-
-  TYPE_CODE (type) = TYPE_CODE_STRUCT;
-
-  /* First comes the total size in bytes.  */
-
-  TYPE_LENGTH (type) = read_number (pp, 0);
-
-  /* C++: Now, if the class is a derived class, then the next character
-     will be a '!', followed by the number of base classes derived from.
-     Each element in the list contains visibility information,
-     the offset of this base class in the derived structure,
-     and then the base type. */
-  if (**pp == '!')
-    {
-      int i, n_baseclasses, offset;
-      struct type *baseclass;
-      int via_public;
-
-      /* Nonzero if it is a virtual baseclass, i.e.,
-
-	 struct A{};
-	 struct B{};
-	 struct C : public B, public virtual A {};
-
-	 B is a baseclass of C; A is a virtual baseclass for C.  This is a C++
-	 2.0 language feature.  */
-      int via_virtual;
-
-      *pp += 1;
-
-      n_baseclasses = read_number (pp, ',');
-      TYPE_FIELD_VIRTUAL_BITS (type) =
-	  (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (n_baseclasses));
-      B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), n_baseclasses);
-
-      for (i = 0; i < n_baseclasses; i++)
-	{
-	  if (**pp == '\\')
-	    *pp = next_symbol_text ();
-
-	  switch (**pp)
-	    {
-	    case '0':
-	      via_virtual = 0;
-	      break;
-	    case '1':
-	      via_virtual = 1;
-	      break;
-	    default:
-	      /* Bad visibility format.  */
-	      return error_type (pp);
-	    }
-	  ++*pp;
-
-	  switch (**pp)
-	    {
-	    case '0':
-	      via_public = 0;
-	      break;
-	    case '2':
-	      via_public = 2;
-	      break;
-	    default:
-	      /* Bad visibility format.  */
-	      return error_type (pp);
-	    }
-	  if (via_virtual) 
-	    SET_TYPE_FIELD_VIRTUAL (type, i);
-	  ++*pp;
-
-	  /* Offset of the portion of the object corresponding to
-	     this baseclass.  Always zero in the absence of
-	     multiple inheritance.  */
-	  offset = read_number (pp, ',');
-	  baseclass = read_type (pp);
-	  *pp += 1;		/* skip trailing ';' */
-
-	  /* Make this baseclass visible for structure-printing purposes.  */
-	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
-	  new->next = list;
-	  list = new;
-	  list->visibility = via_public;
-	  list->field.type = baseclass;
-	  list->field.name = type_name_no_tag (baseclass);
-	  list->field.bitpos = offset;
-	  list->field.bitsize = 0;	/* this should be an unpacked field! */
-	  nfields++;
-	}
-      TYPE_N_BASECLASSES (type) = n_baseclasses;
-    }
-
-  /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
-     At the end, we see a semicolon instead of a field.
-
-     In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
-     a static field.
-
-     The `?' is a placeholder for one of '/2' (public visibility),
-     '/1' (protected visibility), '/0' (private visibility), or nothing
-     (C style symbol table, public visibility).  */
-
-  /* We better set p right now, in case there are no fields at all...    */
-  p = *pp;
-
-  while (**pp != ';')
-    {
-      /* Check for and handle cretinous dbx symbol name continuation!  */
-      if (**pp == '\\') *pp = next_symbol_text ();
-
-      /* Get space to record the next field's data.  */
-      new = (struct nextfield *) alloca (sizeof (struct nextfield));
-      new->next = list;
-      list = new;
-
-      /* Get the field name.  */
-      p = *pp;
-      if (*p == CPLUS_MARKER)
-	{
-	  /* Special GNU C++ name.  */
-	  if (*++p == 'v')
-	    {
-	      const char *prefix;
-	      char *name = 0;
-	      struct type *context;
-
-	      switch (*++p)
-		{
-		case 'f':
-		  prefix = vptr_name;
-		  break;
-		case 'b':
-		  prefix = vb_name;
-		  break;
-		default:
-		  error ("invalid abbreviation at symtab pos %d.", symnum);
-		}
-	      *pp = p + 1;
-	      context = read_type (pp);
-	      if (type_name_no_tag (context) == 0)
-		{
-		  if (name == 0)
-		    error ("type name unknown at symtab pos %d.", symnum);
-		  /* FIXME-tiemann: when is `name' ever non-0?  */
-		  TYPE_NAME (context) = obsavestring (name, p - name - 1);
-		}
-	      list->field.name = obconcat (prefix, type_name_no_tag (context), "");
-	      p = ++(*pp);
-	      if (p[-1] != ':')
-		error ("invalid abbreviation at symtab pos %d.", symnum);
-	      list->field.type = read_type (pp);
-	      (*pp)++;			/* Skip the comma.  */
-	      list->field.bitpos = read_number (pp, ';');
-	      /* This field is unpacked.  */
-	      list->field.bitsize = 0;
-	    }
-	  /* GNU C++ anonymous type.  */
-	  else if (*p == '_')
-	    break;
-	  else
-	    error ("invalid abbreviation at symtab pos %d.", symnum);
-
-	  nfields++;
-	  continue;
-	}
-
-      while (*p != ':') p++;
-      list->field.name = obsavestring (*pp, p - *pp);
-
-      /* C++: Check to see if we have hit the methods yet.  */
-      if (p[1] == ':')
-	break;
-
-      *pp = p + 1;
-
-      /* This means we have a visibility for a field coming. */
-      if (**pp == '/')
-	{
-	  switch (*++*pp)
-	    {
-	    case '0':
-	      list->visibility = 0;	/* private */
-	      *pp += 1;
-	      break;
-
- 	    case '1':
- 	      list->visibility = 1;	/* protected */
- 	      *pp += 1;
- 	      break;
-
- 	    case '2':
- 	      list->visibility = 2;	/* public */
- 	      *pp += 1;
- 	      break;
- 	    }
- 	}
-       else /* normal dbx-style format.  */
-	list->visibility = 2;		/* public */
-
-      list->field.type = read_type (pp);
-      if (**pp == ':')
- 	{
-	  /* Static class member.  */
- 	  list->field.bitpos = (long)-1;
- 	  p = ++(*pp);
- 	  while (*p != ';') p++;
- 	  list->field.bitsize = (long) savestring (*pp, p - *pp);
- 	  *pp = p + 1;
- 	  nfields++;
- 	  continue;
- 	}
-       else if (**pp != ',')
-	 /* Bad structure-type format.  */
-	 return error_type (pp);
-
-      (*pp)++;			/* Skip the comma.  */
-      list->field.bitpos = read_number (pp, ',');
-      list->field.bitsize = read_number (pp, ';');
-
-#if 0
-      /* FIXME-tiemann: Can't the compiler put out something which
-	 lets us distinguish these? (or maybe just not put out anything
-	 for the field).  What is the story here?  What does the compiler
-	really do?  Also, patch gdb.texinfo for this case; I document
-	it as a possible problem there.  Search for "DBX-style".  */
-
-      /* This is wrong because this is identical to the symbols
-	 produced for GCC 0-size arrays.  For example:
-         typedef union {
-	   int num;
-	   char str[0];
-	 } foo;
-	 The code which dumped core in such circumstances should be
-	 fixed not to dump core.  */
-
-      /* g++ -g0 can put out bitpos & bitsize zero for a static
-	 field.  This does not give us any way of getting its
-	 class, so we can't know its name.  But we can just
-	 ignore the field so we don't dump core and other nasty
-	 stuff.  */
-      if (list->field.bitpos == 0
-	  && list->field.bitsize == 0)
-	{
-	  complain (&dbx_class_complaint, 0);
-	  /* Ignore this field.  */
-	  list = list->next;
-	}
-      else
-#endif /* 0 */
-	{
-	  /* Detect an unpacked field and mark it as such.
-	     dbx gives a bit size for all fields.
-	     Note that forward refs cannot be packed,
-	     and treat enums as if they had the width of ints.  */
-	  if (TYPE_CODE (list->field.type) != TYPE_CODE_INT
-	      && TYPE_CODE (list->field.type) != TYPE_CODE_ENUM)
-	    list->field.bitsize = 0;
-	  if ((list->field.bitsize == 8 * TYPE_LENGTH (list->field.type)
-	       || (TYPE_CODE (list->field.type) == TYPE_CODE_ENUM
-		   && (list->field.bitsize
-		       == 8 * TYPE_LENGTH (builtin_type_int))
-		   )
-	       )
-	      &&
-	      list->field.bitpos % 8 == 0)
-	    list->field.bitsize = 0;
-	  nfields++;
-	}
-    }
-
-  if (p[1] == ':')
-    /* chill the list of fields: the last entry (at the head)
-       is a partially constructed entry which we now scrub.  */
-    list = list->next;
-
-  /* Now create the vector of fields, and record how big it is.
-     We need this info to record proper virtual function table information
-     for this class's virtual functions.  */
-
-  TYPE_NFIELDS (type) = nfields;
-  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack,
-					       sizeof (struct field) * nfields);
-
-  TYPE_FIELD_PRIVATE_BITS (type) =
-    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
-  B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields);
-
-  TYPE_FIELD_PROTECTED_BITS (type) =
-    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (nfields));
-  B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields);
-
-  /* Copy the saved-up fields into the field vector.  */
-
-  for (n = nfields; list; list = list->next)
-    {
-      n -= 1;
-      TYPE_FIELD (type, n) = list->field;
-      if (list->visibility == 0)
-	SET_TYPE_FIELD_PRIVATE (type, n);
-      else if (list->visibility == 1)
-	SET_TYPE_FIELD_PROTECTED (type, n);
-    }
-
-  /* Now come the method fields, as NAME::methods
-     where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
-     At the end, we see a semicolon instead of a field.
-
-     For the case of overloaded operators, the format is
-     OPERATOR::*.methods, where OPERATOR is the string "operator",
-     `*' holds the place for an operator name (such as `+=')
-     and `.' marks the end of the operator name.  */
-  if (p[1] == ':')
-    {
-      /* Now, read in the methods.  To simplify matters, we
-	 "unread" the name that has been read, so that we can
-	 start from the top.  */
-
-      /* For each list of method lists... */
-      do
-	{
-	  int i;
-	  struct next_fnfield *sublist = 0;
-	  struct type *look_ahead_type = NULL;
-	  int length = 0;
-	  struct next_fnfieldlist *new_mainlist =
-	    (struct next_fnfieldlist *)alloca (sizeof (struct next_fnfieldlist));
-	  char *main_fn_name;
-
-	  p = *pp;
-
-	  /* read in the name.  */
-	  while (*p != ':') p++;
-	  if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && (*pp)[2] == CPLUS_MARKER)
-	    {
-	      /* This lets the user type "break operator+".
-	         We could just put in "+" as the name, but that wouldn't
-		 work for "*".  */
-	      static char opname[32] = {'o', 'p', CPLUS_MARKER};
-	      char *o = opname + 3;
-
-	      /* Skip past '::'.  */
-	      p += 2;
-	      while (*p != '.')
-		*o++ = *p++;
-	     main_fn_name = savestring (opname, o - opname);
-	      /* Skip past '.'  */
-	      *pp = p + 1;
-	    }
-	  else
-	    {
-	      i = 0;
-	      main_fn_name = savestring (*pp, p - *pp);
-	      /* Skip past '::'.  */
-	      *pp = p + 2;
-	    }
-	  new_mainlist->fn_fieldlist.name = main_fn_name;
-
-	  do
-	    {
-	      struct next_fnfield *new_sublist =
-		(struct next_fnfield *)alloca (sizeof (struct next_fnfield));
-
-	      /* Check for and handle cretinous dbx symbol name continuation!  */
-	      if (look_ahead_type == NULL) /* Normal case. */
-		{
-		  if (**pp == '\\') *pp = next_symbol_text ();
-
-		  new_sublist->fn_field.type = read_type (pp);
-		  if (**pp != ':')
-		    /* Invalid symtab info for method.  */
-		    return error_type (pp);
-	        }
-	      else
-		{ /* g++ version 1 kludge */
-		  new_sublist->fn_field.type = look_ahead_type;
-		  look_ahead_type = NULL;
-	        }
-
-	      *pp += 1;
-	      p = *pp;
-	      while (*p != ';') p++;
-	      /* If this is just a stub, then we don't have the
-		 real name here.  */
-	      new_sublist->fn_field.physname = savestring (*pp, p - *pp);
-	      *pp = p + 1;
-	      new_sublist->visibility = *(*pp)++ - '0';
-	      if (**pp == '\\') *pp = next_symbol_text ();
-	      switch (**pp)
-		{
-		case 'A': /* Normal functions. */
-		  new_sublist->fn_field.is_const = 0;
-		  new_sublist->fn_field.is_volatile = 0;
-	          (*pp)++;
-		  break;
-		case 'B': /* `const' member functions. */
-		  new_sublist->fn_field.is_const = 1;
-		  new_sublist->fn_field.is_volatile = 0;
-	          (*pp)++;
-		  break;
-		case 'C': /* `volatile' member function. */
-		  new_sublist->fn_field.is_const = 0;
-		  new_sublist->fn_field.is_volatile = 1;
-	          (*pp)++;
-		  break;
-		case 'D': /* `const volatile' member function. */
-		  new_sublist->fn_field.is_const = 1;
-		  new_sublist->fn_field.is_volatile = 1;
-	          (*pp)++;
-		  break;
-		default:
-		  /* This probably just means we're processing a file compiled
-		     with g++ version 1.  */
-		  complain(&const_vol_complaint, **pp);
-		}
-
-	      switch (*(*pp)++)
-		{
-		case '*':
-		  /* virtual member function, followed by index.  */
-		  /* The sign bit is set to distinguish pointers-to-methods
-		     from virtual function indicies.  Since the array is
-		     in words, the quantity must be shifted left by 1
-		     on 16 bit machine, and by 2 on 32 bit machine, forcing
-		     the sign bit out, and usable as a valid index into
-		     the array.  Remove the sign bit here.  */
-		  new_sublist->fn_field.voffset =
-		      (0x7fffffff & read_number (pp, ';')) + 2;
-
-		  if (**pp == '\\') *pp = next_symbol_text ();
-
-		  if (**pp == ';' || **pp == '\0')
-		    /* Must be g++ version 1.  */
-		    new_sublist->fn_field.fcontext = 0;
-		  else
-		    {
-		      /* Figure out from whence this virtual function came.
-			 It may belong to virtual function table of
-			 one of its baseclasses.  */
-		      look_ahead_type = read_type (pp);
-		      if (**pp == ':')
-			{ /* g++ version 1 overloaded methods. */ }
-		      else
-			{
-			  new_sublist->fn_field.fcontext = look_ahead_type;
-			  if (**pp != ';')
-			    return error_type (pp);
-			  else
-			    ++*pp;
-			  look_ahead_type = NULL;
-		        }
-		    }
-		  break;
-
-		case '?':
-		  /* static member function.  */
-		  new_sublist->fn_field.voffset = VOFFSET_STATIC;
-		  break;
-		default:
-		  /* **pp == '.'.  */
-		  /* normal member function.  */
-		  new_sublist->fn_field.voffset = 0;
-		  new_sublist->fn_field.fcontext = 0;
-		  break;
-		}
-
-	      new_sublist->next = sublist;
-	      sublist = new_sublist;
-	      length++;
-	      if (**pp == '\\') *pp = next_symbol_text ();
-	    }
-	  while (**pp != ';' && **pp != '\0');
-
-	  *pp += 1;
-
-	  new_mainlist->fn_fieldlist.fn_fields =
-	    (struct fn_field *) obstack_alloc (symbol_obstack,
-					       sizeof (struct fn_field) * length);
-	  TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist) =
-	    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (length));
-	  B_CLRALL (TYPE_FN_PRIVATE_BITS (new_mainlist->fn_fieldlist), length);
-
-	  TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist) =
-	    (B_TYPE *) obstack_alloc (symbol_obstack, B_BYTES (length));
-	  B_CLRALL (TYPE_FN_PROTECTED_BITS (new_mainlist->fn_fieldlist), length);
-
-	  for (i = length; (i--, sublist); sublist = sublist->next)
-	    {
-	      new_mainlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
-	      if (sublist->visibility == 0)
-		B_SET (new_mainlist->fn_fieldlist.private_fn_field_bits, i);
-	      else if (sublist->visibility == 1)
-		B_SET (new_mainlist->fn_fieldlist.protected_fn_field_bits, i);
-	    }
-
-	  new_mainlist->fn_fieldlist.length = length;
-	  new_mainlist->next = mainlist;
-	  mainlist = new_mainlist;
-	  nfn_fields++;
-	  total_length += length;
-	}
-      while (**pp != ';');
-    }
-
-  *pp += 1;
-
-  TYPE_FN_FIELDLISTS (type) =
-    (struct fn_fieldlist *) obstack_alloc (symbol_obstack,
-				   sizeof (struct fn_fieldlist) * nfn_fields);
-
-  TYPE_NFN_FIELDS (type) = nfn_fields;
-  TYPE_NFN_FIELDS_TOTAL (type) = total_length;
-
-  {
-    int i;
-    for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
-      TYPE_NFN_FIELDS_TOTAL (type) +=
-	TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type, i));
-  }
-
-  for (n = nfn_fields; mainlist; mainlist = mainlist->next)
-    TYPE_FN_FIELDLISTS (type)[--n] = mainlist->fn_fieldlist;
-
-  if (**pp == '~')
-    {
-      *pp += 1;
-
-      if (**pp == '=')
-	{
-	  TYPE_FLAGS (type)
-	    |= TYPE_FLAG_HAS_CONSTRUCTOR | TYPE_FLAG_HAS_DESTRUCTOR;
-	  *pp += 1;
-	}
-      else if (**pp == '+')
-	{
-	  TYPE_FLAGS (type) |= TYPE_FLAG_HAS_CONSTRUCTOR;
-	  *pp += 1;
-	}
-      else if (**pp == '-')
-	{
-	  TYPE_FLAGS (type) |= TYPE_FLAG_HAS_DESTRUCTOR;
-	  *pp += 1;
-	}
-
-      /* Read either a '%' or the final ';'.  */
-      if (*(*pp)++ == '%')
-	{
-	  /* Now we must record the virtual function table pointer's
-	     field information.  */
-
-	  struct type *t;
-	  int i;
-
-	  t = read_type (pp);
-	  p = (*pp)++;
-	  while (*p != '\0' && *p != ';')
-	    p++;
-	  if (*p == '\0')
-	    /* Premature end of symbol.  */
-	    return error_type (pp);
-	  
-	  TYPE_VPTR_BASETYPE (type) = t;
-	  if (type == t)
-	    {
-	      if (TYPE_FIELD_NAME (t, TYPE_N_BASECLASSES (t)) == 0)
-		{
-		  /* FIXME-tiemann: what's this?  */
-#if 0
-		  TYPE_VPTR_FIELDNO (type) = i = TYPE_N_BASECLASSES (t);
-#else
-		  error_type (pp);
-#endif
-		}
-	      else for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); --i)
-		if (! strncmp (TYPE_FIELD_NAME (t, i), vptr_name, 
-			sizeof (vptr_name) -1))
-		  {
-		    TYPE_VPTR_FIELDNO (type) = i;
-		    break;
-		  }
-	      if (i < 0)
-		/* Virtual function table field not found.  */
-		return error_type (pp);
-	    }
-	  else
-	    TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
-	  *pp = p + 1;
-	}
-    }
-
-  return type;
-}
-
-/* Read a definition of an array type,
-   and create and return a suitable type object.
-   Also creates a range type which represents the bounds of that
-   array.  */
-static struct type *
-read_array_type (pp, type)
-     register char **pp;
-     register struct type *type;
-{
-  struct type *index_type, *element_type, *range_type;
-  int lower, upper;
-  int adjustable = 0;
-
-  /* Format of an array type:
-     "ar<index type>;lower;upper;<array_contents_type>".  Put code in
-     to handle this.
-
-     Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
-     for these, produce a type like float[][].  */
-
-  index_type = read_type (pp);
-  if (**pp != ';')
-    /* Improper format of array type decl.  */
-    return error_type (pp);
-  ++*pp;
-
-  if (!(**pp >= '0' && **pp <= '9'))
-    {
-      *pp += 1;
-      adjustable = 1;
-    }
-  lower = read_number (pp, ';');
-
-  if (!(**pp >= '0' && **pp <= '9'))
-    {
-      *pp += 1;
-      adjustable = 1;
-    }
-  upper = read_number (pp, ';');
-  
-  element_type = read_type (pp);
-
-  if (adjustable)
-    {
-      lower = 0;
-      upper = -1;
-    }
-
-  {
-    /* Create range type.  */
-    range_type = (struct type *) obstack_alloc (symbol_obstack,
-						sizeof (struct type));
-    TYPE_CODE (range_type) = TYPE_CODE_RANGE;
-    TYPE_TARGET_TYPE (range_type) = index_type;
-
-    /* This should never be needed.  */
-    TYPE_LENGTH (range_type) = sizeof (int);
-
-    TYPE_NFIELDS (range_type) = 2;
-    TYPE_FIELDS (range_type) =
-      (struct field *) obstack_alloc (symbol_obstack,
-				      2 * sizeof (struct field));
-    TYPE_FIELD_BITPOS (range_type, 0) = lower;
-    TYPE_FIELD_BITPOS (range_type, 1) = upper;
-  }
-
-  TYPE_CODE (type) = TYPE_CODE_ARRAY;
-  TYPE_TARGET_TYPE (type) = element_type;
-  TYPE_LENGTH (type) = (upper - lower + 1) * TYPE_LENGTH (element_type);
-  TYPE_NFIELDS (type) = 1;
-  TYPE_FIELDS (type) =
-    (struct field *) obstack_alloc (symbol_obstack,
-				    sizeof (struct field));
-  TYPE_FIELD_TYPE (type, 0) = range_type;
-
-  return type;
-}
-
-
-/* Read a definition of an enumeration type,
-   and create and return a suitable type object.
-   Also defines the symbols that represent the values of the type.  */
-
-static struct type *
-read_enum_type (pp, type)
-     register char **pp;
-     register struct type *type;
-{
-  register char *p;
-  char *name;
-  register long n;
-  register struct symbol *sym;
-  int nsyms = 0;
-  struct pending **symlist;
-  struct pending *osyms, *syms;
-  int o_nsyms;
-
-  if (within_function)
-    symlist = &local_symbols;
-  else
-    symlist = &file_symbols;
-  osyms = *symlist;
-  o_nsyms = osyms ? osyms->nsyms : 0;
-
-  /* Read the value-names and their values.
-     The input syntax is NAME:VALUE,NAME:VALUE, and so on.
-     A semicolon or comman instead of a NAME means the end.  */
-  while (**pp && **pp != ';' && **pp != ',')
-    {
-      /* Check for and handle cretinous dbx symbol name continuation!  */
-      if (**pp == '\\')	*pp = next_symbol_text ();
-
-      p = *pp;
-      while (*p != ':') p++;
-      name = obsavestring (*pp, p - *pp);
-      *pp = p + 1;
-      n = read_number (pp, ',');
-
-      sym = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol));
-      bzero (sym, sizeof (struct symbol));
-      SYMBOL_NAME (sym) = name;
-      SYMBOL_CLASS (sym) = LOC_CONST;
-      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-      SYMBOL_VALUE (sym) = n;
-      add_symbol_to_list (sym, symlist);
-      nsyms++;
-    }
-
-  if (**pp == ';')
-    (*pp)++;			/* Skip the semicolon.  */
-
-  /* Now fill in the fields of the type-structure.  */
-
-  TYPE_LENGTH (type) = sizeof (int);
-  TYPE_CODE (type) = TYPE_CODE_ENUM;
-  TYPE_NFIELDS (type) = nsyms;
-  TYPE_FIELDS (type) = (struct field *) obstack_alloc (symbol_obstack, sizeof (struct field) * nsyms);
-
-  /* Find the symbols for the values and put them into the type.
-     The symbols can be found in the symlist that we put them on
-     to cause them to be defined.  osyms contains the old value
-     of that symlist; everything up to there was defined by us.  */
-  /* Note that we preserve the order of the enum constants, so
-     that in something like "enum {FOO, LAST_THING=FOO}" we print
-     FOO, not LAST_THING.  */
-
-  for (syms = *symlist, n = 0; syms; syms = syms->next)
-    {
-      int j = 0;
-      if (syms == osyms)
-	j = o_nsyms;
-      for (; j < syms->nsyms; j++,n++)
-	{
-	  struct symbol *xsym = syms->symbol[j];
-	  SYMBOL_TYPE (xsym) = type;
-	  TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
-	  TYPE_FIELD_VALUE (type, n) = 0;
-	  TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
-	  TYPE_FIELD_BITSIZE (type, n) = 0;
-	}
-      if (syms == osyms)
-	break;
-    }
-
-#if 0
-  /* This screws up perfectly good C programs with enums.  FIXME.  */
-  /* Is this Modula-2's BOOLEAN type?  Flag it as such if so. */
-  if(TYPE_NFIELDS(type) == 2 &&
-     ((!strcmp(TYPE_FIELD_NAME(type,0),"TRUE") &&
-       !strcmp(TYPE_FIELD_NAME(type,1),"FALSE")) ||
-      (!strcmp(TYPE_FIELD_NAME(type,1),"TRUE") &&
-       !strcmp(TYPE_FIELD_NAME(type,0),"FALSE"))))
-     TYPE_CODE(type) = TYPE_CODE_BOOL;
-#endif
-
-  return type;
-}
-
-/* Read a number from the string pointed to by *PP.
-   The value of *PP is advanced over the number.
-   If END is nonzero, the character that ends the
-   number must match END, or an error happens;
-   and that character is skipped if it does match.
-   If END is zero, *PP is left pointing to that character.
-
-   If the number fits in a long, set *VALUE and set *BITS to 0.
-   If not, set *BITS to be the number of bits in the number.
-
-   If encounter garbage, set *BITS to -1.  */
-
-static void
-read_huge_number (pp, end, valu, bits)
-     char **pp;
-     int end;
-     long *valu;
-     int *bits;
-{
-  char *p = *pp;
-  int sign = 1;
-  long n = 0;
-  int radix = 10;
-  char overflow = 0;
-  int nbits = 0;
-  int c;
-  long upper_limit;
-  
-  if (*p == '-')
-    {
-      sign = -1;
-      p++;
-    }
-
-  /* Leading zero means octal.  GCC uses this to output values larger
-     than an int (because that would be hard in decimal).  */
-  if (*p == '0')
-    {
-      radix = 8;
-      p++;
-    }
-
-  upper_limit = LONG_MAX / radix;
-  while ((c = *p++) >= '0' && c <= ('0' + radix))
-    {
-      if (n <= upper_limit)
-	{
-	  n *= radix;
-	  n += c - '0';		/* FIXME this overflows anyway */
-	}
-      else
-	overflow = 1;
-      
-      /* This depends on large values being output in octal, which is
-	 what GCC does. */
-      if (radix == 8)
-	{
-	  if (nbits == 0)
-	    {
-	      if (c == '0')
-		/* Ignore leading zeroes.  */
-		;
-	      else if (c == '1')
-		nbits = 1;
-	      else if (c == '2' || c == '3')
-		nbits = 2;
-	      else
-		nbits = 3;
-	    }
-	  else
-	    nbits += 3;
-	}
-    }
-  if (end)
-    {
-      if (c && c != end)
-	{
-	  if (bits != NULL)
-	    *bits = -1;
-	  return;
-	}
-    }
-  else
-    --p;
-
-  *pp = p;
-  if (overflow)
-    {
-      if (nbits == 0)
-	{
-	  /* Large decimal constants are an error (because it is hard to
-	     count how many bits are in them).  */
-	  if (bits != NULL)
-	    *bits = -1;
-	  return;
-	}
-      
-      /* -0x7f is the same as 0x80.  So deal with it by adding one to
-	 the number of bits.  */
-      if (sign == -1)
-	++nbits;
-      if (bits)
-	*bits = nbits;
-    }
-  else
-    {
-      if (valu)
-	*valu = n * sign;
-      if (bits)
-	*bits = 0;
-    }
-}
-
-#define	MAX_OF_C_TYPE(t)	((1 << (sizeof (t)*8 - 1)) - 1)
-#define MIN_OF_C_TYPE(t)	(-(1 << (sizeof (t)*8 - 1)))
-
-static struct type *
-read_range_type (pp, typenums)
-     char **pp;
-     int typenums[2];
-{
-  int rangenums[2];
-  long n2, n3;
-  int n2bits, n3bits;
-  int self_subrange;
-  struct type *result_type;
-
-  /* First comes a type we are a subrange of.
-     In C it is usually 0, 1 or the type being defined.  */
-  read_type_number (pp, rangenums);
-  self_subrange = (rangenums[0] == typenums[0] &&
-		   rangenums[1] == typenums[1]);
-
-  /* A semicolon should now follow; skip it.  */
-  if (**pp == ';')
-    (*pp)++;
-
-  /* The remaining two operands are usually lower and upper bounds
-     of the range.  But in some special cases they mean something else.  */
-  read_huge_number (pp, ';', &n2, &n2bits);
-  read_huge_number (pp, ';', &n3, &n3bits);
-
-  if (n2bits == -1 || n3bits == -1)
-    return error_type (pp);
-  
-  /* If limits are huge, must be large integral type.  */
-  if (n2bits != 0 || n3bits != 0)
-    {
-      char got_signed = 0;
-      char got_unsigned = 0;
-      /* Number of bits in the type.  */
-      int nbits;
-
-      /* Range from 0 to <large number> is an unsigned large integral type.  */
-      if ((n2bits == 0 && n2 == 0) && n3bits != 0)
-	{
-	  got_unsigned = 1;
-	  nbits = n3bits;
-	}
-      /* Range from <large number> to <large number>-1 is a large signed
-	 integral type.  */
-      else if (n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1)
-	{
-	  got_signed = 1;
-	  nbits = n2bits;
-	}
-
-      /* Check for "long long".  */
-      if (got_signed && nbits == TARGET_LONG_LONG_BIT)
-	return builtin_type_long_long;
-      if (got_unsigned && nbits == TARGET_LONG_LONG_BIT)
-	return builtin_type_unsigned_long_long;
-
-      if (got_signed || got_unsigned)
-	{
-	  result_type = (struct type *) obstack_alloc (symbol_obstack,
-						       sizeof (struct type));
-	  bzero (result_type, sizeof (struct type));
-	  TYPE_LENGTH (result_type) = nbits / TARGET_CHAR_BIT;
-	  TYPE_MAIN_VARIANT (result_type) = result_type;
-	  TYPE_CODE (result_type) = TYPE_CODE_INT;
-	  if (got_unsigned)
-	    TYPE_FLAGS (result_type) |= TYPE_FLAG_UNSIGNED;
-	  return result_type;
-	}
-      else
-	return error_type (pp);
-    }
-
-  /* A type defined as a subrange of itself, with bounds both 0, is void.  */
-  if (self_subrange && n2 == 0 && n3 == 0)
-    return builtin_type_void;
-
-  /* If n3 is zero and n2 is not, we want a floating type,
-     and n2 is the width in bytes.
-
-     Fortran programs appear to use this for complex types also,
-     and they give no way to distinguish between double and single-complex!
-     We don't have complex types, so we would lose on all fortran files!
-     So return type `double' for all of those.  It won't work right
-     for the complex values, but at least it makes the file loadable.  */
-
-  if (n3 == 0 && n2 > 0)
-    {
-      if (n2 == sizeof (float))
-	return builtin_type_float;
-      return builtin_type_double;
-    }
-
-  /* If the upper bound is -1, it must really be an unsigned int.  */
-
-  else if (n2 == 0 && n3 == -1)
-    {
-      if (sizeof (int) == sizeof (long))
-	return builtin_type_unsigned_int;
-      else
-	return builtin_type_unsigned_long;
-    }
-
-  /* Special case: char is defined (Who knows why) as a subrange of
-     itself with range 0-127.  */
-  else if (self_subrange && n2 == 0 && n3 == 127)
-    return builtin_type_char;
-
-  /* Assumptions made here: Subrange of self is equivalent to subrange
-     of int.  */
-  else if (n2 == 0
-	   && (self_subrange ||
-	       *dbx_lookup_type (rangenums) == builtin_type_int))
-    {
-      /* an unsigned type */
-#ifdef LONG_LONG
-      if (n3 == - sizeof (long long))
-	return builtin_type_unsigned_long_long;
-#endif
-      if (n3 == (unsigned int)~0L)
-	return builtin_type_unsigned_int;
-      if (n3 == (unsigned long)~0L)
-	return builtin_type_unsigned_long;
-      if (n3 == (unsigned short)~0L)
-	return builtin_type_unsigned_short;
-      if (n3 == (unsigned char)~0L)
-	return builtin_type_unsigned_char;
-    }
-#ifdef LONG_LONG
-  else if (n3 == 0 && n2 == -sizeof (long long))
-    return builtin_type_long_long;
-#endif  
-  else if (n2 == -n3 -1)
-    {
-      /* a signed type */
-      if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
-	return builtin_type_int;
-      if (n3 == (1 << (8 * sizeof (long) - 1)) - 1)
-	 return builtin_type_long;
-      if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
-	return builtin_type_short;
-      if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
-	return builtin_type_char;
-    }
-
-  /* We have a real range type on our hands.  Allocate space and
-     return a real pointer.  */
-
-  /* At this point I don't have the faintest idea how to deal with
-     a self_subrange type; I'm going to assume that this is used
-     as an idiom, and that all of them are special cases.  So . . .  */
-  if (self_subrange)
-    return error_type (pp);
-
-  result_type = (struct type *) obstack_alloc (symbol_obstack,
-					       sizeof (struct type));
-  bzero (result_type, sizeof (struct type));
-
-  TYPE_CODE (result_type) = TYPE_CODE_RANGE;
-
-  TYPE_TARGET_TYPE (result_type) = *dbx_lookup_type(rangenums);
-  if (TYPE_TARGET_TYPE (result_type) == 0) {
-    complain (&range_type_base_complaint, rangenums[1]);
-    TYPE_TARGET_TYPE (result_type) = builtin_type_int;
-  }
-
-  TYPE_NFIELDS (result_type) = 2;
-  TYPE_FIELDS (result_type) =
-     (struct field *) obstack_alloc (symbol_obstack,
-				     2 * sizeof (struct field));
-  bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
-  TYPE_FIELD_BITPOS (result_type, 0) = n2;
-  TYPE_FIELD_BITPOS (result_type, 1) = n3;
-
-#if 0
-/* Note that TYPE_LENGTH (result_type) is just overridden a few
-   statements down.  What do we really need here?  */
-  /* We have to figure out how many bytes it takes to hold this
-     range type.  I'm going to assume that anything that is pushing
-     the bounds of a long was taken care of above.  */
-  if (n2 >= MIN_OF_C_TYPE(char) && n3 <= MAX_OF_C_TYPE(char))
-    TYPE_LENGTH (result_type) = 1;
-  else if (n2 >= MIN_OF_C_TYPE(short) && n3 <= MAX_OF_C_TYPE(short))
-    TYPE_LENGTH (result_type) = sizeof (short);
-  else if (n2 >= MIN_OF_C_TYPE(int) && n3 <= MAX_OF_C_TYPE(int))
-    TYPE_LENGTH (result_type) = sizeof (int);
-  else if (n2 >= MIN_OF_C_TYPE(long) && n3 <= MAX_OF_C_TYPE(long))
-    TYPE_LENGTH (result_type) = sizeof (long);
-  else
-    /* Ranged type doesn't fit within known sizes.  */
-    /* FIXME -- use "long long" here.  */
-    return error_type (pp);
-#endif
-
-  TYPE_LENGTH (result_type) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type));
-
-  return result_type;
-}
-
-/* Read a number from the string pointed to by *PP.
-   The value of *PP is advanced over the number.
-   If END is nonzero, the character that ends the
-   number must match END, or an error happens;
-   and that character is skipped if it does match.
-   If END is zero, *PP is left pointing to that character.  */
-
-static long
-read_number (pp, end)
-     char **pp;
-     int end;
-{
-  register char *p = *pp;
-  register long n = 0;
-  register int c;
-  int sign = 1;
-
-  /* Handle an optional leading minus sign.  */
-
-  if (*p == '-')
-    {
-      sign = -1;
-      p++;
-    }
-
-  /* Read the digits, as far as they go.  */
-
-  while ((c = *p++) >= '0' && c <= '9')
-    {
-      n *= 10;
-      n += c - '0';
-    }
-  if (end)
-    {
-      if (c && c != end)
-	error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c, symnum);
-    }
-  else
-    --p;
-
-  *pp = p;
-  return n * sign;
-}
-
-/* Read in an argument list.  This is a list of types, separated by commas
-   and terminated with END.  Return the list of types read in, or (struct type
-   **)-1 if there is an error.  */
-static struct type **
-read_args (pp, end)
-     char **pp;
-     int end;
-{
-  struct type *types[1024], **rval; /* allow for fns of 1023 parameters */
-  int n = 0;
-
-  while (**pp != end)
-    {
-      if (**pp != ',')
-	/* Invalid argument list: no ','.  */
-	return (struct type **)-1;
-      *pp += 1;
-
-      /* Check for and handle cretinous dbx symbol name continuation! */
-      if (**pp == '\\')
-	*pp = next_symbol_text ();
-
-      types[n++] = read_type (pp);
-    }
-  *pp += 1;			/* get past `end' (the ':' character) */
-
-  if (n == 1)
-    {
-      rval = (struct type **) xmalloc (2 * sizeof (struct type *));
-    }
-  else if (TYPE_CODE (types[n-1]) != TYPE_CODE_VOID)
-    {
-      rval = (struct type **) xmalloc ((n + 1) * sizeof (struct type *));
-      bzero (rval + n, sizeof (struct type *));
-    }
-  else
-    {
-      rval = (struct type **) xmalloc (n * sizeof (struct type *));
-    }
-  bcopy (types, rval, n * sizeof (struct type *));
-  return rval;
-}
 
 /* Copy a pending list, used to record the contents of a common
    block for later fixup.  */
@@ -5432,24 +2887,6 @@ copy_pending (beg, begi, end)
     }
   return new;
 }
-
-/* Add a common block's start address to the offset of each symbol
-   declared to be in it (by being between a BCOMM/ECOMM pair that uses
-   the common block name).  */
-
-static void
-fix_common_block (sym, valu)
-    struct symbol *sym;
-    int valu;
-{
-  struct pending *next = (struct pending *) SYMBOL_NAMESPACE (sym);
-  for ( ; next; next = next->next)
-    {
-      register int j;
-      for (j = next->nsyms - 1; j >= 0; j--)
-	SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
-    }
-}
 
 /* Register our willingness to decode symbols for SunOS and a.out and
    b.out files handled by BFD... */
@@ -5468,9 +2905,4 @@ _initialize_dbxread ()
   add_symtab_fns(&sunos_sym_fns);
   add_symtab_fns(&aout_sym_fns);
   add_symtab_fns(&bout_sym_fns);
-
-  undef_types_allocated = 20;
-  undef_types_length = 0;
-  undef_types = (struct type **) xmalloc (undef_types_allocated *
-					  sizeof (struct type *));
 }