gdb-3.3

1 files changed, 1343 insertions, 641 deletions

diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 9908aa1..cbb4e0c 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -1,22 +1,21 @@
 /* Read dbx symbol tables and convert to internal format, for GDB.
    Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc.
 
-GDB is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY.  No author or distributor accepts responsibility to anyone
-for the consequences of using it or for whether it serves any
-particular purpose or works at all, unless he says so in writing.
-Refer to the GDB General Public License for full details.
-
-Everyone is granted permission to copy, modify and redistribute GDB,
-but only under the conditions described in the GDB General Public
-License.  A copy of this license is supposed to have been given to you
-along with GDB so you can know your rights and responsibilities.  It
-should be in a file named COPYING.  Among other things, the copyright
-notice and this notice must be preserved on all copies.
-
-In other words, go ahead and share GDB, but don't try to stop
-anyone else from sharing it farther.  Help stamp out software hoarding!
-*/
+This file is part of GDB.
+
+GDB 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 1, or (at your option)
+any later version.
+
+GDB 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 GDB; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include "param.h"
 
@@ -36,7 +35,9 @@ anyone else from sharing it farther.  Help stamp out software hoarding!
 #include <a.out.h>
 #include <stab.h>
 #endif
+#include <ctype.h>
 
+#ifndef NO_GNU_STABS
 /*
  * Define specifically gnu symbols here.
  */
@@ -107,6 +108,7 @@ anyone else from sharing it farther.  Help stamp out software hoarding!
 #endif
 
 #endif /* not __GNU_STAB__ */
+#endif /* NO_GNU_STABS */
 
 #include <stdio.h>
 #include <obstack.h>
@@ -117,8 +119,10 @@ anyone else from sharing it farther.  Help stamp out software hoarding!
 #include "symtab.h"
 
 #ifndef COFF_FORMAT
+#ifndef AOUTHDR
 #define AOUTHDR		struct exec
 #endif
+#endif
 
 static void add_symbol_to_list ();
 static void read_dbx_symtab ();
@@ -136,6 +140,13 @@ static struct symbol *define_symbol ();
 static void start_subfile ();
 static int hashname ();
 static void hash_symsegs ();
+static struct pending *copy_pending ();
+static void fix_common_block ();
+
+static void add_undefined_type ();
+static void cleanup_undefined_types ();
+
+extern char *index();
 
 extern struct symtab *read_symsegs ();
 extern void free_all_symtabs ();
@@ -143,7 +154,7 @@ extern void free_all_psymtabs ();
 extern void free_inclink_symtabs ();
 
 /* C++ */
-static struct type **read_args();
+static struct type **read_args ();
 
 /* Macro to determine which symbols to ignore when reading the first symbol
    of a file.  Some machines override this definition. */
@@ -212,16 +223,59 @@ static struct type **read_args();
 #endif
 #endif
 
+/* Non-zero if this is an object (.o) file, rather than an executable.
+   Distinguishing between the two is rarely necessary (and seems like
+   a hack, but there is no other way to do ADDR_OF_TEXT_SEGMENT
+   right for SunOS).  */
+#if !defined (IS_OBJECT_FILE)
+/* This will not work
+   if someone decides to make ld preserve relocation info.  */
+#define IS_OBJECT_FILE (hdr.a_trsize != 0)
+#endif
+
 /* Macro for size of text segment */
 #ifndef SIZE_OF_TEXT_SEGMENT
 #define SIZE_OF_TEXT_SEGMENT hdr.a_text
 #endif
 
+/* Get the address in debugged memory of the start
+   of the text segment.  */
+#if !defined (ADDR_OF_TEXT_SEGMENT)
+#if defined (N_TXTADDR)
+#define ADDR_OF_TEXT_SEGMENT (IS_OBJECT_FILE ? 0 : N_TXTADDR (hdr))
+#else /* no N_TXTADDR */
+#define ADDR_OF_TEXT_SEGMENT 0
+#endif /* no N_TXTADDR */
+#endif /* no ADDR_OF_TEXT_SEGMENT */
+
+/* Macro to get entry point from headers.  */
+#ifndef ENTRY_POINT
+#define ENTRY_POINT hdr.a_entry
+#endif
+
 /* Macro for name of symbol to indicate a file compiled with gcc. */
 #ifndef GCC_COMPILED_FLAG_SYMBOL
 #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
+   big-endian machine.  */
+
+#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;
+
 /* Chain of symtabs made from reading the file's symsegs.
    These symtabs do not go into symtab_list themselves,
    but the information is copied from them when appropriate
@@ -303,6 +357,8 @@ static int line_vector_length;
 /* Hash table of global symbols whose values are not known yet.
    They are chained thru the SYMBOL_VALUE, 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];
@@ -331,6 +387,15 @@ 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).  */
 
@@ -368,7 +433,8 @@ struct pending_block
 
 struct pending_block *pending_blocks;
 
-extern CORE_ADDR first_object_file_end;	/* From blockframe.c */
+extern CORE_ADDR startup_file_start;	/* From blockframe.c */
+extern CORE_ADDR startup_file_end;	/* From blockframe.c */
 
 /* File name symbols were loaded from.  */
 
@@ -379,27 +445,36 @@ static char *symfile;
 
 static int first_global_sym, last_global_sym;
 
-/* Partial symbol list for all of the global and static symbols found
-   in a file */
-
-struct partial_symbol *global_psymbols, *static_psymbols;
-int global_psymbols_allocated, static_psymbols_allocated;
+/* Structures with which to manage partial symbol allocation.  */
 
-/* Position for next psymbol to be added */
-
-struct partial_symbol *next_ps_global, *next_ps_static;
+struct psymbol_allocation_list global_psymbols, static_psymbols;
 
 /* Global variable which, when set, indicates that we are processing a
    .o file compiled with gcc */
 
 static unsigned char processing_gcc_compilation;
 
+/* Make a list of forward references which haven't been defined.  */
+static struct type **undef_types;
+static int undef_types_allocated, undef_types_length;
+
+  /* Setup a define to deal cleanly with the underscore problem */
+
+#ifdef NAMES_HAVE_UNDERSCORE
+#define HASH_OFFSET 1
+#else
+#define HASH_OFFSET 0
+#endif
+
 static int
 xxmalloc (n)
 {
   int v = malloc (n);
   if (v == 0)
-    abort ();
+    {
+      fprintf (stderr, "Virtual memory exhausted.\n");
+      abort ();
+    }
   return v;
 }
 
@@ -482,7 +557,7 @@ static int n_allocated_header_files;
    track of which psymtabs have which bincls in them.  This structure
    is used during readin to setup the list of dependencies within each
    partial symbol table. */
- 
+
 struct header_file_location
 {
   char *name;			/* Name of header file */
@@ -494,7 +569,7 @@ struct header_file_location
 /* The actual list and controling variables */
 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
@@ -715,28 +790,54 @@ dbx_lookup_type (typenums)
     }
 }
 
+/* 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;
+  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.  */
+   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 = dbx_lookup_type (typenums);
-  register struct type *type = *type_addr;
+  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 = (struct type *) obstack_alloc (symbol_obstack,
-					    sizeof (struct type));
-      bzero (type, sizeof (struct type));
-      TYPE_VPTR_FIELDNO (type) = -1;
-      *type_addr = type;
+      type = dbx_create_type ();
+      if (type_addr)
+	*type_addr = type;
     }
+  
   return type;
 }
 
@@ -1032,10 +1133,12 @@ start_symtab (name, start_addr)
   current_subfile = 0;
   start_subfile (name);
 
+#if 0 /* This is now set at the beginning of read_ofile_symtab */
   /* Set default for compiler to pcc; assume that we aren't processing
      a gcc compiled file until proved otherwise.  */
 
   processing_gcc_compilation = 0;
+#endif
 }
 
 /* Handle an N_SOL symbol, which indicates the start of
@@ -1130,6 +1233,11 @@ end_symtab (end_addr)
 		    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 ();
+
   /* Finish defining all the blocks of this symtab.  */
   finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr);
   finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr);
@@ -1258,9 +1366,10 @@ init_misc_functions ()
 }
 
 static void
-record_misc_function (name, address)
+record_misc_function (name, address, type)
      char *name;
      CORE_ADDR address;
+     int type;
 {
   register struct misc_bunch *new;
 
@@ -1273,6 +1382,15 @@ record_misc_function (name, address)
     }
   misc_bunch->contents[misc_bunch_index].name = name;
   misc_bunch->contents[misc_bunch_index].address = address;
+  misc_bunch->contents[misc_bunch_index].type = (unsigned char)
+    (type == (N_TEXT | N_EXT) ? mf_text :
+     (type == (N_DATA | N_EXT)
+#ifdef N_SETV
+      || type == (N_SETV | N_EXT)
+#endif
+      ) ? mf_data :
+     type == (N_BSS | N_EXT) ? mf_bss :
+     type == (N_ABS | N_EXT) ? mf_abs : mf_unknown);
   misc_bunch_index++;
   misc_count++;
 }
@@ -1333,7 +1451,7 @@ condense_misc_bunches (inclink)
 	  xxmalloc (misc_count * sizeof (struct misc_function));
       j = 0;
     }
-  
+
   bunch = misc_bunch;
   while (bunch)
     {
@@ -1357,7 +1475,7 @@ condense_misc_bunches (inclink)
 
   /* Sort the misc functions by address.  */
 
-  qsort (misc_function_vector, misc_function_count, 
+  qsort (misc_function_vector, misc_function_count,
 	 sizeof (struct misc_function),
 	 compare_misc_functions);
 }
@@ -1425,22 +1543,31 @@ sort_symtab_syms (s)
 	       sizeof (struct symbol *), compare_symbols);
     }
 }
-  
+
 
 extern struct symtab *psymtab_to_symtab ();
 
+/* The entry point.  */
+static CORE_ADDR entry_point;
+
 /* This is the symbol-file command.  Read the file, analyze its symbols,
    and add a struct symtab to symtab_list.  */
 
 void
-symbol_file_command (name)
+symbol_file_command (name, from_tty)
      char *name;
+     int from_tty;
 {
   register int desc;
   DECLARE_FILE_HEADERS;
   struct nlist *nlist;
+
+  /* The string table.  */
   char *stringtab;
+  
+  /* The size of the string table (buffer is a bizarre name...).  */
   long buffer;
+  
   register int val;
   extern void close ();
   struct cleanup *old_chain;
@@ -1452,6 +1579,7 @@ symbol_file_command (name)
   if (name == 0)
     {
       if ((symtab_list || partial_symtab_list)
+	  && from_tty
 	  && !query ("Discard symbol table? ", 0))
 	error ("Not confirmed.");
       if (symfile)
@@ -1462,6 +1590,9 @@ symbol_file_command (name)
       return;
     }
 
+  name = tilde_expand (name);
+  make_cleanup (free, name);
+
   if ((symtab_list || partial_symtab_list)
       && !query ("Load new symbol table from \"%s\"? ", name))
     error ("Not confirmed.");
@@ -1480,6 +1611,8 @@ symbol_file_command (name)
 
   READ_FILE_HEADERS (desc, name);
 
+  entry_point = ENTRY_POINT;
+
   if (NUMBER_OF_SYMBOLS == 0)
     {
       if (symfile)
@@ -1500,20 +1633,32 @@ symbol_file_command (name)
   val = lseek (desc, STRING_TABLE_OFFSET, 0);
   if (val < 0)
     perror_with_name (name);
-  stat (name, &statbuf);
+  if (stat (name, &statbuf) == -1)
+    error ("internal: error in stat of already open file.");
   READ_STRING_TABLE_SIZE (buffer);
   if (buffer >= 0 && buffer < statbuf.st_size)
-    stringtab = (char *) alloca (buffer);
+    {
+#ifdef BROKEN_LARGE_ALLOCA
+      stringtab = (char *) xmalloc (buffer);
+      make_cleanup (free, stringtab);
+#else
+      stringtab = (char *) alloca (buffer);
+#endif
+    }
   else
     stringtab = NULL;
   if (stringtab == NULL)
-    error ("ridiculous string table size: %d bytes", name, buffer);
+    error ("ridiculous string table size: %d bytes", buffer);
 
-  bcopy (&buffer, stringtab, sizeof buffer);
-  val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
+  /* Usually READ_STRING_TABLE_SIZE will have shifted the file pointer.
+     Occaisionally, it won't.  */
+  val = lseek (desc, STRING_TABLE_OFFSET, L_SET);
   if (val < 0)
     perror_with_name (name);
-
+  val = myread (desc, stringtab, buffer);
+  if (val < 0)
+    perror_with_name (name);
+  
   /* Throw away the old symbol table.  */
 
   if (symfile)
@@ -1525,41 +1670,9 @@ symbol_file_command (name)
   /* Empty the hash table of global syms looking for values.  */
   bzero (global_sym_chain, sizeof global_sym_chain);
 
-#ifdef READ_GDB_SYMSEGS
-  /* That puts us at the symsegs.  Read them.  */
-  symseg_chain = read_symsegs (desc, name);
-  hash_symsegs ();
-
-  /* Free the symtabs made by read_symsegs, but not their contents,
-     which have been copied into symtabs on symtab_list.  */
-  for (symseg = symseg_chain; symseg; symseg = symseg->next)
-    {
-      int i;
-      struct sourcevector *sv = (struct sourcevector *) symseg->linetable;
-
-      for (i = 0; i < sv->length; i++)
-	{
-	  int j;
-	  struct source *source = sv->source[i];
-	  struct symtab *sp1
-	    = (struct symtab *) xxmalloc (sizeof (struct symtab));
-
-	  bcopy (symseg, sp1, sizeof (struct symtab));
-	  sp1->filename = savestring (source->name, strlen (source->name));
-	  sp1->linetable = &source->contents;
-	  sp1->free_code = free_nothing;
-	  sp1->free_ptr = (i == 0) ? (char *) symseg : 0;
-
-	  sp1->next = symtab_list;
-	  symtab_list = sp1;
-	}
-    }
-#else
-  /* Where people are using the 4.2 ld program, must not check for
-     symsegs, because that ld puts randonm garbage at the end of
-     the output file and that would trigger an error message.  */
+  /* Symsegs are no longer supported by GDB.  Setting symseg_chain to
+     0 is easier than finding all the symseg code and eliminating it.  */
   symseg_chain = 0;
-#endif
 
   /* Position to read the symbol table.  Do not read it all at once. */
   val = lseek (desc, SYMBOL_TABLE_OFFSET, 0);
@@ -1584,7 +1697,8 @@ symbol_file_command (name)
   /* Now that the symbol table data of the executable file are all in core,
      process them and define symbols accordingly.  Closes desc.  */
 
-  read_dbx_symtab (desc, stringtab, NUMBER_OF_SYMBOLS, 0, 0, 0);
+  read_dbx_symtab (desc, stringtab, buffer, NUMBER_OF_SYMBOLS, 0,
+		   ADDR_OF_TEXT_SEGMENT, SIZE_OF_TEXT_SEGMENT);
 
   /* Go over the misc functions and install them in vector.  */
 
@@ -1675,19 +1789,19 @@ next_symbol_text ()
  * Initializes storage for all of the partial symbols that will be
  * created by read_dbx_symtab and subsidiaries.
  */
-void 
+void
 init_psymbol_list (total_symbols)
      int total_symbols;
 {
   /* Current best guess is that there are approximately a twentieth
      of the total symbols (in a debugging file) are global or static
      oriented symbols */
-  global_psymbols_allocated = total_symbols / 10;
-  static_psymbols_allocated = total_symbols / 10;
-  next_ps_global = global_psymbols = (struct partial_symbol *)
-    xmalloc (global_psymbols_allocated * sizeof (struct partial_symbol));
-  next_ps_static = static_psymbols = (struct partial_symbol *)
-    xmalloc (static_psymbols_allocated * sizeof (struct partial_symbol));
+  global_psymbols.size = total_symbols / 10;
+  static_psymbols.size = total_symbols / 10;
+  global_psymbols.next = global_psymbols.list = (struct partial_symbol *)
+    xmalloc (global_psymbols.size * sizeof (struct partial_symbol));
+  static_psymbols.next = static_psymbols.list = (struct partial_symbol *)
+    xmalloc (static_psymbols.size * sizeof (struct partial_symbol));
 }
 
 /*
@@ -1764,7 +1878,8 @@ static void end_psymtab();
    style data, setup partial_symtab's describing each source file for
    which debugging information is available.  NLISTLEN is the number
    of symbols in the symbol table.  All symbol names are given as
-   offsets relative to STRINGTAB.
+   offsets relative to STRINGTAB.  STRINGTAB_SIZE is the size of
+   STRINGTAB.
 
    I have no idea whether or not this routine should be setup to deal
    with inclinks.  It seems reasonable to me that they be dealt with
@@ -1772,26 +1887,37 @@ static void end_psymtab();
    them here.
    */
 
-static void process_symbol_for_psymtab ();
-
 static void
-read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
+read_dbx_symtab (desc, stringtab, stringtab_size, nlistlen, inclink,
+		 text_addr, text_size)
      int desc;
      register char *stringtab;
+     register long stringtab_size;
      register int nlistlen;
      int inclink;
      unsigned text_addr;
      int text_size;
 {
+  register struct nlist *bufp;
   register char *namestring;
-  register struct symbol *sym, *prev;
-  int hash;
-  int num_object_files = 0;
+  register struct partial_symbol *psym;
+  register struct psymbol_allocation_list *psymbol_struct;
+
+  int nsl;
   int past_first_source_file = 0;
+  CORE_ADDR last_o_file_start = 0;
   struct cleanup *old_chain;
-  int current_text_start, current_file_symbol_start;
-  struct pending *global_symbols, *static_symbols;
-  int nsl;			/* Length of namestring, when needed */
+  char *p;
+  enum namespace ns;
+  enum address_class class;
+
+#ifdef PROFILE_TYPES
+  int i;
+  int profile_types [256];
+  int strcmp_called = 0;
+  int autovars = 0;
+  int global_funs = 0;
+#endif
 
   /* Current partial symtab */
   struct partial_symtab *pst;
@@ -1805,16 +1931,11 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
   struct partial_symtab **dependency_list;
   int dependencies_used, dependencies_allocated;
 
-  /* Setup a define to deal cleanly with the underscore problem */
-  
-#ifdef NAMES_HAVE_UNDERSCORE
-#define HASH_OFFSET 1
-#else
-#define HASH_OFFSET 0
+#ifdef PROFILE_TYPES
+  for (i = 0; i < 256; i++)
+    profile_types[i] = 0;
 #endif
 
-  global_symbols = static_symbols =
-    (struct pending *) 0;
   pst = (struct partial_symtab *) 0;
 
   includes_allocated = 30;
@@ -1838,34 +1959,80 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
   init_psymbol_list (nlistlen);
 
   last_source_file = 0;
-  
+
 #ifdef END_OF_TEXT_DEFAULT
   end_of_text_addr = END_OF_TEXT_DEFAULT;
+#else
+  end_of_text_addr = text_addr + text_size;
 #endif
-  
+
   symtab_input_desc = desc;	/* This is needed for fill_symbuf below */
   symbuf_end = symbuf_idx = 0;
-  
+
   for (symnum = 0; symnum < nlistlen; symnum++)
     {
-      struct nlist *bufp;
-      unsigned char type;
-      
       /* Get the symbol for this run and pull out some info */
       QUIT;	/* allow this to be interruptable */
       if (symbuf_idx == symbuf_end)
 	fill_symbuf ();
       bufp = &symbuf[symbuf_idx++];
-      type = bufp->n_type;
+
+#ifdef PROFILE_TYPES
+      profile_types[bufp->n_type]++;
+#endif
 
       /*
-       * Special cases to speed up readin.
+       * Special case to speed up readin.
        */
-      if (type == N_SLINE) continue;
+      if (bufp->n_type == N_SLINE) continue;
+
+      /* Ok.  There is a lot of code duplicated in the rest of this
+         switch statiement (for efficiency reasons).  Since I don't
+         like duplicating code, I will do my penance here, and
+         describe the code which is duplicated:
+
+	 *) The assignment to namestring.
+	 *) The call to index.
+	 *) The addition of a partial symbol the the two partial
+	    symbol lists.  This last is a large section of code, so
+	    I've imbedded it in the following macro.
+	 */
       
-      namestring = bufp->n_un.n_strx ? bufp->n_un.n_strx + stringtab : "";
-
-      switch (type)
+/* Set namestring based on bufp.  */
+#define SET_NAMESTRING()\
+  if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)  \
+    error ("Invalid symbol data: bad string table offset: %d",       \
+	   bufp->n_un.n_strx);                                       \
+  namestring = bufp->n_un.n_strx + stringtab
+
+#define	ADD_PSYMBOL_TO_LIST(NAME, NAMELENGTH, NAMESPACE, CLASS, LIST, VALUE)\
+  do {		        						\
+    if ((LIST).next >=							\
+	(LIST).list + (LIST).size)					\
+      {									\
+	(LIST).list = (struct partial_symbol *)				\
+	  xrealloc ((LIST).list,					\
+		    ((LIST).size * 2					\
+		     * sizeof (struct partial_symbol)));		\
+	/* Next assumes we only went one over.  Should be good if	\
+	   program works correctly */					\
+	(LIST).next =							\
+	  (LIST).list + (LIST).size;					\
+	(LIST).size *= 2;						\
+      }									\
+    psym = (LIST).next++;						\
+									\
+    SYMBOL_NAME (psym) = (char *) obstack_alloc (psymbol_obstack,	\
+						 (NAMELENGTH) + 1);	\
+    strncpy (SYMBOL_NAME (psym), (NAME), (NAMELENGTH));			\
+    SYMBOL_NAME (psym)[(NAMELENGTH)] = '\0';				\
+    SYMBOL_NAMESPACE (psym) = (NAMESPACE);				\
+    SYMBOL_CLASS (psym) = (CLASS);					\
+    SYMBOL_VALUE (psym) = (VALUE); 					\
+  } while (0);
+
+
+      switch (bufp->n_type)
 	{
 	  /*
 	   * Standard, non-debugger, symbols
@@ -1874,9 +2041,25 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	case N_TEXT | N_EXT:
 	  /* Catch etext */
 
-	  if (!strcmp (namestring, "_etext"))
+	  SET_NAMESTRING();
+
+	  if (namestring[6] == '\0' && namestring[5] == 't'
+	      && namestring[4] == 'x' && namestring[3] == 'e'
+	      && namestring[2] == 't' && namestring[1] == 'e'
+	      && namestring[0] == '_')
 	    end_of_text_addr = bufp->n_value;
-	  /* Fall through */
+
+	  /* Figure out beginning and end of global linker symbol
+	     section and put non-debugger specified symbols on
+	     tmp_symchain */
+
+	  last_global_sym = symnum;
+	  if (!first_global_sym) first_global_sym = symnum;
+
+	  record_misc_function (namestring, bufp->n_value,
+				bufp->n_type); /* Always */
+
+	  continue;
 
 #ifdef N_NBTEXT
 	case N_NBTEXT | N_EXT:
@@ -1887,44 +2070,73 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 #ifdef N_NBBSS
 	case N_NBBSS | N_EXT:
 #endif
+#ifdef N_SETV
+	case N_SETV | N_EXT:
+#endif
 	case N_ABS | N_EXT:
 	case N_DATA | N_EXT:
 	case N_BSS | N_EXT:
 	  /* Figure out beginning and end of global linker symbol
 	     section and put non-debugger specified symbols on
 	     tmp_symchain */
-	  
+
+	  SET_NAMESTRING();
+
 	  last_global_sym = symnum;
 	  if (!first_global_sym) first_global_sym = symnum;
-	  
-	  record_misc_function (namestring, bufp->n_value); /* Always */
+
+	  /* Not really a function here, but... */
+	  record_misc_function (namestring, bufp->n_value,
+				bufp->n_type); /* Always */
 
 	  continue;
 
 #ifdef N_NBTEXT
 	case N_NBTEXT:
 #endif
+#ifdef OFILE_FN_FLAGGED
+#if ! (N_FN & N_EXT)
+	case N_FN:
+#endif
+	case N_FN | N_EXT:
+#else
 	case N_TEXT:
-	  if (!strcmp (namestring + strlen (namestring) - 2, ".o")
-	      || !strncmp (namestring, "-l", 2))
+#endif
+	  SET_NAMESTRING();
+	  if ((namestring[0] == '-' && namestring[1] == 'l')
+	      || (namestring [(nsl = strlen (namestring)) - 1] == 'o'
+		  && namestring [nsl - 2] == '.'))
 	    {
-	      if (num_object_files++ == 1)
-		first_object_file_end = bufp->n_value;
+	      if (entry_point < bufp->n_value
+		  && entry_point >= last_o_file_start)
+		{
+		  startup_file_start = last_o_file_start;
+		  startup_file_end = bufp->n_value;
+		}
 	      if (past_first_source_file && pst)
 		{
 		  end_psymtab (pst, psymtab_include_list, includes_used,
 			       symnum * sizeof (struct nlist), bufp->n_value,
 			       dependency_list, dependencies_used,
-			       next_ps_global, next_ps_static);
+			       global_psymbols.next, static_psymbols.next);
 		  pst = (struct partial_symtab *) 0;
 		  includes_used = 0;
 		  dependencies_used = 0;
 		}
 	      else
 		past_first_source_file = 1;
+	      last_o_file_start = bufp->n_value;
 	    }
 	  continue;
-	      
+
+#ifdef OFILE_FN_FLAGGED
+	case N_TEXT:
+#else
+#if ! (N_FN & N_EXT)
+	case N_FN:
+#endif
+	case N_FN | N_EXT:
+#endif
 	case N_UNDF:
 	case N_UNDF | N_EXT:
 	case N_ABS:
@@ -1936,9 +2148,9 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 #ifdef N_NBBSS
 	case N_NBBSS:
 #endif
-	case N_FN:
+
 	  /* Keep going . . .*/
-	  
+
 	  /*
 	   * Special symbol types for GNU
 	   */
@@ -1956,10 +2168,9 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	case N_SETB:
 	case N_SETB | N_EXT:
 	case N_SETV:
-	case N_SETV | N_EXT:
 #endif
 	  continue;
-	  
+
 	  /*
 	   * Debugger symbols
 	   */
@@ -1967,23 +2178,25 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	case N_SO:
 	  /* End the current partial symtab and start a new one */
 
-	  if (past_first_source_file && pst)
+	  SET_NAMESTRING();
+
+	  if (pst && past_first_source_file)
 	    {
 	      end_psymtab (pst, psymtab_include_list, includes_used,
 			   symnum * sizeof (struct nlist), bufp->n_value,
 			   dependency_list, dependencies_used,
-			   next_ps_global, next_ps_static);
+			   global_psymbols.next, static_psymbols.next);
 	      pst = (struct partial_symtab *) 0;
 	      includes_used = 0;
 	      dependencies_used = 0;
 	    }
 	  else
 	    past_first_source_file = 1;
-	  
+
 	  pst = start_psymtab (namestring, bufp->n_value,
 			       symnum * sizeof (struct nlist),
-			       next_ps_global, next_ps_static);
-	  
+			       global_psymbols.next, static_psymbols.next);
+
 	  continue;
 
 #ifdef N_BINCL
@@ -1991,14 +2204,54 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	  /* Add this bincl to the bincl_list for future EXCLs.  No
 	     need to save the string; it'll be around until
 	     read_dbx_symtab function return */
+
+	  SET_NAMESTRING();
+
 	  add_bincl_to_list (pst, namestring, bufp->n_value);
 
-	  /* Fall through */
+	  /* Mark down an include file in the current psymtab */
+
+	  psymtab_include_list[includes_used++] = namestring;
+	  if (includes_used >= includes_allocated)
+	    {
+	      char **orig = psymtab_include_list;
+
+	      psymtab_include_list = (char **)
+		alloca ((includes_allocated *= 2) *
+			sizeof (char *));
+	      bcopy (orig, psymtab_include_list,
+		     includes_used * sizeof (char *));
+	    }
+
+	  continue;
 #endif
 
 	case N_SOL:
 	  /* Mark down an include file in the current psymtab */
 
+	  SET_NAMESTRING();
+
+	  /* In C++, one may expect the same filename to come round many
+	     times, when code is coming alternately from the main file
+	     and from inline functions in other files. So I check to see
+	     if this is a file we've seen before.
+
+	     This seems to be a lot of time to be spending on N_SOL, but
+	     things like "break expread.y:435" need to work (I
+	     suppose the psymtab_include_list could be hashed or put
+	     in a binary tree, if profiling shows this is a major hog).  */
+	  {
+	    register int i;
+	    for (i = 0; i < includes_used; i++)
+	      if (!strcmp (namestring, psymtab_include_list[i]))
+		{
+		  i = -1; 
+		  break;
+		}
+	    if (i == -1)
+	      continue;
+	  }
+
 	  psymtab_include_list[includes_used++] = namestring;
 	  if (includes_used >= includes_allocated)
 	    {
@@ -2009,44 +2262,131 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 			sizeof (char *));
 	      bcopy (orig, psymtab_include_list,
 		     includes_used * sizeof (char *));
-#ifdef DEBUG_INFO
-	      fprintf (stderr, "Had to realloc includes.  New size: %d\n",
-		       includes_allocated);
-#endif	      
 	    }
 	  continue;
 
-	case N_FUN:
-	case N_SSYM:
-	case N_GSYM:
-	case N_LSYM:
-	case N_STSYM:
-	case N_LCSYM:
-	case N_ENTRY:
-#ifdef N_MAIN
-	case N_MAIN:
+	case N_LSYM:		/* Typedef or automatic variable. */
+	  SET_NAMESTRING();
+
+	  p = (char *) index (namestring, ':');
+
+	  /* Skip if there is no : or if the thing following the : is
+	     not a letter (which indicates declaration of a local
+	     variable, which we aren't interested in).  */
+	  if (!p) continue;
+
+	  switch (p[1])
+	    {
+	    case 'T':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   STRUCT_NAMESPACE, LOC_TYPEDEF,
+				   static_psymbols, bufp->n_value);
+	      continue;
+	    case 't':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_TYPEDEF,
+				   static_psymbols, bufp->n_value);
+	      continue;
+	    default:
+#ifdef PROFILE_TYPES
+	      if (isalpha(p[1]))
+		  printf ("Funny...LSYM with a letter that isn't a type\n");
+	      autovars++;
 #endif
-#ifdef N_BSLINE
-	case N_BSLINE:
+	      continue;
+	    }
+
+	case N_FUN:
+	  SET_NAMESTRING();
+
+	  p = (char *) index (namestring, ':');
+
+	  if (!p || p[1] == 'F') continue;
+
+#ifdef PROFILE_TYPES
+	  if (p[1] != 'f')
+	    printf ("Funny...FUN with a letter that isn't 'F' or 'f'.\n");
+	  global_funs++;
 #endif
-	case N_PC:
+
+	  ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+			       VAR_NAMESPACE, LOC_BLOCK,
+			       static_psymbols, bufp->n_value);
+
+	  continue;
+
+	case N_GSYM:		/* Global (extern) variable; can be
+				   data or bss (sigh).  */
+	case N_STSYM:		/* Data seg var -- static  */
+	case N_LCSYM:		/* BSS      "  */
+
+	/* Following may probably be ignored; I'll leave them here
+	   for now (until I do Pascal and Modula 2 extensions).  */
+
+	case N_PC:		/* I may or may not need this; I
+				   suspect not.  */
 #ifdef N_M2C
-	case N_M2C:
-	case N_SCOPE:
+	case N_M2C:		/* I suspect that I can ignore this here. */
+	case N_SCOPE:		/* Same.   */
 #endif
-	  /* Process a symbol as appropriate for the type (this
-	     information is contained in the name of the symbol) */
 
-	  if (namestring[0] != '\0')
-#if 1	    
-	    process_symbol_for_psymtab (namestring);
-#else
-	    process_symbol_for_psymtab (namestring, tmp_symchain);
-#endif	  
-	  continue;
+	  SET_NAMESTRING();
+
+	  p = (char *) index (namestring, ':');
+	  if (!p)
+	    continue;		/* Not a debugging symbol.   */
+
+	  process_symbol_for_psymtab:
+
+	  /* Main processing section for debugging symbols which
+	     the initial read through the symbol tables needs to worry
+	     about.  If we reach this point, the symbol which we are
+	     considering is definitely one we are interested in.
+	     p must also contain the (valid) index into the namestring
+	     which indicates the debugging type symbol.  */
+
+	  switch (p[1])
+	    {
+	    case 'c':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_CONST,
+				   static_psymbols, bufp->n_value);
+	      continue;
+	    case 'S':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_STATIC,
+				   static_psymbols, bufp->n_value);
+	      continue;
+	    case 'G':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_EXTERNAL,
+				   global_psymbols, bufp->n_value);
+	      continue;
+
+	    case 't':
+	      ADD_PSYMBOL_TO_LIST (namestring, p - namestring,
+				   VAR_NAMESPACE, LOC_TYPEDEF,
+				   global_psymbols, bufp->n_value);
+	      continue;
+
+	      /* I don't think the default case should happen.  A breakpoint
+		 here to check would probably be good.  */
+	    default:
+	      /* Two things show up here (hopefully); static symbols of
+		 local scope (static used inside braces) or extensions
+		 of structure symbols.  We can ignore both.  */
+	      if (p[1] != 'V' && p[1] != '('
+		  && (p[1] < '0' || p[1] > '9'))
+		fatal ("Internal error: Unexpected debugging symbol type '%c' at symnum %d.\n",
+		       p[1], symnum);
+	      continue;
+	    }
 
 #ifdef N_BINCL
 	case N_EXCL:
+
+	  SET_NAMESTRING();
+
 	  /* Find the corresponding bincl and mark that psymtab on the
 	     psymtab dependency list */
 	  {
@@ -2061,7 +2401,7 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	      {
 		int i;
 		int found = 0;
-		
+
 		for (i = 0; i < dependencies_used; i++)
 		  if (dependency_list[i] == needed_pst)
 		    {
@@ -2071,7 +2411,7 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 
 		/* If it's already in the list, skip the rest.  */
 		if (found) continue;
-		
+
 		dependency_list[dependencies_used++] = needed_pst;
 		if (dependencies_used >= dependencies_allocated)
 		  {
@@ -2095,12 +2435,21 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 		     symnum);
 	  }
 	  continue;
-	  
+
 	case N_EINCL:
 #endif
 #ifdef N_DSLINE
 	case N_DSLINE:
 #endif
+#ifdef N_BSLINE
+	case N_BSLINE:
+#endif
+	case N_SSYM:		/* Claim: Structure or union element.
+				   Hopefully, I can ignore this.  */
+	case N_ENTRY:		/* Alternate entry point; can ignore. */
+#ifdef N_MAIN
+	case N_MAIN:		/* Can definitely ignore this.   */
+#endif
 	case N_LENG:
 	case N_BCOMM:
 	case N_ECOMM:
@@ -2118,142 +2467,70 @@ read_dbx_symtab (desc, stringtab, nlistlen, inclink, text_addr, text_size)
 	default:
 	  /* If we haven't found it yet, we've got problems */
 
-	  if (IGNORE_SYMBOL (type))
+	  if (IGNORE_SYMBOL (bufp->n_type))
 	    continue;
 
-	  fatal ("Bad symbol type 0x%x encountered in gdb scan", type);
+	  fatal ("Bad symbol type 0x%x encountered in gdb scan", bufp->n_type);
 	}
     }
-      
-  if (last_source_file)
+
+  /* If there's stuff to be cleaned up, clean it up.  */
+  if (entry_point < bufp->n_value
+      && entry_point >= last_o_file_start)
+    {
+      startup_file_start = last_o_file_start;
+      startup_file_end = bufp->n_value;
+    }
+
+  if (pst)
     {
       end_psymtab (pst, psymtab_include_list, includes_used,
 		   symnum * sizeof (struct nlist), end_of_text_addr,
 		   dependency_list, dependencies_used,
-		   next_ps_global, next_ps_static);
+		   global_psymbols.next, static_psymbols.next);
       includes_used = 0;
       dependencies_used = 0;
       pst = (struct partial_symtab *) 0;
     }
-  
+
   free_bincl_list ();
   discard_cleanups (old_chain);
-}
-
-/*
- * Take a single symbol (name: NAME) and process it (add it to the
- * app psymbol list or not).
- */
-static void
-process_symbol_for_psymtab (name)
-     char *name;
-{
-  char *p = (char *) index(name, ':') + 1;
-  int deftype;
-  struct partial_symbol *sym;
-  enum { T_IGNORE, T_STATIC, T_GLOBAL } symbol_type;
-  enum namespace ns = UNDEF_NAMESPACE;
-  enum address_class class;
-  int hash;
-
-  if (p == (char *) 0x1)
-    /* No ":" ; I guess it's not a debuggging symbol */
-    return;
-
-  if ((*p >= '0' && *p <= '9') || *p == '(')
-    deftype = 'l';
-  else
-    deftype = *p;
-  
-  /* Figure out how to handle this symbol */
-  switch (deftype)
-    {
-      /* T is a struct/union/enum, t is a typedef */
-    case 'T':
-      symbol_type = T_STATIC;
-      ns = STRUCT_NAMESPACE;
-      class = LOC_TYPEDEF;
-      break;
-    case 't':
-      symbol_type = T_STATIC;
-      ns = VAR_NAMESPACE;
-      class = LOC_TYPEDEF;
-      break;
-    case 'c':
-      symbol_type = T_STATIC;
-      ns = VAR_NAMESPACE;
-      class = LOC_CONST;
-      break;
-    case 'S':
-      symbol_type = T_STATIC;
-      ns = VAR_NAMESPACE;
-      class = LOC_STATIC;
-      break;
-    case 'f':
-      symbol_type = T_STATIC;
-      ns = VAR_NAMESPACE;
-      class = LOC_BLOCK;
-      break;
-    case 'F':
-      symbol_type = T_GLOBAL;
-      ns = VAR_NAMESPACE;
-      class = LOC_BLOCK;
-      break;
-    case 'G':
-      symbol_type = T_GLOBAL;
-      ns = VAR_NAMESPACE;
-      class = LOC_STATIC;
-      break;
-    default:
-      return;
-    }
-  
-  /* Create the symbol and store it on the list */
-  /* There's a better algorithm possible for the allocation; figure
-     out how far through the symbol table we are and do a reestimate */
-  if (symbol_type == T_STATIC)
-    {
-      if (next_ps_static >= static_psymbols + static_psymbols_allocated)
-	{
-	  static_psymbols = (struct partial_symbol *)
-	    xrealloc (static_psymbols,
-		      (static_psymbols_allocated * 2
-		       * sizeof (struct partial_symbol)));
-	  /* Next assumes we only went one over.  Should be good if
-	     program works correctly */
-	  next_ps_static = static_psymbols + static_psymbols_allocated;
-	  static_psymbols_allocated *= 2;
-#ifdef DEBUGINFO
-	  fprintf(stderr, "debuginfo: Had to realloc statics\n");
-#endif
-	}
-      sym = next_ps_static++;
-    }
-  else
-    {
-      if (next_ps_global >= global_psymbols + global_psymbols_allocated)
-	{
-	  global_psymbols = (struct partial_symbol *)
-	    xrealloc (global_psymbols,
-		      (global_psymbols_allocated * 2
-		       * sizeof (struct partial_symbol)));
-	  next_ps_global = global_psymbols + global_psymbols_allocated;
-	  global_psymbols_allocated *= 2;
-#ifdef DEBUGINFO
-	  fprintf(stderr, "debuginfo: Had to realloc globals\n");
+#ifdef PROFILE_TYPES
+  {
+    int i, j;
+#define __define_stab(SYM, NUMBER, NAME)	{NUMBER, NAME},
+  static struct xyzzy {
+    unsigned char symnum;
+    char *name;
+  } tmp_list[] = {
+#include "stab.def"
+    {0x1, "eREF"},
+    {0x2, "ABS"},
+    {0x3, "eABS"},
+    {0x4, "TEXT"},
+    {0x5, "eTEXT"},
+    {0x6, "DATA"},
+    {0x7, "eDATA"},
+    {0x8, "BSS"},
+    {0x9, "eBSS"},
+    {0x12, "COMM"},
+    {0x13, "eCOMM"},
+    {0x1f, "FN"},
+    {0, "Unknown"},
+};
+    for (i = 0; i < 256; i++)
+      {
+	for (j = 0; j < (sizeof (tmp_list) / sizeof (struct xyzzy)) - 1; j++)
+	  if (tmp_list[j].symnum == i)
+	    break;
+	printf ("Symbol \"%s\" (0x%x) occured %d times.\n",
+		tmp_list[j].name, i, profile_types[i]);
+      }
+    printf ("Auto vars (under LSYM): %d\n", autovars);
+    printf ("Global funs (under FUN): %d\n", global_funs);
+  }
 #endif
-	}
-      sym = next_ps_global++;
-    }
-
-  SYMBOL_NAME(sym) = (char *) obstack_alloc (psymbol_obstack,
-					     p - name);
-  strncpy(SYMBOL_NAME(sym), name, p - name - 1);
-  SYMBOL_NAME(sym)[p - name - 1] = '\0';
-  SYMBOL_NAMESPACE(sym) = ns;
-  SYMBOL_CLASS(sym) = class;
 }
-#undef HASH_OFFSET
 
 /*
  * Allocate and partially fill a partial symtab.  It will be
@@ -2270,19 +2547,19 @@ start_psymtab (filename, textlow, ldsymoff, global_syms, static_syms)
   struct partial_symtab *result =
     (struct partial_symtab *) obstack_alloc (psymbol_obstack,
 					     sizeof (struct partial_symtab));
-  
+
   result->filename =
     (char *) obstack_alloc (psymbol_obstack,
 			    strlen (filename) + 1);
   strcpy (result->filename, filename);
-	      
+
   result->textlow = textlow;
   result->ldsymoff = ldsymoff;
 
   result->readin = 0;
 
-  result->globals_offset = global_syms - global_psymbols;
-  result->statics_offset = static_syms - static_psymbols;
+  result->globals_offset = global_syms - global_psymbols.list;
+  result->statics_offset = static_syms - static_psymbols.list;
 
   result->n_global_syms = 0;
   result->n_static_syms = 0;
@@ -2302,7 +2579,7 @@ compare_psymbols (s1, s2)
 	  strcmp (st1 + 1, st2 + 1));
 }
 
-  
+
 /* Close off the current usage of a partial_symbol table entry.  This
    involves setting the correct number of includes (with a realloc),
    setting the high text mark, setting the symbol length in the
@@ -2333,9 +2610,9 @@ end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
   pst->texthigh = capping_text;
 
   pst->n_global_syms =
-    capping_global - (global_psymbols + pst->globals_offset);
+    capping_global - (global_psymbols.list + pst->globals_offset);
   pst->n_static_syms =
-    capping_static - (static_psymbols + pst->statics_offset);
+    capping_static - (static_psymbols.list + pst->statics_offset);
 
   pst->dependencies = (struct partial_symtab **)
     obstack_alloc (psymbol_obstack,
@@ -2377,9 +2654,9 @@ end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
       subpst->next = partial_symtab_list;
       partial_symtab_list = subpst;
     }
-  
+
   /* Sort the global list; don't sort the static list */
-  qsort (global_psymbols + pst->globals_offset, pst->n_global_syms,
+  qsort (global_psymbols.list + pst->globals_offset, pst->n_global_syms,
 	 sizeof (struct partial_symbol), compare_psymbols);
 
   /* Put the psymtab on the psymtab list */
@@ -2387,14 +2664,74 @@ end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
   partial_symtab_list = pst;
 }
 
+
+/* Helper routines for psymtab_to_symtab.  */
+static void scan_file_globals ();
+static void read_ofile_symtab ();
+
+static void
+psymtab_to_symtab_1 (pst, desc, stringtab, stringtab_size, sym_offset)
+     struct partial_symtab *pst;
+     int desc;
+     char *stringtab;
+     int stringtab_size;
+     int sym_offset;
+{
+  struct cleanup *old_chain;
+  int i;
+  
+  if (!pst)
+    return;
+
+  if (pst->readin)
+    {
+      fprintf (stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
+	       pst->filename);
+      return;
+    }
+
+  /* Read in all partial symbtabs on which this one is dependent */
+  for (i = 0; i < pst->number_of_dependencies; i++)
+    if (!pst->dependencies[i]->readin)
+      {
+	/* Inform about additional files that need to be read in.  */
+	if (info_verbose)
+	  {
+	    printf_filtered (" and %s...", pst->dependencies[i]->filename);
+	    fflush (stdout);
+	  }
+	psymtab_to_symtab_1 (pst->dependencies[i], desc,
+			     stringtab, stringtab_size, sym_offset);
+      }
+
+  if (pst->ldsymlen)		/* Otherwise it's a dummy */
+    {
+      /* Init stuff necessary for reading in symbols */
+      free_pendings = 0;
+      pending_blocks = 0;
+      file_symbols = 0;
+      global_symbols = 0;
+      old_chain = make_cleanup (really_free_pendings, 0);
+
+      /* Read in this files symbols */
+      lseek (desc, sym_offset, L_SET);
+      read_ofile_symtab (desc, stringtab, stringtab_size,
+			 pst->ldsymoff,
+			 pst->ldsymlen, pst->textlow,
+			 pst->texthigh - pst->textlow, 0);
+      sort_symtab_syms (symtab_list); /* At beginning since just added */
+
+      do_cleanups (old_chain);
+    }
+
+  pst->readin = 1;
+}
+
 /*
  * Read in all of the symbols for a given psymtab for real.  Return
  * the value of the symtab you create.  Do not free the storage
  * allocated to the psymtab; it may have pointers to it.
  */
-static void scan_file_globals ();
-static void read_ofile_symtab ();
-
 struct symtab *
 psymtab_to_symtab(pst)
      struct partial_symtab *pst;
@@ -2423,90 +2760,78 @@ psymtab_to_symtab(pst)
 	       pst->filename);
       return 0;
     }
-  
+
   if (!name)
     error("No symbol file currently specified; use command symbol-file");
 
-  /* Read in all partial symbtabs on which this one is dependent */
-  for (i = 0; i < pst->number_of_dependencies; i++)
-    if (!pst->dependencies[i]->readin)
-      psymtab_to_symtab (pst->dependencies[i]);
-
-  if (pst->ldsymlen)		/* Otherwise it's a dummy */
+  if (pst->ldsymlen || pst->number_of_dependencies)
     {
+      /* Print the message now, before reading the string table,
+	 to avoid disconcerting pauses.  */
+      if (info_verbose)
+	{
+	  printf_filtered ("Reading in symbols for %s...", pst->filename);
+	  fflush (stdout);
+	}
+
       /* Open symbol file and read in string table */
       stat (name, &statbuf);
       desc = open(name, O_RDONLY, 0); /* symbol_file_command
 					 guarrantees that the symbol file name
 					 will be absolute, so there is no
 					 need for openp */
-      
+
       old_chain = make_cleanup (close, desc);
-      
+
       if (desc < 0)
 	error("Symbol file not readable");
-      
+
       READ_FILE_HEADERS (desc, name);
-      
+
       /* Read in the string table */
       lseek (desc, STRING_TABLE_OFFSET, L_SET);
       READ_STRING_TABLE_SIZE (stsize);
       if (stsize >= 0 && stsize < statbuf.st_size)
-	stringtab = (char *) alloca (stsize);
+	{
+#ifdef BROKEN_LARGE_ALLOCA
+	  stringtab = (char *) xmalloc (stsize);
+	  make_cleanup (free, stringtab);
+#else
+	  stringtab = (char *) alloca (stsize);
+#endif
+	}
       else
 	stringtab = NULL;
       if (stringtab == NULL)
-	error ("ridiculous string table size: %d bytes", name, stsize);
-      
-      bcopy (&stsize, stringtab, sizeof stsize);
-      val = myread (desc, stringtab + sizeof stsize, stsize - sizeof stsize);
+	error ("ridiculous string table size: %d bytes", stsize);
+
+      /* Usually READ_STRING_TABLE_SIZE will have shifted the file pointer.
+	 Occaisionally, it won't.  */
+      val = lseek (desc, STRING_TABLE_OFFSET, L_SET);
+      if (val < 0)
+	perror_with_name (name);
+      val = myread (desc, stringtab, stsize);
       if (val < 0)
 	perror_with_name (name);
-      
-      /* Init stuff necessary for reading in symbols */
-      free_pendings = 0;
-      pending_blocks = 0;
-      file_symbols = 0;
-      global_symbols = 0;
-      make_cleanup (really_free_pendings, 0);
-      
-      /* Read in this files symbols */
-      lseek (desc, SYMBOL_TABLE_OFFSET, L_SET);
-      read_ofile_symtab (desc, stringtab, pst->ldsymoff,
-			 pst->ldsymlen, pst->textlow,
-			 pst->texthigh - pst->textlow, 0);
-      sort_symtab_syms (symtab_list); /* At beginning since just added */
-      
-      /* Match with global symbols */
-      lseek (desc, SYMBOL_TABLE_OFFSET, L_SET);
-      scan_file_globals (desc, stringtab,
-			 first_global_sym * sizeof(struct nlist),
-			 last_global_sym - first_global_sym + 1);
-      
-      do_cleanups (old_chain);
-    }
 
-  /* Find pst in list, prune it, and free it's storage */
-  for (list_patch = &partial_symtab_list;
-       *list_patch && *list_patch != pst;
-       list_patch = &((*list_patch)->next))
-    ;
+      psymtab_to_symtab_1 (pst, desc, stringtab, stsize,
+			   SYMBOL_TABLE_OFFSET);
 
-  if (!(*list_patch))		/* pst not in list.  Don't worry about it? */
-    fatal ("internal: psymtab_to_symtab called with non-listed pst");
+      /* Match with global symbols.  This  only needs to be done once,
+         after all of the symtabs and dependencies have been read in.   */
+      scan_file_globals ();
 
-  *list_patch = (*list_patch)->next; /* Prune */
+      do_cleanups (old_chain);
 
-  pst->readin = 1;		/* Mark as read in */
+      /* Finish up the debug error message.  */
+      if (info_verbose)
+	printf_filtered ("done.\n");
+    }
 
-  /* It's the last one if we actually read something in */
-  if (pst->ldsymlen)
-    return symtab_list;
-  else
-    /* Search through list for correct name. */
-    for (result = symtab_list; result; result = result->next)
-      if (!strcmp (result->filename, pst->filename))
-	return result;
+  /* Search through list for correct name. */
+  for (result = symtab_list; result; result = result->next)
+    if (!strcmp (result->filename, pst->filename))
+      return result;
 
   return 0;
 }
@@ -2514,101 +2839,63 @@ 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.
- *
- * DESC is the file descriptor of the symbol file, with the seek
- * pointer pointing at the beginning of the symbol table.
- * STRINGTAB is the file's string table, already read in.
- * OFFSET is the offset (in bytes) of the beginning of the global
- * symbols from the beginning of the symbol table.
- * NUMSYMS is the number of symbols that have to be checked.
+ * to.  Get these symbols from the misc function list.
  */
 static void
-scan_file_globals (desc, stringtab, offset, numsyms)
-     int desc;
-     char *stringtab;
-     int offset;
-     int numsyms;
+scan_file_globals ()
 {
   int hash;
+  int mf;
 
-  lseek(desc, offset, L_INCR);
-  symtab_input_desc = desc;
-  symbuf_end = symbuf_idx = 0;
-
-  for (symnum = 0; symnum < numsyms; symnum++)
+  for (mf = 0; mf < misc_function_count; mf++)
     {
-      struct nlist *bufp;
-      unsigned char type;
-      char *namestring;
+      char *namestring = misc_function_vector[mf].name;
+      struct symbol *sym, *prev;
 
       QUIT;
-      if (symbuf_idx == symbuf_end)
-	fill_symbuf ();
 
-      bufp = &symbuf[symbuf_idx++];
-      type = bufp->n_type;
+      prev = (struct symbol *) 0;
 
-      if (type & N_EXT && type != N_EXT)
-	{
-	  struct symbol *sym, *prev;
-	  
-	  namestring = bufp->n_un.n_strx ?
-	    bufp->n_un.n_strx + stringtab : "";
-	  prev = (struct symbol *) 0;
+      /* Get the hash index and check all the symbols
+	 under that hash index. */
 
-	  /* Get the hash index and check all the symbols
-	     under that hash index. */
-	  
-#ifdef NAMES_HAVE_UNDERSCORE
-	  hash = hashname (namestring + 1);
-#else /* ! NAMES_HAVE_UNDERSCORE */
-	  hash = hashname (namestring);
-#endif /* ! NAMES_HAVE_UNDERSCORE */
-	  for (sym = global_sym_chain[hash]; sym;)
+      hash = hashname (namestring);
+
+      for (sym = global_sym_chain[hash]; sym;)
+	{
+	  if (*namestring == SYMBOL_NAME (sym)[0]
+	      && !strcmp(namestring + 1, SYMBOL_NAME (sym) + 1))
 	    {
-	      if (
-#ifdef NAMES_HAVE_UNDERSCORE
-		  *namestring == '_'
-		  && namestring[1] == SYMBOL_NAME (sym)[0]
-		  && !strcmp(namestring + 2, SYMBOL_NAME (sym) + 1)
-#else /* ! NAMES_HAVE_UNDERSCORE */
-		  namestring[0] == SYMBOL_NAME (sym) [0]
-		  && !strcmp(namestring + 1, SYMBOL_NAME(sym) + 1)
-#endif /* ! NAMES_HAVE_UNDERSCORE */
-		  )
-		{
-		  /* Splice this symbol out of the hash chain and
-		     assign the value we have to it. */
-		  if (prev)
-		    SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
-		  else
-		    global_sym_chain[hash]
-		      = (struct symbol *) SYMBOL_VALUE (sym);
-		  SYMBOL_VALUE (sym) = bufp->n_value;
-		  if (prev)
-		    sym = (struct symbol *) SYMBOL_VALUE (prev);
-		  else
-		    sym = global_sym_chain[hash];
-		  break;	/* Only one reference per file */
-		}
+	      /* Splice this symbol out of the hash chain and
+		 assign the value we have to it. */
+	      if (prev)
+		SYMBOL_VALUE (prev) = SYMBOL_VALUE (sym);
 	      else
-		{
-		  prev = sym;
-		  sym = (struct symbol *) SYMBOL_VALUE (sym);
-		}
+		global_sym_chain[hash]
+		  = (struct symbol *) SYMBOL_VALUE (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 (sym) = misc_function_vector[mf].address;
+	      
+	      if (prev)
+		sym = (struct symbol *) SYMBOL_VALUE (prev);
+	      else
+		sym = global_sym_chain[hash];
+	    }
+	  else
+	    {
+	      prev = sym;
+	      sym = (struct symbol *) SYMBOL_VALUE (sym);
 	    }
 	}
     }
-  /* There shouldn't be anything left on the hash list at this point.
-     If there is, we have done something wrong.  For right now it's
-     worth checking, until I get the bugs out. */
-  /* Sigh.  Unfortunately, the above is not true.  If an extern
-     variable is mentioned in an include file (or a program) and the
-     variable is never either referenced or defined, there will be a
-     debugger symbol with no "real" symbol.  Oh well. */
 }
-	      
+
 /*
  * Read in a defined section of a specific object file's symbols.
  *
@@ -2624,11 +2911,11 @@ scan_file_globals (desc, stringtab, offset, numsyms)
  * TEXT_SIZE is the size of the text segment read in.
  * OFFSET is a flag which indicates that the value of all of the
  * symbols should be offset by TEXT_OFFSET (for the purposes of
- * incremental linking). 
+ * incremental linking).
  */
-    
+
 static void
-read_ofile_symtab (desc, stringtab, sym_offset,
+read_ofile_symtab (desc, stringtab, stringtab_size, sym_offset,
 		   sym_size, text_offset, text_size, offset)
      int desc;
      register char *stringtab;
@@ -2653,9 +2940,39 @@ read_ofile_symtab (desc, stringtab, sym_offset,
 
   symtab_input_desc = desc;
   symbuf_end = symbuf_idx = 0;
-  lseek(desc, sym_offset, L_INCR);
 
-  fill_symbuf();
+  /* It is necessary to actually read one symbol *before* the start
+     of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
+     occurs before the N_SO symbol.
+
+     Detecting this in read_dbx_symtab
+     would slow down initial readin, so we look for it here instead.  */
+  if (sym_offset >= sizeof (struct nlist))
+    {
+      lseek (desc, sym_offset - sizeof (struct nlist), L_INCR);
+      fill_symbuf ();
+      bufp = &symbuf[symbuf_idx++];
+
+      if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)
+	error ("Invalid symbol data: bad string table offset: %d",
+	       bufp->n_un.n_strx);
+      namestring = bufp->n_un.n_strx + stringtab;
+
+      processing_gcc_compilation =
+	(bufp->n_type == N_TEXT
+	 && !strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL));
+    }
+  else
+    {
+      /* The N_SO starting this symtab is the first symbol, so we
+	 better not check the symbol before it.  I'm not this can
+	 happen, but it doesn't hurt to check for it.  */
+      lseek(desc, sym_offset, L_INCR);
+      processing_gcc_compilation = 0;
+    }
+
+  if (symbuf_idx == symbuf_end)
+    fill_symbuf();
   bufp = &symbuf[symbuf_idx];
   if ((unsigned char) bufp->n_type != N_SO)
     fatal("First symbol in segment of executable not a source symbol");
@@ -2674,7 +2991,10 @@ read_ofile_symtab (desc, stringtab, sym_offset,
 	  (type == N_TEXT || type == N_DATA || type == N_BSS))
 	bufp->n_value += text_offset;
 
-      namestring = bufp->n_un.n_strx ? bufp->n_un.n_strx + stringtab : "";
+      if (bufp->n_un.n_strx < 0 || bufp->n_un.n_strx >= stringtab_size)
+	error ("Invalid symbol data: bad string table offset: %d",
+	       bufp->n_un.n_strx);
+      namestring = bufp->n_un.n_strx + stringtab;
 
       if (type & N_STAB)
 	process_one_symbol(type, bufp->n_desc,
@@ -2683,6 +3003,11 @@ read_ofile_symtab (desc, stringtab, sym_offset,
          happen in this routine. */
       else if (type == N_TEXT
 	       && !strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL))
+	/* I don't think this code will ever be executed, because
+	   the GCC_COMPILED_FLAG_SYMBOL usually is right before
+	   the N_SO symbol which starts this source file.
+	   However, there is no reason not to accept
+	   the GCC_COMPILED_FLAG_SYMBOL anywhere.  */
 	processing_gcc_compilation = 1;
       else if (type & N_EXT || type == N_TEXT
 #ifdef N_NBTEXT
@@ -2768,6 +3093,7 @@ process_one_symbol (type, desc, value, name)
      char *name;
 {
   register struct context_stack *new;
+  char *colon_pos;
 
   /* Something is wrong if we see real data before
      seeing a source file name.  */
@@ -2775,7 +3101,7 @@ process_one_symbol (type, desc, value, name)
   if (last_source_file == 0 && type != N_SO)
     {
       /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
-	 where that code is defined, and all symbols on the Convex. */
+	 where that code is defined.  */
       if (IGNORE_SYMBOL (type))
 	return;
 
@@ -2790,7 +3116,17 @@ process_one_symbol (type, desc, value, name)
 	 a new function.  We must process its "name" normally for dbx,
 	 but also record the start of a new lexical context, and possibly
 	 also the end of the lexical context for the previous function.  */
-      
+      /* This is not always true.  This type of symbol may indicate a
+         text segment variable.  */
+
+      colon_pos = index (name, ':');
+      if (!colon_pos++
+	  || (*colon_pos != 'f' && *colon_pos != 'F'))
+	{
+	  define_symbol (value, name, desc);
+	  break;
+	}
+
       within_function = 1;
       if (context_stack_depth > 0)
 	{
@@ -2835,11 +3171,19 @@ process_one_symbol (type, desc, value, name)
 
     case N_RBRAC:
       /* This "symbol" just indicates the end of an inner lexical
-	 context that was started with N_RBRAC.  */
+	 context that was started with N_LBRAC.  */
       new = &context_stack[--context_stack_depth];
       if (desc != new->depth)
 	error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
-      local_symbols = new->locals;
+
+      /* Can only use new->locals as local symbols here if we're in
+         gcc or on a machine that puts them before the lbrack.  */
+      /* Some native compilers put the variable decls inside of an
+         LBRAC/RBRAC block.  */
+#ifdef VARIABLES_INSIDE_BLOCK
+      if (processing_gcc_compilation)
+#endif
+	local_symbols = new->locals;
 
       /* If this is not the outermost LBRAC...RBRAC pair in the
 	 function, its local symbols preceded it, and are the ones
@@ -2847,10 +3191,16 @@ process_one_symbol (type, desc, value, name)
 
 	 If this is the outermost LBRAC...RBRAC pair, there is no
 	 need to do anything; leave the symbols that preceded it
-	 to be attached to the function's own block.  */
+	 to be attached to the function's own block.  However, if
+	 it is so, we need to indicate that we just moved outside
+	 of the function.  */
+#ifdef VARIABLES_INSIDE_BLOCK
+      if (local_symbols && context_stack_depth > processing_gcc_compilation)
+#else
       if (local_symbols && context_stack_depth > 1)
+#endif
 	{
-	  /* Muzzle a compiler bug that makes end > start.  */
+	  /* Muzzle a compiler bug that makes end < start.  */
 	  if (new->start_addr > value)
 	    new->start_addr = value;
 	  /* Make a block for the local symbols within.  */
@@ -2858,9 +3208,18 @@ process_one_symbol (type, desc, value, name)
 			new->start_addr + last_source_start_addr,
 			value + last_source_start_addr);
 	}
+      else
+	{
+	  within_function = 0;
+	}
+#ifdef VARIABLES_INSIDE_BLOCK
+      /* gcc: normal.  pcc: now pop locals of block just finished.  */
+      if (!processing_gcc_compilation)
+	local_symbols = new->locals;
+#endif
       break;
 
-    case N_FN:
+    case N_FN | N_EXT:
       /* This kind of symbol supposedly indicates the start
 	 of an object file.  In fact this type does not appear.  */
       break;
@@ -2870,6 +3229,14 @@ process_one_symbol (type, desc, value, name)
 	 for one source file.
 	 Finish the symbol table of the previous source file
 	 (if any) and start accumulating a new symbol table.  */
+#ifdef PCC_SOL_BROKEN
+      /* pcc bug, occasionally puts out SO for SOL.  */
+      if (context_stack_depth > 0)
+	{
+	  start_subfile (name);
+	  break;
+	}
+#endif
       if (last_source_file)
 	end_symtab (value);
       start_symtab (name, value);
@@ -2907,7 +3274,36 @@ process_one_symbol (type, desc, value, name)
       break;
 
     case N_BCOMM:
+      if (common_block)
+	error ("Invalid symbol data: common within common at symtab pos %d",
+	       symnum);
+      common_block = local_symbols;
+      common_block_i = local_symbols ? local_symbols->nsyms : 0;
+      break;
+
     case N_ECOMM:
+      /* Symbols declared since the BCOMM are to have the common block
+	 start address added in when we know it.  common_block points to
+	 the first symbol after the BCOMM in the local_symbols list;
+	 copy the list and hang it off the symbol for the common block name
+	 for later fixup.  */
+      {
+	int i;
+	struct pending *link = local_symbols;
+	struct symbol *sym =
+	  (struct symbol *) xmalloc (sizeof (struct symbol));
+	bzero (sym, sizeof *sym);
+	SYMBOL_NAME (sym) = savestring (name, strlen (name));
+	SYMBOL_CLASS (sym) = LOC_BLOCK;
+	SYMBOL_NAMESPACE (sym) = (enum namespace)
+	  copy_pending (local_symbols, common_block_i, common_block);
+	i = hashname (SYMBOL_NAME (sym));
+	SYMBOL_VALUE (sym) = (int) global_sym_chain[i];
+	global_sym_chain[i] = sym;
+	common_block = 0;
+	break;
+      }
+
     case N_ECOML:
     case N_LENG:
       break;
@@ -2924,7 +3320,7 @@ process_one_symbol (type, desc, value, name)
 
 static void
 condense_addl_misc_bunches ()
-{ 
+{
   register int i, j;
   register struct misc_bunch *bunch;
 #ifdef NAMES_HAVE_UNDERSCORE
@@ -2964,7 +3360,7 @@ condense_addl_misc_bunches ()
 
 
 /* Read in another .o file and create a symtab entry for it.*/
- 
+
 static void
 read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
      int desc;
@@ -2977,7 +3373,6 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
   register char *namestring;
   register struct symbol *sym, *prev;
   int hash;
-  int num_object_files = 0;
 
 #ifdef N_BINCL
   subfile_stack = 0;
@@ -2999,13 +3394,13 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 	fill_symbuf ();
       bufp = &symbuf[symbuf_idx++];
       type = bufp->n_type & N_TYPE;
-      namestring = bufp->n_un.n_strx ? bufp->n_un.n_strx + stringtab : "";
+      namestring = bufp->n_un.n_strx + stringtab;
 
       if( (type == N_TEXT) || (type == N_DATA) || (type == N_BSS) )
 	{
 	  /* Relocate this file's symbol table information
 	     to the address it has been loaded into.  */
-	  bufp->n_value += text_addr;        
+	  bufp->n_value += text_addr;
 	}
 
       type = bufp->n_type;
@@ -3025,10 +3420,8 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 #endif
 		)
 	       && (!strcmp (namestring + strlen (namestring) - 2, ".o"))
-	       || ! strcmp (namestring, "-l", 2))
+	       || ! strncmp (namestring, "-l", 2))
 	{
-	  if (num_object_files++ == 1)
-	    first_object_file_end = bufp->n_value;
 	  if (last_source_file)
 	    end_symtab (bufp->n_value);
 	}
@@ -3045,6 +3438,13 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 	      && !strcmp (namestring, "_etext"))
 	    end_of_text_addr = bufp->n_value;
 
+#if 0
+	  /* 25 Sep 89: The following seems to be stolen from
+	     read_ofile_symtab, and is wrong here (i.e. there was no
+	     first pass for add-file symbols).  */
+	  /* This shouldn't be necessary, as we now do all of this work
+	     in scan_global syms and all misc functions should have been
+	     recorded on the first pass.  */
 	  /* Global symbol: see if we came across a dbx definition
 	     for a corresponding symbol.  If so, store the value.
 	     Remove syms from the chain when their values are stored,
@@ -3079,7 +3479,10 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 		      else
 			global_sym_chain[hash]
 			  = (struct symbol *) SYMBOL_VALUE (sym);
-		      SYMBOL_VALUE (sym) = bufp->n_value;
+		      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
+			fix_common_block (sym, bufp->n_value);
+		      else
+			SYMBOL_VALUE (sym) = bufp->n_value;
 		      if (prev)
 			sym = (struct symbol *) SYMBOL_VALUE (prev);
 		      else
@@ -3100,7 +3503,9 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 	  if (type <= (N_TYPE | N_EXT)
 	      && type != N_EXT
 	      && ! used_up)
-	    record_misc_function (namestring, bufp->n_value);
+	    record_misc_function (namestring, bufp->n_value,
+				  bufp->n_type);
+#endif /* 0 */
 	}
     }
 
@@ -3113,13 +3518,13 @@ read_addl_syms (desc, stringtab, nlistlen, text_addr, text_size)
 /* C++:
    This function allows the addition of incrementally linked object files.
    Since this has a fair amount of code in common with symbol_file_command,
-   it might be worthwhile to consolidate things, as was done with 
+   it might be worthwhile to consolidate things, as was done with
    read_dbx_symtab and condense_misc_bunches. */
 
 void
 add_file_command (arg_string)
      char* arg_string;
-{ 
+{
   register int desc;
   DECLARE_FILE_HEADERS;
   struct nlist *nlist;
@@ -3132,10 +3537,13 @@ add_file_command (arg_string)
   struct stat statbuf;
   char *name;
   unsigned text_addr;
-  
+
   if (arg_string == 0)
     error ("add-file takes a file name and an address");
 
+  arg_string = tilde_expand (arg_string);
+  make_cleanup (free, arg_string);
+
   for( ; *arg_string == ' '; arg_string++ );
   name = arg_string;
   for( ; *arg_string && *arg_string != ' ' ; arg_string++ );
@@ -3148,29 +3556,28 @@ add_file_command (arg_string)
 
   dont_repeat ();
 
-  if (!query ("add symbol table from filename \"%s\" at text_addr = 0x%x\n", 
+  if (!query ("add symbol table from filename \"%s\" at text_addr = 0x%x\n",
 	      name, text_addr))
     error ("Not confirmed.");
 
   desc = open (name, O_RDONLY);
   if (desc < 0)
     perror_with_name (name);
-  
+
   old_chain = make_cleanup (close, desc);
-  make_cleanup (free_current_contents, &name);
-  
+
   READ_FILE_HEADERS (desc, name);
-  
+
   if (NUMBER_OF_SYMBOLS == 0)
     {
       printf ("%s does not have a symbol-table.\n", name);
       fflush (stdout);
       return;
     }
-  
+
   printf ("Reading symbol data from %s...", name);
   fflush (stdout);
-  
+
   /* Now read the string table, all at once.  */
   val = lseek (desc, STRING_TABLE_OFFSET, 0);
   if (val < 0)
@@ -3178,58 +3585,37 @@ add_file_command (arg_string)
   stat (name, &statbuf);
   READ_STRING_TABLE_SIZE (buffer);
   if (buffer >= 0 && buffer < statbuf.st_size)
-    stringtab = (char *) alloca (buffer);
+    {
+#ifdef BROKEN_LARGE_ALLOCA
+      stringtab = (char *) xmalloc (buffer);
+      make_cleanup (free, stringtab);
+#else
+      stringtab = (char *) alloca (buffer);
+#endif
+    }
   else
     stringtab = NULL;
   if (stringtab == NULL)
-    error ("ridiculous string table size: %d bytes", name, buffer);
-  
-  bcopy (&buffer, stringtab, sizeof buffer);
-  val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
+    error ("ridiculous string table size: %d bytes", buffer);
+
+  /* Usually READ_STRING_TABLE_SIZE will have shifted the file pointer.
+     Occaisionally, it won't.  */
+  val = lseek (desc, STRING_TABLE_OFFSET, 0);
+  if (val < 0)
+    perror_with_name (name);
+  val = myread (desc, stringtab, buffer);
   if (val < 0)
     perror_with_name (name);
-  
-#ifdef READ_GDB_SYMSEGS
-  /* That puts us at the symsegs.  Read them.  */
-  symseg_chain = read_symsegs (desc, name);
-  hash_symsegs ();
-
-  /* Free the symtabs made by read_symsegs, but not their contents,
-     which have been copied into symtabs on symtab_list.  */
-  for (symseg = symseg_chain; symseg; symseg = symseg->next)
-    {
-      int i;
-      struct sourcevector *sv = (struct sourcevector *) symseg->linetable;
 
-      for (i = 0; i < sv->length; i++)
-	{
-	  int j;
-	  struct source *source = sv->source[i];
-	  struct symtab *sp1
-	    = (struct symtab *) xxmalloc (sizeof (struct symtab));
-
-	  bcopy (symseg, sp1, sizeof (struct symtab));
-	  sp1->filename = savestring (source->name, strlen (source->name));
-	  sp1->linetable = &source->contents;
-	  sp1->free_code = free_nothing;
-	  sp1->free_ptr = (i == 0) ? (char *) symseg : 0;
-
-	  sp1->next = symtab_list;
-	  symtab_list = sp1;
-	}
-    }
-#else
-  /* Where people are using the 4.2 ld program, must not check for
-     symsegs, because that ld puts randonm garbage at the end of
-     the output file and that would trigger an error message.  */
+  /* Symsegs are no longer supported by GDB.  Setting symseg_chain to
+     0 is easier than finding all the symseg code and eliminating it.  */
   symseg_chain = 0;
-#endif
-  
+
   /* Position to read the symbol table.  Do not read it all at once. */
   val = lseek (desc, SYMBOL_TABLE_OFFSET, 0);
   if (val < 0)
     perror_with_name (name);
-  
+
   init_misc_functions ();
   make_cleanup (discard_misc_bunches, 0);
   init_header_files ();
@@ -3242,27 +3628,22 @@ add_file_command (arg_string)
 
   read_addl_syms (desc, stringtab, NUMBER_OF_SYMBOLS, text_addr,
 		  SIZE_OF_TEXT_SEGMENT);
-		  
-  
+
+
   /* Sort symbols alphabetically within each block.  */
-  
+
   sort_syms ();
-  
+
   /* Go over the misc functions and install them in vector.  */
-  
+
   condense_addl_misc_bunches (1);
-  
+
   /* Don't allow char * to have a typename (else would get caddr_t.)  */
-  
+
   TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
-  
-  /* Make a default for file to list.  */
-  /* Hmmm.  I'd say we don't want this in add_file_command, but . . . */
-  
-  select_source_symtab (symtab_list);
-  
+
   do_cleanups (old_chain);
-  
+
   /* Free the symtabs made by read_symsegs, but not their contents,
      which have been copied into symtabs on symtab_list.  */
   while (symseg_chain)
@@ -3271,7 +3652,7 @@ add_file_command (arg_string)
       free (symseg_chain);
       symseg_chain = s;
     }
-  
+
   printf ("done.\n");
   fflush (stdout);
 }
@@ -3292,6 +3673,10 @@ define_symbol (value, string, desc)
   if (string[0] == 0)
     return 0;
 
+  /* Ignore old-style symbols from cc -go  */
+  if (p == 0)
+    return 0;
+
   SYMBOL_NAME (sym)
     = (char *) obstack_alloc (symbol_obstack, ((p - string) + 1));
   /* Open-coded bcopy--saves function call time.  */
@@ -3327,14 +3712,14 @@ define_symbol (value, string, desc)
 	    value = (char *) obstack_alloc (symbol_obstack, sizeof (double));
 	    bcopy (&d, value, sizeof (double));
 	    SYMBOL_VALUE_BYTES (sym) = value;
-	    SYMBOL_CLASS (sym) = LOC_CONST;
+	    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_BYTES;
+	    SYMBOL_CLASS (sym) = LOC_CONST;
 	  }
 	  break;
 	default:
@@ -3358,11 +3743,11 @@ define_symbol (value, string, desc)
       SYMBOL_TYPE (sym)
 	= lookup_pointer_type (lookup_function_type (read_type (&p)));
     }
-  else 
+  else
     {
       struct type *type = read_type (&p);
-      
-      if ((deftype == 'F' || deftype == 'f') 
+
+      if ((deftype == 'F' || deftype == 'f')
 	  && TYPE_CODE (type) != TYPE_CODE_FUNC)
 	SYMBOL_TYPE (sym) = lookup_function_type (type);
       else
@@ -3411,9 +3796,8 @@ define_symbol (value, string, desc)
       SYMBOL_VALUE (sym) = value;
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       add_symbol_to_list (sym, &local_symbols);
-      /* DESC == 0 implies compiled with GCC.
-	 In this case, if it says `short', believe it.  */
-      if (desc == 0)
+      /* If it's compiled, if it says `short', believe it.  */
+      if (processing_gcc_compilation || BELIEVE_PCC_PROMOTION)
 	break;
       /* If PCC says a parameter is a short or a char,
 	 it is really an int.  */
@@ -3427,14 +3811,14 @@ define_symbol (value, string, desc)
 
     case 'P':
       SYMBOL_CLASS (sym) = LOC_REGPARM;
-      SYMBOL_VALUE (sym) = value;
+      SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (value);
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       add_symbol_to_list (sym, &local_symbols);
       break;
 
     case 'r':
       SYMBOL_CLASS (sym) = LOC_REGISTER;
-      SYMBOL_VALUE (sym) = value;
+      SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (value);
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       add_symbol_to_list (sym, &local_symbols);
       break;
@@ -3470,7 +3854,7 @@ define_symbol (value, string, desc)
 	       TYPE_FIELD_NAME (SYMBOL_TYPE (sym), i - 1) =
 		 TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym), i));
 	 }
-      
+
       add_symbol_to_list (sym, &file_symbols);
       break;
 
@@ -3491,7 +3875,6 @@ define_symbol (value, string, desc)
       break;
 
     case 'V':
-    case 'v':
       /* Static symbol of local scope */
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_VALUE (sym) = value;
@@ -3499,12 +3882,84 @@ define_symbol (value, string, desc)
       add_symbol_to_list (sym, &local_symbols);
       break;
 
+    case 'v':
+      /* Reference parameter */
+      SYMBOL_CLASS (sym) = LOC_REF_ARG;
+      SYMBOL_VALUE (sym) = value;
+      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, *ntype;
+  struct symbol *sym;
+
+  for (type = undef_types; type < undef_types + undef_types_length; type++)
+    {
+      struct type *ntype = 0;
+      /* 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;
+}
+
+
+
 /* 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).
@@ -3547,40 +4002,140 @@ read_type (pp)
   struct type *type1;
   int typenums[2];
   int xtypenums[2];
+  char *tmpc;
 
-  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);
+  /* 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;
+      *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':
-      type = dbx_alloc_type (typenums);
-      /* Set the type code according to the following letter.  */
-      switch ((*pp)[0])
+      {
+	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;
+
 	{
-	case 's':
-	  TYPE_CODE (type) = TYPE_CODE_STRUCT;
-	  break;
-	case 'u':
-	  TYPE_CODE (type) = TYPE_CODE_UNION;
-	  break;
-	case 'e':
-	  TYPE_CODE (type) = TYPE_CODE_ENUM;
-	  break;
+	  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:
+	      error ("Bad type cross reference at symnum: %d.", symnum);
+	    }
+	  
+	  to = type_name = (char *)
+	    obstack_alloc (symbol_obstack,
+			   (strlen (prefix) +
+			    ((char *) index (*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;
+	
+	  /* 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 *) index (*pp, ',');
+	  if (from)
+	    *pp = from;
 	}
-      /* Skip the name the cross-ref points to.  */
-      /* 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.)  */
-      *pp = (char *) index (*pp, ',');
-      /* Just allocate the type and leave it zero if nothing known */
-      return dbx_alloc_type (typenums);
+
+	/* 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':
@@ -3598,15 +4153,17 @@ read_type (pp)
       type = *dbx_lookup_type (xtypenums);
       if (type == 0)
 	type = builtin_type_void;
-      *dbx_lookup_type (typenums) = type;
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
       break;
-      
+
     case '*':
       type1 = read_type (pp);
       if (TYPE_POINTER_TYPE (type1))
 	{
 	  type = TYPE_POINTER_TYPE (type1);
-	  *dbx_lookup_type (typenums) = type;
+	  if (typenums[0] != -1)
+	    *dbx_lookup_type (typenums) = type;
 	}
       else
 	{
@@ -3631,12 +4188,31 @@ read_type (pp)
       }
       break;
 
+    case '#':
+      {
+	struct type *domain = read_type (pp);
+	char c;
+	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);
       if (TYPE_REFERENCE_TYPE (type1))
 	{
 	  type = TYPE_REFERENCE_TYPE (type1);
-	  *dbx_lookup_type (typenums) = type;
+	  if (typenums[0] != -1)
+	    *dbx_lookup_type (typenums) = type;
 	}
       else
 	{
@@ -3650,7 +4226,8 @@ read_type (pp)
       if (TYPE_FUNCTION_TYPE (type1))
 	{
 	  type = TYPE_FUNCTION_TYPE (type1);
-	  *dbx_lookup_type (typenums) = type;
+	  if (typenums[0] != -1)
+	    *dbx_lookup_type (typenums) = type;
 	}
       else
 	{
@@ -3661,7 +4238,8 @@ read_type (pp)
 
     case 'r':
       type = read_range_type (pp, typenums);
-      *dbx_lookup_type (typenums) = type;
+      if (typenums[0] != -1)
+	*dbx_lookup_type (typenums) = type;
       break;
 
     case 'e':
@@ -3685,43 +4263,11 @@ read_type (pp)
       if (*(*pp)++ != 'r')
 	error ("Invalid symbol data: unrecognized type-code `a%c' %s %d.",
 	       (*pp)[-1], "at symtab position", symnum);
-      
+
       type = dbx_alloc_type (typenums);
       type = read_array_type (pp, type);
       break;
 
-#if 0
-      /* Format of an array type:
-	 "ar<index type>;lower;upper;<array_contents_type>".  Put code
-	 in to handle this.  */
-
-      /* dbx expresses array types in terms of a range type for the index,
-	 and that range type is specified right inside the array type spec
-	 making ar1;MIN;MAX;VALTYPE  */
-      if (!strncmp (*pp, "r1;0;", 5))
-	(*pp) += 5;
-      else if (!strncmp (*pp, "r(0,1);0;", 9))
-	(*pp) += 9;
-      else break;
-
-      TYPE_CODE (type) = TYPE_CODE_ARRAY;
-      /* In Fortran, an upper bound may be T... meaning a parameter specifies
-	 the length of the data.  In this case, just pretend the bound is 1.
-	 This happens only for array parameters, which are really passed
-	 as pointers anyway, and we will translate them into such.  */
-      if (**pp == 'T')
-	{
-	  n = 1;
-	  while (**pp != ';')
-	    (*pp)++;
-	}
-      else
-	n = read_number (pp, ';') + 1;
-      TYPE_TARGET_TYPE (type) = read_type (pp);
-      TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type)) * n;
-      break;
-#endif
-
     default:
       error ("Invalid symbol data: unrecognized type-code `%c' at symtab pos %d.",
 	     (*pp)[-1], symnum);
@@ -3788,6 +4334,11 @@ read_struct_type (pp, type)
   struct type *baseclass = NULL;
   int read_possible_virtual_info = 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.  */
@@ -3804,8 +4355,18 @@ read_struct_type (pp, type)
       int i, n_baseclasses, offset;
       struct type **baseclass_vec;
       struct type *baseclass;
-      int via_public, via_virtual;
-      
+      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, ',');
@@ -3848,6 +4409,15 @@ read_struct_type (pp, type)
 	  *pp += 1;		/* skip trailing ';' */
 	  baseclass_vec[i] = lookup_basetype_type (baseclass, offset, via_virtual, via_public);
 
+          /* Since lookup_basetype_type can copy the type,
+	     it might copy a stub type (complete with stub flag).
+	     If so, we need to add it to the list of undefined types
+	     to clean up later.  Even if lookup_basetype_type
+	     didn't copy the type, adding it to the undefined list
+	     will not do any harm.  */
+          if (TYPE_FLAGS(baseclass_vec[i]) & TYPE_FLAG_STUB)
+            add_undefined_type (baseclass_vec[i]);
+
 	  /* Make this baseclass visible for structure-printing purposes.  */
 	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
 	  new->next = list;
@@ -3871,6 +4441,9 @@ read_struct_type (pp, type)
      The `?' is a placeholder for one of '+' (public visibility),
      '0' (protected visibility), and '-' (private visibility).  */
 
+  /* We better set p right now, in case there are no fields at all...    */
+  p = *pp;
+
   while (**pp != ';')
     {
       int visibility;
@@ -3908,7 +4481,7 @@ read_struct_type (pp, type)
  	      visibility = 1;
  	      *pp += 1;
  	      break;
- 
+
  	    case '2':
  	      visibility = 2;
  	      *pp += 1;
@@ -3934,20 +4507,54 @@ read_struct_type (pp, type)
       (*pp)++;			/* Skip the comma.  */
       list->field.bitpos = read_number (pp, ',');
       list->field.bitsize = read_number (pp, ';');
-      /* 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++;
+
+      /* 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)
+	{
+	  /* Have we given the warning yet?  */
+	  static int warning_given = 0;
+
+	  /* Only give the warning once, no matter how many class
+	     variables there are.  */
+	  if (!warning_given)
+	    {
+	      warning_given = 1;
+	      fprintf_filtered (stderr, "\n\
+Warning:  DBX-style class variable debugging information encountered.\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.\n\
+");
+	    }
+
+	  /* Ignore this field.  */
+	  list = list->next;
+	}
+      else
+	{
+	  /* 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++;
+	}
     }
 
   /* Now come the method fields, as NAME::methods
@@ -4012,7 +4619,12 @@ read_struct_type (pp, type)
 	      if (**pp == '\\') *pp = next_symbol_text ();
 
 	      new_sublist->fn_field.type = read_type (pp);
-	      new_sublist->fn_field.args = read_args (pp, ':');
+	      if (**pp != ':')
+		error ("invalid symtab info for method at symbol number %d.",
+		       symnum);
+	      *pp += 1;
+	      new_sublist->fn_field.args =
+		TYPE_ARG_TYPES (new_sublist->fn_field.type);
 	      p = *pp;
 	      while (*p != ';') p++;
 	      new_sublist->fn_field.physname = savestring (*pp, p - *pp);
@@ -4020,10 +4632,22 @@ read_struct_type (pp, type)
 	      new_sublist->visibility = *(*pp)++ - '0';
 	      if (**pp == '\\') *pp = next_symbol_text ();
 
-	      if (*(*pp)++ == '*')
-		new_sublist->fn_field.voffset = read_number (pp, ';') + 1;
-	      else
-		new_sublist->fn_field.voffset = 0;
+	      switch (*(*pp)++)
+		{
+		case '*':
+		  /* virtual member function, followed by index.  */
+		  new_sublist->fn_field.voffset = read_number (pp, ';') + 1;
+		  break;
+		case '?':
+		  /* static member function.  */
+		  new_sublist->fn_field.voffset = 1;
+		  break;
+		default:
+		  /* **pp == '.'.  */
+		  /* normal member function.  */
+		  new_sublist->fn_field.voffset = 0;
+		  break;
+		}
 
 	      new_sublist->next = sublist;
 	      sublist = new_sublist;
@@ -4165,7 +4789,7 @@ read_struct_type (pp, type)
   return type;
 }
 
-/* Read a definition of an enumberation 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.  */
@@ -4176,18 +4800,41 @@ read_array_type (pp, 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.  */
+     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)++ != ';')
     error ("Invalid symbol data; improper format of array type decl.");
+
+  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,
@@ -4246,8 +4893,8 @@ read_enum_type (pp, type)
 
   /* Read the value-names and their values.
      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
-     A semicolon instead of a NAME means the end.  */
-  while (**pp && **pp != ';')
+     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 ();
@@ -4257,7 +4904,7 @@ read_enum_type (pp, type)
       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;
@@ -4268,7 +4915,8 @@ read_enum_type (pp, type)
       nsyms++;
     }
 
-  (*pp)++;			/* Skip the semicolon.  */
+  if (**pp == ';')
+    (*pp)++;			/* Skip the semicolon.  */
 
   /* Now fill in the fields of the type-structure.  */
 
@@ -4281,8 +4929,11 @@ read_enum_type (pp, 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 = nsyms; syms; syms = syms->next)
+  for (syms = *symlist, n = 0; syms; syms = syms->next)
     {
       int j = 0;
       if (syms == osyms)
@@ -4291,10 +4942,10 @@ read_enum_type (pp, type)
 	{
 	  struct symbol *sym = syms->symbol[j];
 	  SYMBOL_TYPE (sym) = type;
-	  TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (sym);
+	  TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (sym);
 	  TYPE_FIELD_VALUE (type, n) = 0;
 	  TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (sym);
-	  TYPE_FIELD_BITSIZE (type, n) = 0;
+	  TYPE_FIELD_BITSIZE (type, n++) = 0;
 	}
       if (syms == osyms)
 	break;
@@ -4302,7 +4953,7 @@ read_enum_type (pp, type)
 
   return type;
 }
-  
+
 #define	MAX_OF_TYPE(t)	((1 << (sizeof (t) - 1)) - 1)
 #define MIN_OF_TYPE(t)	(-(1 << (sizeof (t) - 1)))
 
@@ -4374,6 +5025,10 @@ read_range_type (pp, typenums)
 	       *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 == (1 << (8 * sizeof (int))) - 1)
 	return builtin_type_unsigned_int;
       if (n3 == (1 << (8 * sizeof (short))) - 1)
@@ -4381,6 +5036,10 @@ read_range_type (pp, typenums)
       if (n3 == (1 << (8 * sizeof (char))) - 1)
 	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 */
@@ -4402,7 +5061,7 @@ read_range_type (pp, typenums)
      as an idiom, and that all of them are special cases.  So . . .  */
   if (self_subrange)
     error ("Type defined as subrange of itself.");
-  
+
   result_type = (struct type *) obstack_alloc (symbol_obstack,
 					       sizeof (struct type));
   bzero (result_type, sizeof (struct type));
@@ -4434,7 +5093,7 @@ read_range_type (pp, typenums)
   bzero (TYPE_FIELDS (result_type), 2 * sizeof (struct field));
   TYPE_FIELD_BITPOS (result_type, 0) = n2;
   TYPE_FIELD_BITPOS (result_type, 1) = n3;
-    
+
   return result_type;
 }
 
@@ -4501,7 +5160,7 @@ read_args (pp, end)
       /* 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) */
@@ -4524,7 +5183,7 @@ read_args (pp, end)
 }
 
 /* This function is really horrible, but to avoid it, there would need
-   to be more filling in of forward references.  THIS SHOULD BE MOVED OUT 
+   to be more filling in of forward references.  THIS SHOULD BE MOVED OUT
    OF COFFREAD.C AND DBXREAD.C TO SOME PLACE WHERE IT CAN BE SHARED */
 int
 fill_in_vptr_fieldno (type)
@@ -4535,7 +5194,45 @@ fill_in_vptr_fieldno (type)
       fill_in_vptr_fieldno (TYPE_BASECLASS (type, 1));
   return TYPE_VPTR_FIELDNO (type);
 }
+
+/* Copy a pending list, used to record the contents of a common
+   block for later fixup.  */
+static struct pending *
+copy_pending (beg, begi, end)
+    struct pending *beg, *end;
+    int begi;
+{
+  struct pending *new = 0;
+  struct pending *next;
+
+  for (next = beg; next != 0 && (next != end || begi < end->nsyms);
+       next = next->next, begi = 0)
+    {
+      register int j;
+      for (j = begi; j < next->nsyms; j++)
+	add_symbol_to_list (next->symbol[j], &new);
+    }
+  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, value)
+    struct symbol *sym;
+    int value;
+{
+  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 (next->symbol[j]) += value;
+    }
+}
+
 void
 _initialize_dbxread ()
 {
@@ -4543,6 +5240,11 @@ _initialize_dbxread ()
   header_files = (struct header_file *) 0;
   this_object_header_files = (int *) 0;
 
+  undef_types_allocated = 20;
+  undef_types_length = 0;
+  undef_types = (struct type **) xmalloc (undef_types_allocated *
+					  sizeof (struct type *));
+
   add_com ("symbol-file", class_files, symbol_file_command,
 	   "Load symbol table (in dbx format) from executable file FILE.");