* symtab.h (struct linetable), xcoffread.c (arrange_linetable):

	Revise comments re linetable sorting.
	* buildsym.c (compare_line_numbers): Sort by pc, not by line.
	* coffread.c: Tell end_symtab to sort the line table.

	* coffread.c: Re-work a lot of the coff-specific stuff to use stuff
	in buildsym.c.  This includes coff_finish_block, coff_context_stack,
	coff_local_symbols, coff_file_symbols, coff_global_symbols,
	coff_end_symtab and coff_add_symbol_to_list.
	(read_enum_type): Deal with it now that we have a "struct pending"
	not a "struct coff_pending".

	* buildsym.c (end_symtab): Don't realloc subfile->linetable.

5 files changed, 156 insertions, 354 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 18e42c7..cb8a653 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,19 @@
+Wed Sep  1 11:35:49 1993  Jim Kingdon  (kingdon@lioth.cygnus.com)
+
+	* symtab.h (struct linetable), xcoffread.c (arrange_linetable):
+	Revise comments re linetable sorting.
+	* buildsym.c (compare_line_numbers): Sort by pc, not by line.
+	* coffread.c: Tell end_symtab to sort the line table.
+
+	* coffread.c: Re-work a lot of the coff-specific stuff to use stuff
+	in buildsym.c.  This includes coff_finish_block, coff_context_stack,
+	coff_local_symbols, coff_file_symbols, coff_global_symbols,
+	coff_end_symtab and coff_add_symbol_to_list.
+	(read_enum_type): Deal with it now that we have a "struct pending"
+	not a "struct coff_pending".
+
+	* buildsym.c (end_symtab): Don't realloc subfile->linetable.
+
 Wed Sep  1 13:12:43 1993  K. Richard Pixley  (rich@sendai.cygnus.com)
 
 	* a68v-nat.c, altos-xdep.c, convex-tdep.c, convex-xdep.c,
diff --git a/gdb/buildsym.c b/gdb/buildsym.c
index a36ef79..be13a9c 100644
--- a/gdb/buildsym.c
+++ b/gdb/buildsym.c
@@ -98,7 +98,8 @@ add_symbol_to_list (symbol, listhead)
   (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
 }
 
-/* Find a symbol on a pending list.  */
+/* Find a symbol named NAME on a LIST.  NAME need not be '\0'-terminated;
+   LENGTH is the length of the name.  */
 
 struct symbol *
 find_symbol_in_list (list, name, length)
@@ -297,7 +298,7 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile)
 
 static struct blockvector *
 make_blockvector (objfile)
-      struct objfile *objfile;
+     struct objfile *objfile;
 {
   register struct pending_block *next;
   register struct blockvector *blockvector;
@@ -358,7 +359,9 @@ make_blockvector (objfile)
 
 
 /* Start recording information about source code that came from an included
-   (or otherwise merged-in) source file with a different name.  */
+   (or otherwise merged-in) source file with a different name.  NAME is
+   the name of the file (cannot be NULL), DIRNAME is the directory in which
+   it resides (or NULL if not known).  */
 
 void
 start_subfile (name, dirname)
@@ -572,8 +575,20 @@ compare_line_numbers (ln1p, ln2p)
      const PTR ln1p;
      const PTR ln2p;
 {
-  return (((struct linetable_entry *) ln1p) -> line -
-	  ((struct linetable_entry *) ln2p) -> line);
+  struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
+  struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
+
+  /* Note: this code does not assume that CORE_ADDRs can fit in ints.
+     Please keep it that way.  */
+  if (ln1->pc < ln2->pc)
+    return -1;
+
+  if (ln1->pc > ln2->pc)
+    return 1;
+
+  /* If pc equal, sort by line.  I'm not sure whether this is optimum
+     behavior (see comment at struct linetable in symtab.h).  */
+  return ln1->line - ln2->line;
 }
 
 
@@ -699,7 +714,13 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile, section)
   /* 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).
-     FIXME:  Stabs specific. */
+
+     Both cleanup_undefined_types and finish_global_stabs are stabs
+     specific, but harmless for other symbol readers, since on gdb
+     startup or when finished reading stabs, the state is set so these
+     are no-ops.  FIXME: Is this handled right in case of QUIT?  Can
+     we make this cleaner?  */
+
   cleanup_undefined_types ();
   finish_global_stabs (objfile);
 
@@ -737,11 +758,20 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile, section)
 	{
 	  if (subfile->line_vector)
 	    {
-	      /* First, shrink the linetable to make more memory.  */
 	      linetablesize = sizeof (struct linetable) +
 		subfile->line_vector->nitems * sizeof (struct linetable_entry);
+#if 0
+	      /* I think this is artifact from before it went on the obstack.
+		 I doubt we'll need the memory between now and when we
+		 free it later in this function.  */
+	      /* First, shrink the linetable to make more memory.  */
 	      subfile->line_vector = (struct linetable *)
 		xrealloc ((char *) subfile->line_vector, linetablesize);
+#endif
+	      /* If sort_linevec is false, we might want just check to make
+		 sure they are sorted and complain() if not, as a way of
+		 tracking down compilers/symbol readers which don't get
+		 them sorted right.  */
 
 	      if (sort_linevec)
 		qsort (subfile->line_vector->item,
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 8348b57..6ccf456 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -123,44 +123,6 @@ static unsigned	local_auxesz;
 
 static struct symbol *opaque_type_chain[HASHSIZE];
 
-/* Record the symbols defined for each context in a list.
-   We don't create a struct block for the context until we
-   know how long to make it.  */
-
-struct coff_pending
-{
-  struct coff_pending *next;
-  struct symbol *symbol;
-};
-
-/* Here are the three lists that symbols are put on.  */
-
-struct coff_pending *coff_file_symbols;	/* static at top level, and types */
-
-struct coff_pending *coff_global_symbols;  /* global functions and variables */
-
-struct coff_pending *coff_local_symbols;  /* everything local to lexical context */
-
-/* List of unclosed lexical contexts
-   (that will become blocks, eventually).  */
-
-struct coff_context_stack
-{
-  struct coff_context_stack *next;
-  struct coff_pending *locals;
-  struct pending_block *old_blocks;
-  struct symbol *name;
-  CORE_ADDR start_addr;
-  int depth;
-};
-
-struct coff_context_stack *coff_context_stack;
-
-/* Nonzero if within a function (so symbols should be local,
-   if nothing says specifically).  */
-
-int within_function;
-
 #if 0
 /* The type of the function we are currently reading in.  This is
    used by define_symbol to record the type of arguments to a function. */
@@ -229,9 +191,6 @@ decode_function_type PARAMS ((struct coff_symbol *, unsigned int,
 static struct type *
 coff_read_enum_type PARAMS ((int, int, int));
 
-static struct blockvector *
-make_blockvector PARAMS ((struct objfile *));
-
 static struct symbol *
 process_coff_symbol PARAMS ((struct coff_symbol *, union internal_auxent *,
 			     struct objfile *));
@@ -300,14 +259,6 @@ coff_start_symtab PARAMS ((void));
 static void
 coff_record_line PARAMS ((int, CORE_ADDR));
 
-static void
-coff_finish_block PARAMS ((struct symbol *, struct coff_pending **,
-			   struct pending_block *, CORE_ADDR, CORE_ADDR,
-			   struct objfile *));
-
-static void
-coff_add_symbol_to_list PARAMS ((struct symbol *, struct coff_pending **));
-
 static struct type *
 coff_alloc_type PARAMS ((int));
 
@@ -365,142 +316,6 @@ coff_alloc_type (index)
   return type;
 }
 
-/* maintain the lists of symbols and blocks */
-
-/* Add a symbol to one of the lists of symbols.  */
-static void
-coff_add_symbol_to_list (symbol, listhead)
-     struct symbol *symbol;
-     struct coff_pending **listhead;
-{
-  register struct coff_pending *link
-    = (struct coff_pending *) xmalloc (sizeof (struct coff_pending));
-
-  link->next = *listhead;
-  link->symbol = symbol;
-  *listhead = link;
-}
-
-/* Take one of the lists of symbols and make a block from it.
-   Put the block on the list of pending blocks.  */
-
-static void
-coff_finish_block (symbol, listhead, old_blocks, start, end, objfile)
-     struct symbol *symbol;
-     struct coff_pending **listhead;
-     struct pending_block *old_blocks;
-     CORE_ADDR start, end;
-     struct objfile *objfile;
-{
-  register struct coff_pending *next, *next1;
-  register struct block *block;
-  register struct pending_block *pblock;
-  struct pending_block *opblock;
-  register int i;
-
-  /* Count the length of the list of symbols.  */
-
-  for (next = *listhead, i = 0; next; next = next->next, i++);
-
-  block = (struct block *)
-	    obstack_alloc (&objfile->symbol_obstack, sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
-
-  /* Copy the symbols into the block.  */
-
-  BLOCK_NSYMS (block) = i;
-  for (next = *listhead; next; next = next->next)
-    BLOCK_SYM (block, --i) = next->symbol;
-
-  BLOCK_START (block) = start;
-  BLOCK_END (block) = end;
-  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
-
-  /* Put the block in as the value of the symbol that names it.  */
-
-  if (symbol)
-    {
-      SYMBOL_BLOCK_VALUE (symbol) = block;
-      BLOCK_FUNCTION (block) = symbol;
-    }
-  else
-    BLOCK_FUNCTION (block) = 0;
-
-  /* Now free the links of the list, and empty the list.  */
-
-  for (next = *listhead; next; next = next1)
-    {
-      next1 = next->next;
-      free ((PTR)next);
-    }
-  *listhead = 0;
-
-  /* Install this block as the superblock
-     of all blocks made since the start of this scope
-     that don't have superblocks yet.  */
-
-  opblock = 0;
-  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
-    {
-      if (BLOCK_SUPERBLOCK (pblock->block) == 0)
-	BLOCK_SUPERBLOCK (pblock->block) = block;
-      opblock = pblock;
-    }
-
-  /* Record this block on the list of all blocks in the file.
-     Put it after opblock, or at the beginning if opblock is 0.
-     This puts the block in the list after all its subblocks.  */
-
-  pblock = (struct pending_block *) xmalloc (sizeof (struct pending_block));
-  pblock->block = block;
-  if (opblock)
-    {
-      pblock->next = opblock->next;
-      opblock->next = pblock;
-    }
-  else
-    {
-      pblock->next = pending_blocks;
-      pending_blocks = pblock;
-    }
-}
-
-static struct blockvector *
-make_blockvector (objfile)
-     struct objfile *objfile;
-{
-  register struct pending_block *next, *next1;
-  register struct blockvector *blockvector;
-  register int i;
-
-  /* Count the length of the list of blocks.  */
-
-  for (next = pending_blocks, i = 0; next; next = next->next, i++);
-
-  blockvector = (struct blockvector *)
-		  obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
-
-  /* Copy the blocks into the blockvector.
-     This is done in reverse order, which happens to put
-     the blocks into the proper order (ascending starting address).
-     coff_finish_block has hair to insert each block into the list
-     after its subblocks in order to make sure this is true.  */
-
-  BLOCKVECTOR_NBLOCKS (blockvector) = i;
-  for (next = pending_blocks; next; next = next->next)
-    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
-
-  /* Now free the links of the list, and empty the list.  */
-
-  for (next = pending_blocks; next; next = next1)
-    {
-      next1 = next->next;
-      free ((PTR)next);
-    }
-  pending_blocks = 0;
-
-  return blockvector;
-}
-
 /* Manage the vector of line numbers.  */
 
 static void
@@ -531,11 +346,14 @@ coff_record_line (line, pc)
 static void
 coff_start_symtab ()
 {
-  coff_file_symbols = 0;
-  coff_global_symbols = 0;
-  coff_context_stack = 0;
-  within_function = 0;
-  last_source_file = NULL;
+  start_symtab (
+		/* We fill in the filename later.  */
+		"",
+		/* We never know the directory name for COFF.  */
+		NULL,
+		/* The start address is irrelevant, since we set
+		   last_source_start_addr in coff_end_symtab.  */
+		0);
 
   /* Initialize the source file line number information for this file.  */
 
@@ -581,87 +399,24 @@ static void
 coff_end_symtab (objfile)
      struct objfile *objfile;
 {
-  register struct symtab *symtab;
-  register struct coff_context_stack *cstk;
-  register struct blockvector *blockvector;
-  register struct linetable *lv;
+  struct symtab *symtab;
 
-  /* Finish the lexical context of the last function in the file.  */
+  last_source_start_addr = cur_src_start_addr;
 
-  if (coff_context_stack)
-    {
-      cstk = coff_context_stack;
-      coff_context_stack = 0;
-      /* Make a block for the local symbols within.  */
-      coff_finish_block (cstk->name, &coff_local_symbols, cstk->old_blocks,
-		    cstk->start_addr, cur_src_end_addr, objfile);
-      free ((PTR)cstk);
-    }
+  /* For COFF, we only have one subfile, so we can just look at
+     subfiles and not worry about there being other elements in the
+     chain.  We fill in various fields now because we didn't know them
+     before (or because doing it now is simply an artifact of how this
+     file used to be written).  */
+  subfiles->line_vector = line_vector;
+  subfiles->name = last_source_file;
 
-  /* Ignore a file that has no functions with real debugging info.  */
-  if (pending_blocks == 0 && coff_file_symbols == 0 && coff_global_symbols == 0)
-    {
-      free ((PTR)line_vector);
-      line_vector = 0;
-      line_vector_length = -1;
-      last_source_file = NULL;
-      return;
-    }
+  /* sort_pending is needed for amdcoff, at least.
+     sort_linevec is needed for the SCO compiler.  */
+  symtab = end_symtab (cur_src_end_addr, 1, 1, objfile, 0);
 
-  /* It is unfortunate that in amdcoff, pending blocks might not be ordered
-     in this stage. Especially, blocks for static functions will show up at
-     the end.  We need to sort them, so tools like `find_pc_function' and
-     `find_pc_block' can work reliably. */
-  if (pending_blocks) {
-    /* FIXME!  Remove this horrid bubble sort and use qsort!!! */
-    int swapped;
-    do {
-      struct pending_block *pb, *pbnext;
-
-      pb = pending_blocks, pbnext = pb->next;
-      swapped = 0;
-
-      while ( pbnext ) {
-
-	  /* swap blocks if unordered! */
-
-	  if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) {
-	    struct block *tmp = pb->block;
-	    complain (&misordered_blocks_complaint, BLOCK_START (pb->block));
-	    pb->block = pbnext->block;
-	    pbnext->block = tmp;
-	    swapped = 1;
-	  }
-	  pb = pbnext;
-	  pbnext = pbnext->next;
-      }
-    } while (swapped);
-  }
-
-  /* Create the two top-level blocks for this file (STATIC_BLOCK and
-     GLOBAL_BLOCK).  */
-  coff_finish_block (0, &coff_file_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
-  coff_finish_block (0, &coff_global_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
-
-  /* Create the blockvector that points to all the file's blocks.  */
-  blockvector = make_blockvector (objfile);
-
-  /* Now create the symtab object for this source file.  */
-  symtab = allocate_symtab (last_source_file, objfile);
-
-  /* Fill in its components.  */
-  symtab->blockvector = blockvector;
-  symtab->free_code = free_linetable;
-  symtab->free_ptr = 0;
-  symtab->filename = last_source_file;
-  symtab->dirname = NULL;
-  lv = line_vector;
-  lv->nitems = line_vector_index;
-  symtab->linetable = (struct linetable *)
-    xrealloc ((char *) lv, (sizeof (struct linetable)
-		   + lv->nitems * sizeof (struct linetable_entry)));
-
-  free_named_symtabs (symtab->filename);
+  if (symtab != NULL)
+    free_named_symtabs (symtab->filename);
 
   /* Reinitialize for beginning of new file. */
   line_vector = 0;
@@ -888,7 +643,7 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
      struct objfile *objfile;
 {
   FILE *stream; 
-  register struct coff_context_stack *new;
+  register struct context_stack *new;
   struct coff_symbol coff_symbol;
   register struct coff_symbol *cs = &coff_symbol;
   static struct internal_syment main_sym;
@@ -1098,41 +853,41 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
 		  complain (&bf_no_aux_complaint, cs->c_symnum);
 		fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
 
-		new = (struct coff_context_stack *)
-		  xmalloc (sizeof (struct coff_context_stack));
-		new->depth = depth = 0;
-		new->next = 0;
-		coff_context_stack = new;
-		new->locals = 0;
-		new->old_blocks = pending_blocks;
-		new->start_addr = fcn_start_addr;
+		/* Might want to check that locals are 0 and
+		   context_stack_depth is zero, and complain if not.  */
+
+		depth = 0;
+		new = push_context (depth, fcn_start_addr);
 		fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
 		new->name = process_coff_symbol (&fcn_cs_saved,
 						 &fcn_aux_saved, objfile);
 	      }
 	    else if (STREQ (cs->c_name, ".ef"))
 	      {
-		      /* the value of .ef is the address of epilogue code;
-		       * not useful for gdb
-		       */
+		/* the value of .ef is the address of epilogue code;
+		   not useful for gdb.  */
 		/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
 			    contains number of lines to '}' */
-		new = coff_context_stack;
-		if (new == 0)
+		new = pop_context ();
+		/* Stack must be empty now.  */
+		if (context_stack_depth > 0 || new == NULL)
 		  {
 		    complain (&ef_complaint, cs->c_symnum);
 		    within_function = 0;
 		    break;
 		  }
-		if (cs->c_naux != 1) {
-		  complain (&ef_no_aux_complaint, cs->c_symnum);
-		  fcn_last_line = 0x7FFFFFFF;
-		} else {
-		  fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
-		}
+		if (cs->c_naux != 1)
+		  {
+		    complain (&ef_no_aux_complaint, cs->c_symnum);
+		    fcn_last_line = 0x7FFFFFFF;
+		  }
+		else
+		  {
+		    fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+		  }
 		enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line);
 
-		coff_finish_block (new->name, &coff_local_symbols, new->old_blocks,
+		finish_block (new->name, &local_symbols, new->old_blocks,
 			      new->start_addr,
 #if defined (FUNCTION_EPILOGUE_SIZE)
 			      /* This macro should be defined only on
@@ -1149,45 +904,31 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
 #endif
 			      objfile
 			      );
-		coff_context_stack = 0;
 		within_function = 0;
-		free ((PTR)new);
 	      }
 	    break;
 
 	  case C_BLOCK:
 	    if (STREQ (cs->c_name, ".bb"))
 	      {
-		new = (struct coff_context_stack *)
-			    xmalloc (sizeof (struct coff_context_stack));
-		depth++;
-		new->depth = depth;
-		new->next = coff_context_stack;
-		coff_context_stack = new;
-		new->locals = coff_local_symbols;
-		new->old_blocks = pending_blocks;
-		new->start_addr = cs->c_value;
-		new->name = 0;
-		coff_local_symbols = 0;
+		push_context (++depth, cs->c_value);
 	      }
 	    else if (STREQ (cs->c_name, ".eb"))
 	      {
-		new = coff_context_stack;
-		if (new == 0 || depth != new->depth)
+		new = pop_context ();
+		if (depth-- != new->depth)
 		  {
 		    complain (&eb_complaint, (char *)symnum);
 		    break;
 		  }
-		if (coff_local_symbols && coff_context_stack->next)
+		if (local_symbols && context_stack_depth > 0)
 		  {
 		    /* Make a block for the local symbols within.  */
-		    coff_finish_block (0, &coff_local_symbols, new->old_blocks,
+		    finish_block (0, &local_symbols, new->old_blocks,
 				  new->start_addr, cs->c_value, objfile);
 		  }
-		depth--;
-		coff_local_symbols = new->locals;
-		coff_context_stack = new->next;
-		free ((PTR)new);
+		/* Now pop locals of block just finished.  */
+		local_symbols = new->locals;
 	      }
 	    break;
 
@@ -1337,9 +1078,6 @@ init_stringtab (chan, offset)
     return 0;
 
   stringtab = (char *) xmalloc (length);
-  if (stringtab == NULL)
-    return -1;
-
   memcpy (stringtab, &length, sizeof length);
   if (length == sizeof length)		/* Empty table -- just the count */
     return 0;
@@ -1435,9 +1173,6 @@ init_lineno (chan, offset, size)
   /* Allocate the desired table, plus a sentinel */
   linetab = (char *) xmalloc (size + local_linesz);
 
-  if (linetab == NULL)
-    return -1;
-
   val = myread (chan, linetab, size);
   if (val != size)
     return -1;
@@ -1626,9 +1361,9 @@ process_coff_symbol (cs, aux, objfile)
 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       if (cs->c_sclass == C_STAT)
-	coff_add_symbol_to_list (sym, &coff_file_symbols);
+	add_symbol_to_list (sym, &file_symbols);
       else if (cs->c_sclass == C_EXT)
-	coff_add_symbol_to_list (sym, &coff_global_symbols);
+	add_symbol_to_list (sym, &global_symbols);
     }
   else
     {
@@ -1640,13 +1375,13 @@ process_coff_symbol (cs, aux, objfile)
 
 	  case C_AUTO:
 	    SYMBOL_CLASS (sym) = LOC_LOCAL;
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 	    break;
 
 	  case C_EXT:
 	    SYMBOL_CLASS (sym) = LOC_STATIC;
 	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
-	    coff_add_symbol_to_list (sym, &coff_global_symbols);
+	    add_symbol_to_list (sym, &global_symbols);
 	    break;
 
 	  case C_STAT:
@@ -1654,11 +1389,11 @@ process_coff_symbol (cs, aux, objfile)
 	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
 	    if (within_function) {
 	      /* Static symbol of local scope */
-	      coff_add_symbol_to_list (sym, &coff_local_symbols);
+	      add_symbol_to_list (sym, &local_symbols);
 	    }
 	    else {
 	      /* Static symbol at top level of file */
-	      coff_add_symbol_to_list (sym, &coff_file_symbols);
+	      add_symbol_to_list (sym, &file_symbols);
 	    }
 	    break;
 
@@ -1668,7 +1403,7 @@ process_coff_symbol (cs, aux, objfile)
 	  case C_REG:
 	    SYMBOL_CLASS (sym) = LOC_REGISTER;
 	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 	    break;
 
 	  case C_LABEL:
@@ -1681,7 +1416,7 @@ process_coff_symbol (cs, aux, objfile)
 	    /* Add parameter to function.  */
 	    add_param_to_type(&in_function_type,sym);
 #endif
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
 	    /* If PCC says a parameter is a short or a char,
 	       aligned on an int boundary, realign it to the "little end"
@@ -1700,7 +1435,7 @@ process_coff_symbol (cs, aux, objfile)
 	  case C_REGPARM:
 	    SYMBOL_CLASS (sym) = LOC_REGPARM;
 	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 #if !defined (BELIEVE_PCC_PROMOTION)
 	/* FIXME:  This should retain the current type, since it's just
 	   a register value.  gnu@adobe, 26Feb93 */
@@ -1741,7 +1476,7 @@ process_coff_symbol (cs, aux, objfile)
 		SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
 		opaque_type_chain[i] = sym;
 	      }
-	    coff_add_symbol_to_list (sym, &coff_file_symbols);
+	    add_symbol_to_list (sym, &file_symbols);
 	    break;
 
 	  case C_STRTAG:
@@ -1760,7 +1495,7 @@ process_coff_symbol (cs, aux, objfile)
 		TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
 		  concat (SYMBOL_NAME (sym), NULL);
 
-	    coff_add_symbol_to_list (sym, &coff_file_symbols);
+	    add_symbol_to_list (sym, &file_symbols);
 	    break;
 
 	  default:
@@ -2114,21 +1849,23 @@ coff_read_enum_type (index, length, lastsym)
   register struct type *type;
   int nsyms = 0;
   int done = 0;
-  struct coff_pending **symlist;
+  struct pending **symlist;
   struct coff_symbol member_sym;
   register struct coff_symbol *ms = &member_sym;
   struct internal_syment sub_sym;
   union internal_auxent sub_aux;
-  struct coff_pending *osyms, *syms;
+  struct pending *osyms, *syms;
+  int o_nsyms;
   register int n;
   char *name;
 
   type = coff_alloc_type (index);
   if (within_function)
-    symlist = &coff_local_symbols;
+    symlist = &local_symbols;
   else
-    symlist = &coff_file_symbols;
+    symlist = &file_symbols;
   osyms = *symlist;
+  o_nsyms = osyms ? osyms->nsyms : 0;
 
   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
     {
@@ -2146,7 +1883,7 @@ coff_read_enum_type (index, length, lastsym)
 	    SYMBOL_CLASS (sym) = LOC_CONST;
 	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 	    SYMBOL_VALUE (sym) = ms->c_value;
-	    coff_add_symbol_to_list (sym, symlist);
+	    add_symbol_to_list (sym, symlist);
 	    nsyms++;
 	    break;
 
@@ -2174,15 +1911,28 @@ coff_read_enum_type (index, length, lastsym)
      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 != osyms; syms = syms->next)
+  for (syms = *symlist, n = 0; syms; syms = syms->next)
     {
-      SYMBOL_TYPE (syms->symbol) = type;
-      TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (syms->symbol);
-      TYPE_FIELD_VALUE (type, n) = 0;
-      TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (syms->symbol);
-      TYPE_FIELD_BITSIZE (type, n) = 0;
+      int j = 0;
+      if (syms == osyms)
+	j = o_nsyms;
+      for (; j < syms->nsyms; j++,n++)
+	{
+	  struct symbol *xsym = syms->symbol[j];
+	  SYMBOL_TYPE (xsym) = type;
+	  TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
+	  TYPE_FIELD_VALUE (type, n) = 0;
+	  TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+	  TYPE_FIELD_BITSIZE (type, n) = 0;
+	}
+      if (syms == osyms)
+	break;
     }
+
 #if 0
   /* This screws up perfectly good C programs with enums.  FIXME.  */
   /* Is this Modula-2's BOOLEAN type?  Flag it as such if so. */
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 8ac6972..5b47bea 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -523,7 +523,10 @@ enum address_class
      frame address" used by COFF, stabs, etc., and we don't know how
      to convert between these until we start examining prologues.
 
-     Note that LOC_BASEREG is much less general than a DWARF expression.  */
+     Note that LOC_BASEREG is much less general than a DWARF expression.
+     We don't need the generality (at least not yet), and storing a general
+     DWARF expression would presumably take up more space than the existing
+     scheme.  */
 
   LOC_BASEREG,
 
@@ -628,26 +631,27 @@ struct linetable_entry
   CORE_ADDR pc;
 };
 
-/* The order of entries in the linetable is significant.
+/* The order of entries in the linetable is significant.  They should
+   be sorted by increasing values of the pc field.  If there is more than
+   one entry for a given pc, then I'm not sure what should happen (and
+   I not sure whether we currently handle it the best way).
 
-   It should generally be in ascending line number order.  Line table
-   entries for a function at lines 10-40 should come before entries
-   for a function at lines 50-70.
-
-   A for statement looks like this
+   Example: a C for statement generally looks like this
 
    	10	0x100	- for the init/test part of a for stmt.
    	20	0x200
    	30	0x300
    	10	0x400	- for the increment part of a for stmt.
 
-   FIXME: this description is incomplete.  coffread.c is said to get
-   the linetable order wrong (would arrange_linenos from xcoffread.c
-   work for normal COFF too?).  */
+   */
 
 struct linetable
 {
   int nitems;
+
+  /* Actually NITEMS elements.  If you don't like this use of the
+     `struct hack', you can shove it up your ANSI (seriously, if the
+     committee tells us how to do it, we can probably go along).  */
   struct linetable_entry item[1];
 };
 
diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c
index 28948d5..4abaee9 100644
--- a/gdb/xcoffread.c
+++ b/gdb/xcoffread.c
@@ -295,6 +295,8 @@ compare_lte (lte1, lte2)
 /* Give a line table with function entries are marked, arrange its functions
    in assending order and strip off function entry markers and return it in
    a newly created table. If the old one is good enough, return the old one. */
+/* FIXME: I think all this stuff can be replaced by just passing
+   sort_linevec = 1 to end_symtab.  */
 
 static struct linetable *
 arrange_linetable (oldLineTb)