import gdb-1999-07-07 post reformat

1 files changed, 750 insertions, 740 deletions

diff --git a/gdb/coffread.c b/gdb/coffread.c
index 1a63cfb7552..1a923ebff66 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1,23 +1,24 @@
 /* Read coff symbol tables and convert to internal format, for GDB.
    Copyright 1987, 88, 89, 90, 91, 92, 93, 94, 96, 97, 1998
-             Free Software Foundation, Inc.
+   Free Software Foundation, Inc.
    Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -44,16 +45,17 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 extern void _initialize_coffread PARAMS ((void));
 
-struct coff_symfile_info {
-  file_ptr min_lineno_offset;		/* Where in file lowest line#s are */
-  file_ptr max_lineno_offset;		/* 1+last byte of line#s in file */
+struct coff_symfile_info
+  {
+    file_ptr min_lineno_offset;	/* Where in file lowest line#s are */
+    file_ptr max_lineno_offset;	/* 1+last byte of line#s in file */
 
-  CORE_ADDR textaddr;			/* Addr of .text section. */
-  unsigned int textsize;		/* Size of .text section. */
-  struct stab_section_list *stabsects;	/* .stab sections.  */
-  asection *stabstrsect;		/* Section pointer for .stab section */
-  char *stabstrdata;
-};
+    CORE_ADDR textaddr;		/* Addr of .text section. */
+    unsigned int textsize;	/* Size of .text section. */
+    struct stab_section_list *stabsects;	/* .stab sections.  */
+    asection *stabstrsect;	/* Section pointer for .stab section */
+    char *stabstrdata;
+  };
 
 /* Translate an external name string into a user-visible name.  */
 #define	EXTERNAL_NAME(string, abfd) \
@@ -71,7 +73,7 @@ struct coff_symfile_info {
    to map one to one onto the sdb register numbers.  */
 
 #ifndef SDB_REG_TO_REGNUM
-# define SDB_REG_TO_REGNUM(value)     (value)
+#define SDB_REG_TO_REGNUM(value)     (value)
 #endif
 
 /* Core address of start and end of text of current source file.
@@ -98,24 +100,24 @@ static char *temp_aux;
    internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
    macros from include/coff/internal.h .  */
 
-static unsigned	local_n_btmask;
-static unsigned	local_n_btshft;
-static unsigned	local_n_tmask;
-static unsigned	local_n_tshift;
+static unsigned local_n_btmask;
+static unsigned local_n_btshft;
+static unsigned local_n_tmask;
+static unsigned local_n_tshift;
 
 #define	N_BTMASK	local_n_btmask
 #define	N_BTSHFT	local_n_btshft
 #define	N_TMASK		local_n_tmask
 #define	N_TSHIFT	local_n_tshift
- 
+
 /* Local variables that hold the sizes in the file of various COFF structures.
    (We only need to know this to read them from the file -- BFD will then
    translate the data in them, into `internal_xxx' structs in the right
    byte order, alignment, etc.)  */
 
-static unsigned	local_linesz;
-static unsigned	local_symesz;
-static unsigned	local_auxesz;
+static unsigned local_linesz;
+static unsigned local_symesz;
+static unsigned local_auxesz;
 
 /* This is set if this is a PE format file.  */
 
@@ -128,50 +130,51 @@ static struct symbol *opaque_type_chain[HASHSIZE];
 
 /* Complaints about various problems in the file being read  */
 
-struct complaint ef_complaint = 
-  {"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
+struct complaint ef_complaint =
+{"Unmatched .ef symbol(s) ignored starting at symnum %d", 0, 0};
 
-struct complaint ef_stack_complaint = 
-  {"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0};
+struct complaint ef_stack_complaint =
+{"`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d", 0, 0};
 
-struct complaint eb_stack_complaint = 
-  {"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0};
+struct complaint eb_stack_complaint =
+{"`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d", 0, 0};
 
 struct complaint bf_no_aux_complaint =
-  {"`.bf' symbol %d has no aux entry", 0, 0};
+{"`.bf' symbol %d has no aux entry", 0, 0};
 
 struct complaint ef_no_aux_complaint =
-  {"`.ef' symbol %d has no aux entry", 0, 0};
+{"`.ef' symbol %d has no aux entry", 0, 0};
 
 struct complaint lineno_complaint =
-  {"Line number pointer %d lower than start of line numbers", 0, 0};
+{"Line number pointer %d lower than start of line numbers", 0, 0};
 
 struct complaint unexpected_type_complaint =
-  {"Unexpected type for symbol %s", 0, 0};
+{"Unexpected type for symbol %s", 0, 0};
 
 struct complaint bad_sclass_complaint =
-  {"Bad n_sclass for symbol %s", 0, 0};
+{"Bad n_sclass for symbol %s", 0, 0};
 
 struct complaint misordered_blocks_complaint =
-  {"Blocks out of order at address %x", 0, 0};
+{"Blocks out of order at address %x", 0, 0};
 
 struct complaint tagndx_bad_complaint =
-  {"Symbol table entry for %s has bad tagndx value", 0, 0};
+{"Symbol table entry for %s has bad tagndx value", 0, 0};
 
-struct complaint eb_complaint = 
-  {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
+struct complaint eb_complaint =
+{"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
 
 /* Simplified internal version of coff symbol table information */
 
-struct coff_symbol {
-  char *c_name;
-  int c_symnum;		/* symbol number of this entry */
-  int c_naux;		/* 0 if syment only, 1 if syment + auxent, etc */
-  long c_value;
-  int c_sclass;
-  int c_secnum;
-  unsigned int c_type;
-};
+struct coff_symbol
+  {
+    char *c_name;
+    int c_symnum;		/* symbol number of this entry */
+    int c_naux;			/* 0 if syment only, 1 if syment + auxent, etc */
+    long c_value;
+    int c_sclass;
+    int c_secnum;
+    unsigned int c_type;
+  };
 
 static struct type *coff_read_struct_type PARAMS ((int, int, int));
 
@@ -286,7 +289,7 @@ coff_locate_sections (abfd, sectp, csip)
       /* We can have multiple .stab sections if linked with
          --split-by-reloc.  */
       for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
-	if (! isdigit (*s))
+	if (!isdigit (*s))
 	  break;
       if (*s == '\0')
 	{
@@ -301,8 +304,8 @@ coff_locate_sections (abfd, sectp, csip)
 	  *pn = n;
 
 	  /* This will be run after coffstab_build_psymtabs is called
-             in coff_symfile_read, at which point we no longer need
-             the information.  */
+	     in coff_symfile_read, at which point we no longer need
+	     the information.  */
 	  make_cleanup (free, n);
 	}
     }
@@ -311,19 +314,21 @@ coff_locate_sections (abfd, sectp, csip)
 /* Return the section_offsets* that CS points to.  */
 static int cs_to_section PARAMS ((struct coff_symbol *, struct objfile *));
 
-struct find_targ_sec_arg {
-  int targ_index;
-  asection **resultp;
-};
+struct find_targ_sec_arg
+  {
+    int targ_index;
+    asection **resultp;
+  };
 
 static void find_targ_sec PARAMS ((bfd *, asection *, void *));
 
-static void find_targ_sec (abfd, sect, obj)
+static void
+find_targ_sec (abfd, sect, obj)
      bfd *abfd;
      asection *sect;
      PTR obj;
 {
-  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *)obj;
+  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
   if (sect->target_index == args->targ_index)
     *args->resultp = sect;
 }
@@ -391,14 +396,14 @@ coff_lookup_type (index)
       int old_vector_length = type_vector_length;
 
       type_vector_length *= 2;
-      if (index /* is still */ >= type_vector_length)
+      if (index /* is still */  >= type_vector_length)
 	type_vector_length = index * 2;
 
       type_vector = (struct type **)
 	xrealloc ((char *) type_vector,
 		  type_vector_length * sizeof (struct type *));
       memset (&type_vector[old_vector_length], 0,
-	     (type_vector_length - old_vector_length) * sizeof(struct type *));
+	 (type_vector_length - old_vector_length) * sizeof (struct type *));
     }
   return &type_vector[index];
 }
@@ -431,19 +436,19 @@ coff_alloc_type (index)
 
 static void
 coff_start_symtab (name)
-    char *name;
+     char *name;
 {
   start_symtab (
-		/* We fill in the filename later.  start_symtab puts
-		   this pointer into last_source_file and we put it in
-		   subfiles->name, which end_symtab frees; that's why
-		   it must be malloc'd.  */
-		savestring (name, strlen(name)),
-		/* 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);
+  /* We fill in the filename later.  start_symtab puts
+     this pointer into last_source_file and we put it in
+     subfiles->name, which end_symtab frees; that's why
+     it must be malloc'd.  */
+		 savestring (name, strlen (name)),
+  /* 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);
   record_debugformat ("COFF");
 }
 
@@ -454,9 +459,9 @@ coff_start_symtab (name)
 
 static void
 complete_symtab (name, start_addr, size)
-    char *name;
-    CORE_ADDR start_addr;
-    unsigned int size;
+     char *name;
+     CORE_ADDR start_addr;
+     unsigned int size;
 {
   if (last_source_file != NULL)
     free (last_source_file);
@@ -464,11 +469,11 @@ complete_symtab (name, start_addr, size)
   current_source_start_addr = start_addr;
   current_source_end_addr = start_addr + size;
 
-  if (current_objfile -> ei.entry_point >= current_source_start_addr &&
-      current_objfile -> ei.entry_point <  current_source_end_addr)
+  if (current_objfile->ei.entry_point >= current_source_start_addr &&
+      current_objfile->ei.entry_point < current_source_end_addr)
     {
-      current_objfile -> ei.entry_file_lowpc = current_source_start_addr;
-      current_objfile -> ei.entry_file_highpc = current_source_end_addr;
+      current_objfile->ei.entry_file_lowpc = current_source_start_addr;
+      current_objfile->ei.entry_file_highpc = current_source_end_addr;
     }
 }
 
@@ -502,7 +507,8 @@ record_minimal_symbol (name, address, type, objfile)
      struct objfile *objfile;
 {
   /* We don't want TDESC entry points in the minimal symbol table */
-  if (name[0] == '@') return;
+  if (name[0] == '@')
+    return;
 
   prim_record_minimal_symbol (name, address, type, objfile);
 }
@@ -567,7 +573,7 @@ find_linenos (abfd, asect, vpinfo)
     return;
   size = count * local_linesz;
 
-  info = (struct coff_symfile_info *)vpinfo;
+  info = (struct coff_symfile_info *) vpinfo;
 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
   offset = asect->line_filepos;
 /* End of warning */
@@ -607,30 +613,30 @@ coff_symfile_read (objfile, section_offsets, mainline)
   struct cleanup *back_to;
   int stabstrsize;
 
-  info = (struct coff_symfile_info *) objfile -> sym_private;
+  info = (struct coff_symfile_info *) objfile->sym_private;
   dbxinfo = objfile->sym_stab_info;
-  symfile_bfd = abfd;			/* Kludge for swap routines */
+  symfile_bfd = abfd;		/* Kludge for swap routines */
 
 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
-   num_symbols = bfd_get_symcount (abfd);	/* How many syms */
-   symtab_offset = cdata->sym_filepos;		/* Symbol table file offset */
-   stringtab_offset = symtab_offset +		/* String table file offset */
-		      num_symbols * cdata->local_symesz;
+  num_symbols = bfd_get_symcount (abfd);	/* How many syms */
+  symtab_offset = cdata->sym_filepos;	/* Symbol table file offset */
+  stringtab_offset = symtab_offset +	/* String table file offset */
+    num_symbols * cdata->local_symesz;
 
   /* Set a few file-statics that give us specific information about
      the particular COFF file format we're reading.  */
   local_n_btmask = cdata->local_n_btmask;
   local_n_btshft = cdata->local_n_btshft;
-  local_n_tmask  = cdata->local_n_tmask;
+  local_n_tmask = cdata->local_n_tmask;
   local_n_tshift = cdata->local_n_tshift;
-  local_linesz   = cdata->local_linesz;
-  local_symesz   = cdata->local_symesz;
-  local_auxesz   = cdata->local_auxesz;
+  local_linesz = cdata->local_linesz;
+  local_symesz = cdata->local_symesz;
+  local_auxesz = cdata->local_auxesz;
 
   /* Allocate space for raw symbol and aux entries, based on their
      space requirements as reported by BFD.  */
   temp_sym = (char *) xmalloc
-	 (cdata->local_symesz + cdata->local_auxesz);
+    (cdata->local_symesz + cdata->local_auxesz);
   temp_aux = temp_sym + cdata->local_symesz;
   back_to = make_cleanup ((make_cleanup_func) free_current_contents, &temp_sym);
 
@@ -649,7 +655,7 @@ coff_symfile_read (objfile, section_offsets, mainline)
   bfd_map_over_sections (abfd, find_linenos, (PTR) info);
 
   make_cleanup ((make_cleanup_func) free_linetab, 0);
-  val = init_lineno (abfd, info->min_lineno_offset, 
+  val = init_lineno (abfd, info->min_lineno_offset,
 		     info->max_lineno_offset - info->min_lineno_offset);
   if (val < 0)
     error ("\"%s\": error reading line numbers\n", name);
@@ -675,7 +681,7 @@ coff_symfile_read (objfile, section_offsets, mainline)
   {
     struct symtab *s;
 
-    for (s = objfile -> symtabs; s != NULL; s = s -> next)
+    for (s = objfile->symtabs; s != NULL; s = s->next)
       sort_symtab_syms (s);
   }
 
@@ -688,19 +694,19 @@ coff_symfile_read (objfile, section_offsets, mainline)
 
   if (info->stabsects)
     {
-      if (! info->stabstrsect)
+      if (!info->stabstrsect)
 	{
 	  error_begin ();
 	  fprintf_filtered
 	    (gdb_stderr,
 	     ("The debugging information in `%s' is corrupted.\n"
-	      "The file has a `.stabs' section, but no `.stabstr' section.\n"),
+	   "The file has a `.stabs' section, but no `.stabstr' section.\n"),
 	     name);
 	  return_to_top_level (RETURN_ERROR);
 	}
 
       /* FIXME: dubious.  Why can't we use something normal like
-	 bfd_get_section_contents?  */
+         bfd_get_section_contents?  */
       bfd_seek (abfd, abfd->where, 0);
 
       stabstrsize = bfd_section_size (abfd, info->stabstrsect);
@@ -731,13 +737,13 @@ static void
 coff_symfile_finish (objfile)
      struct objfile *objfile;
 {
-  if (objfile -> sym_private != NULL)
+  if (objfile->sym_private != NULL)
     {
-      mfree (objfile -> md, objfile -> sym_private);
+      mfree (objfile->md, objfile->sym_private);
     }
 }
-
 
+
 /* Given pointers to a symbol table in coff style exec file,
    analyze them and create struct symtab's describing the symbols.
    NSYMS is the number of symbols in the symbol table.
@@ -800,7 +806,7 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
   last_source_file = NULL;
   memset (opaque_type_chain, 0, sizeof opaque_type_chain);
 
-  if (type_vector)			/* Get rid of previous one */
+  if (type_vector)		/* Get rid of previous one */
     free ((PTR) type_vector);
   type_vector_length = 160;
   type_vector = (struct type **)
@@ -848,50 +854,51 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
 
       switch (cs->c_sclass)
 	{
-	  case C_EFCN:
-	  case C_EXTDEF:
-	  case C_ULABEL:
-	  case C_USTATIC:
-	  case C_LINE:
-	  case C_ALIAS:
-	  case C_HIDDEN:
-	    complain (&bad_sclass_complaint, cs->c_name);
-	    break;
-
-	  case C_FILE:
-	    /* c_value field contains symnum of next .file entry in table
-	       or symnum of first global after last .file.  */
-	    next_file_symnum = cs->c_value;
-	    if (cs->c_naux > 0)
-	      filestring = coff_getfilename (&main_aux);
-	    else
-	      filestring = "";
+	case C_EFCN:
+	case C_EXTDEF:
+	case C_ULABEL:
+	case C_USTATIC:
+	case C_LINE:
+	case C_ALIAS:
+	case C_HIDDEN:
+	  complain (&bad_sclass_complaint, cs->c_name);
+	  break;
 
-	    /* Complete symbol table for last object file
-	       containing debugging information.  */
-	    if (last_source_file)
-	      {
-		coff_end_symtab (objfile);
-		coff_start_symtab (filestring);
-	      }
-	    in_source_file = 1;
-	    break;
+	case C_FILE:
+	  /* c_value field contains symnum of next .file entry in table
+	     or symnum of first global after last .file.  */
+	  next_file_symnum = cs->c_value;
+	  if (cs->c_naux > 0)
+	    filestring = coff_getfilename (&main_aux);
+	  else
+	    filestring = "";
+
+	  /* Complete symbol table for last object file
+	     containing debugging information.  */
+	  if (last_source_file)
+	    {
+	      coff_end_symtab (objfile);
+	      coff_start_symtab (filestring);
+	    }
+	  in_source_file = 1;
+	  break;
 
 	  /* C_LABEL is used for labels and static functions.  Including
 	     it here allows gdb to see static functions when no debug
 	     info is available.  */
-	  case C_LABEL:
-	    /* However, labels within a function can make weird backtraces,
-	       so filter them out (from phdm@macqel.be). */
-	    if (within_function)
-	      break;
-          case C_STAT:
-	  case C_THUMBLABEL:
-	  case C_THUMBSTAT:
-	  case C_THUMBSTATFUNC:
-	    if (cs->c_name[0] == '.')
-	      {
-		if (STREQ (cs->c_name, ".text")) {
+	case C_LABEL:
+	  /* However, labels within a function can make weird backtraces,
+	     so filter them out (from phdm@macqel.be). */
+	  if (within_function)
+	    break;
+	case C_STAT:
+	case C_THUMBLABEL:
+	case C_THUMBSTAT:
+	case C_THUMBSTATFUNC:
+	  if (cs->c_name[0] == '.')
+	    {
+	      if (STREQ (cs->c_name, ".text"))
+		{
 		  /* FIXME:  don't wire in ".text" as section name
 		     or symbol name! */
 		  /* Check for in_source_file deals with case of
@@ -899,247 +906,247 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
 		     followed by a later file with no symbols.  */
 		  if (in_source_file)
 		    complete_symtab (filestring,
-				     cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+		    cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT),
 				     main_aux.x_scn.x_scnlen);
 		  in_source_file = 0;
 		}
-		/* flush rest of '.' symbols */
-		break;
-	      }
-	    else if (!SDB_TYPE (cs->c_type)
-		     && cs->c_name[0] == 'L'
-		     && (strncmp (cs->c_name, "LI%", 3) == 0
-			 || strncmp (cs->c_name, "LF%", 3) == 0
-			 || strncmp (cs->c_name,"LC%",3) == 0
-			 || strncmp (cs->c_name,"LP%",3) == 0
-			 || strncmp (cs->c_name,"LPB%",4) == 0
-			 || strncmp (cs->c_name,"LBB%",4) == 0
-			 || strncmp (cs->c_name,"LBE%",4) == 0
-			 || strncmp (cs->c_name,"LPBX%",5) == 0))
-	      /* At least on a 3b1, gcc generates swbeg and string labels
-		 that look like this.  Ignore them.  */
+	      /* flush rest of '.' symbols */
 	      break;
-	    /* fall in for static symbols that don't start with '.' */
-	  case C_THUMBEXT:
-	  case C_THUMBEXTFUNC:
-	  case C_EXT:
-	    {
-	      /* Record it in the minimal symbols regardless of
-		 SDB_TYPE.  This parallels what we do for other debug
-		 formats, and probably is needed to make
-		 print_address_symbolic work right without the (now
-		 gone) "set fast-symbolic-addr off" kludge.  */
+	    }
+	  else if (!SDB_TYPE (cs->c_type)
+		   && cs->c_name[0] == 'L'
+		   && (strncmp (cs->c_name, "LI%", 3) == 0
+		       || strncmp (cs->c_name, "LF%", 3) == 0
+		       || strncmp (cs->c_name, "LC%", 3) == 0
+		       || strncmp (cs->c_name, "LP%", 3) == 0
+		       || strncmp (cs->c_name, "LPB%", 4) == 0
+		       || strncmp (cs->c_name, "LBB%", 4) == 0
+		       || strncmp (cs->c_name, "LBE%", 4) == 0
+		       || strncmp (cs->c_name, "LPBX%", 5) == 0))
+	    /* At least on a 3b1, gcc generates swbeg and string labels
+	       that look like this.  Ignore them.  */
+	    break;
+	  /* fall in for static symbols that don't start with '.' */
+	case C_THUMBEXT:
+	case C_THUMBEXTFUNC:
+	case C_EXT:
+	  {
+	    /* Record it in the minimal symbols regardless of
+	       SDB_TYPE.  This parallels what we do for other debug
+	       formats, and probably is needed to make
+	       print_address_symbolic work right without the (now
+	       gone) "set fast-symbolic-addr off" kludge.  */
 
-	      /* FIXME: should use mst_abs, and not relocate, if absolute.  */
-	      enum minimal_symbol_type ms_type;
-	      int sec;
+	    /* FIXME: should use mst_abs, and not relocate, if absolute.  */
+	    enum minimal_symbol_type ms_type;
+	    int sec;
 
-	      if (cs->c_secnum == N_UNDEF)
-		{
-		  /* This is a common symbol.  See if the target
-		     environment knows where it has been relocated to.  */
-		  CORE_ADDR reladdr;
-		  if (target_lookup_symbol (cs->c_name, &reladdr))
-		    {
-		      /* Error in lookup; ignore symbol.  */
-		      break;
-		    }
-		  tmpaddr = reladdr;
-		  /* The address has already been relocated; make sure that
-		     objfile_relocate doesn't relocate it again.  */
-		  sec = -2;
-		  ms_type = cs->c_sclass == C_EXT
-			    || cs->c_sclass == C_THUMBEXT ?
-			       mst_bss : mst_file_bss;
-		}
-	      else
-		{
-		  sec = cs_to_section (cs, objfile);
-		  tmpaddr = cs->c_value;
-		  if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
-		      || cs->c_sclass == C_THUMBEXT)
-		    tmpaddr += ANOFFSET (section_offsets, sec);
+	    if (cs->c_secnum == N_UNDEF)
+	      {
+		/* This is a common symbol.  See if the target
+		   environment knows where it has been relocated to.  */
+		CORE_ADDR reladdr;
+		if (target_lookup_symbol (cs->c_name, &reladdr))
+		  {
+		    /* Error in lookup; ignore symbol.  */
+		    break;
+		  }
+		tmpaddr = reladdr;
+		/* The address has already been relocated; make sure that
+		   objfile_relocate doesn't relocate it again.  */
+		sec = -2;
+		ms_type = cs->c_sclass == C_EXT
+		  || cs->c_sclass == C_THUMBEXT ?
+		  mst_bss : mst_file_bss;
+	      }
+	    else
+	      {
+		sec = cs_to_section (cs, objfile);
+		tmpaddr = cs->c_value;
+		if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
+		    || cs->c_sclass == C_THUMBEXT)
+		  tmpaddr += ANOFFSET (section_offsets, sec);
 
-		  switch (sec)
-		    {
-		    case SECT_OFF_TEXT:
-		    case SECT_OFF_RODATA:
-		      ms_type =
-			cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
-					|| cs->c_sclass == C_THUMBEXT ?
-					  mst_text : mst_file_text;
+		switch (sec)
+		  {
+		  case SECT_OFF_TEXT:
+		  case SECT_OFF_RODATA:
+		    ms_type =
+		      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
+		      || cs->c_sclass == C_THUMBEXT ?
+		      mst_text : mst_file_text;
 #ifdef SMASH_TEXT_ADDRESS
-		      if (tmpaddr & 1)	/* FIXME: delete this line */
-			SMASH_TEXT_ADDRESS (tmpaddr);
+		    if (tmpaddr & 1)	/* FIXME: delete this line */
+		      SMASH_TEXT_ADDRESS (tmpaddr);
 #endif
-		      break;
-		    case SECT_OFF_DATA:
-		      ms_type =
-			cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
-			  mst_data : mst_file_data;
-		      break;
-		    case SECT_OFF_BSS:
-		      ms_type =
-			cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
-			  mst_data : mst_file_data;
-		      break;
-		    default:
-		      ms_type = mst_unknown;
-		      break;
-		    }
-		}
+		    break;
+		  case SECT_OFF_DATA:
+		    ms_type =
+		      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
+		      mst_data : mst_file_data;
+		    break;
+		  case SECT_OFF_BSS:
+		    ms_type =
+		      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
+		      mst_data : mst_file_data;
+		    break;
+		  default:
+		    ms_type = mst_unknown;
+		    break;
+		  }
+	      }
 
-	      if (cs->c_name[0] != '@' /* Skip tdesc symbols */)
-		{
-		  struct minimal_symbol *msym;
+	    if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
+	      {
+		struct minimal_symbol *msym;
 
-		  msym = prim_record_minimal_symbol_and_info
-		  (cs->c_name, tmpaddr, ms_type, (char *)cs->c_sclass, sec,
+		msym = prim_record_minimal_symbol_and_info
+		  (cs->c_name, tmpaddr, ms_type, (char *) cs->c_sclass, sec,
 		   NULL, objfile);
 #ifdef COFF_MAKE_MSYMBOL_SPECIAL
-		  if(msym)
-		    COFF_MAKE_MSYMBOL_SPECIAL(cs->c_sclass, msym);		
+		if (msym)
+		  COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
 #endif
+	      }
+	    if (SDB_TYPE (cs->c_type))
+	      {
+		struct symbol *sym;
+		sym = process_coff_symbol
+		  (cs, &main_aux, section_offsets, objfile);
+		SYMBOL_VALUE (sym) = tmpaddr;
+		SYMBOL_SECTION (sym) = sec;
+	      }
+	  }
+	  break;
+
+	case C_FCN:
+	  if (STREQ (cs->c_name, ".bf"))
+	    {
+	      within_function = 1;
+
+	      /* value contains address of first non-init type code */
+	      /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
+	         contains line number of '{' } */
+	      if (cs->c_naux != 1)
+		complain (&bf_no_aux_complaint, cs->c_symnum);
+	      fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+	      fcn_first_line_addr = cs->c_value;
+
+	      /* 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,
+				     section_offsets, objfile);
+	    }
+	  else if (STREQ (cs->c_name, ".ef"))
+	    {
+	      /* 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 '}' */
+
+	      if (context_stack_depth <= 0)
+		{		/* We attempted to pop an empty context stack */
+		  complain (&ef_stack_complaint, cs->c_symnum);
+		  within_function = 0;
+		  break;
 		}
-	      if (SDB_TYPE (cs->c_type))
+
+	      new = pop_context ();
+	      /* Stack must be empty now.  */
+	      if (context_stack_depth > 0 || new == NULL)
 		{
-		  struct symbol *sym;
-		  sym = process_coff_symbol
-		    (cs, &main_aux, section_offsets, objfile);
-		  SYMBOL_VALUE (sym) = tmpaddr;
-		  SYMBOL_SECTION (sym) = sec;
+		  complain (&ef_complaint, cs->c_symnum);
+		  within_function = 0;
+		  break;
 		}
-	    }
-	    break;
-
-	  case C_FCN:
-	    if (STREQ (cs->c_name, ".bf"))
-	      {
-		within_function = 1;
-
-		/* value contains address of first non-init type code */
-		/* main_aux.x_sym.x_misc.x_lnsz.x_lnno
-			    contains line number of '{' } */
-		if (cs->c_naux != 1)
-		  complain (&bf_no_aux_complaint, cs->c_symnum);
-		fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
-		fcn_first_line_addr = cs->c_value;
-
-		/* 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,
-				       section_offsets, objfile);
-	      }
-	    else if (STREQ (cs->c_name, ".ef"))
-	      {
-		/* 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 '}' */
-
-		if (context_stack_depth <= 0)
-		  {		/* We attempted to pop an empty context stack */
-		    complain (&ef_stack_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;
+		}
+	      /* fcn_first_line is the line number of the opening '{'.
+	         Do not record it - because it would affect gdb's idea
+	         of the line number of the first statement of the function -
+	         except for one-line functions, for which it is also the line
+	         number of all the statements and of the closing '}', and
+	         for which we do not have any other statement-line-number. */
+	      if (fcn_last_line == 1)
+		record_line (current_subfile, fcn_first_line,
+			     fcn_first_line_addr);
+	      else
+		enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
+			       section_offsets);
 
-		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;
-		  }
-		/* fcn_first_line is the line number of the opening '{'.
-		   Do not record it - because it would affect gdb's idea
-		   of the line number of the first statement of the function -
-		   except for one-line functions, for which it is also the line
-		   number of all the statements and of the closing '}', and
-		   for which we do not have any other statement-line-number. */
-		if (fcn_last_line == 1)
-	          record_line (current_subfile, fcn_first_line,
-			       fcn_first_line_addr);
-		else
-		  enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line,
-				 section_offsets);
-
-		finish_block (new->name, &local_symbols, new->old_blocks,
-			      new->start_addr,
+	      finish_block (new->name, &local_symbols, new->old_blocks,
+			    new->start_addr,
 #if defined (FUNCTION_EPILOGUE_SIZE)
-			      /* This macro should be defined only on
-				 machines where the
-				 fcn_aux_saved.x_sym.x_misc.x_fsize
-				 field is always zero.
-				 So use the .bf record information that
-				 points to the epilogue and add the size
-				 of the epilogue.  */
-			      cs->c_value
-			      + FUNCTION_EPILOGUE_SIZE
-			      + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+	      /* This macro should be defined only on
+	         machines where the
+	         fcn_aux_saved.x_sym.x_misc.x_fsize
+	         field is always zero.
+	         So use the .bf record information that
+	         points to the epilogue and add the size
+	         of the epilogue.  */
+			    cs->c_value
+			    + FUNCTION_EPILOGUE_SIZE
+			    + ANOFFSET (section_offsets, SECT_OFF_TEXT),
 #else
-			      fcn_cs_saved.c_value
-			      + fcn_aux_saved.x_sym.x_misc.x_fsize
-			      + ANOFFSET (section_offsets, SECT_OFF_TEXT),
+			    fcn_cs_saved.c_value
+			    + fcn_aux_saved.x_sym.x_misc.x_fsize
+			    + ANOFFSET (section_offsets, SECT_OFF_TEXT),
 #endif
-			      objfile
-			      );
-		within_function = 0;
-	      }
-	    break;
+			    objfile
+		);
+	      within_function = 0;
+	    }
+	  break;
 
-	  case C_BLOCK:
-	    if (STREQ (cs->c_name, ".bb"))
-	      {
-		tmpaddr = cs->c_value;
-		tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT);
-		push_context (++depth, tmpaddr);
-	      }
-	    else if (STREQ (cs->c_name, ".eb"))
-	      {
-		if (context_stack_depth <= 0)
-		  {		/* We attempted to pop an empty context stack */
-		    complain (&eb_stack_complaint, cs->c_symnum);
-		    break;
-		  }
+	case C_BLOCK:
+	  if (STREQ (cs->c_name, ".bb"))
+	    {
+	      tmpaddr = cs->c_value;
+	      tmpaddr += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+	      push_context (++depth, tmpaddr);
+	    }
+	  else if (STREQ (cs->c_name, ".eb"))
+	    {
+	      if (context_stack_depth <= 0)
+		{		/* We attempted to pop an empty context stack */
+		  complain (&eb_stack_complaint, cs->c_symnum);
+		  break;
+		}
 
-		new = pop_context ();
-		if (depth-- != new->depth)
-		  {
-		    complain (&eb_complaint, symnum);
-		    break;
-		  }
-		if (local_symbols && context_stack_depth > 0)
-		  {
-		    tmpaddr =
-		      cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT);
-		    /* Make a block for the local symbols within.  */
-		    finish_block (0, &local_symbols, new->old_blocks,
-				  new->start_addr, tmpaddr, objfile);
-		  }
-		/* Now pop locals of block just finished.  */
-		local_symbols = new->locals;
-	      }
-	    break;
+	      new = pop_context ();
+	      if (depth-- != new->depth)
+		{
+		  complain (&eb_complaint, symnum);
+		  break;
+		}
+	      if (local_symbols && context_stack_depth > 0)
+		{
+		  tmpaddr =
+		    cs->c_value + ANOFFSET (section_offsets, SECT_OFF_TEXT);
+		  /* Make a block for the local symbols within.  */
+		  finish_block (0, &local_symbols, new->old_blocks,
+				new->start_addr, tmpaddr, objfile);
+		}
+	      /* Now pop locals of block just finished.  */
+	      local_symbols = new->locals;
+	    }
+	  break;
 
-	  default:
-	    process_coff_symbol (cs, &main_aux, section_offsets, objfile);
-	    break;
+	default:
+	  process_coff_symbol (cs, &main_aux, section_offsets, objfile);
+	  break;
 	}
     }
 
@@ -1162,25 +1169,25 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
 
 static void
 read_one_sym (cs, sym, aux)
-    register struct coff_symbol *cs;
-    register struct internal_syment *sym;
-    register union internal_auxent *aux;
+     register struct coff_symbol *cs;
+     register struct internal_syment *sym;
+     register union internal_auxent *aux;
 {
   int i;
 
   cs->c_symnum = symnum;
   bfd_read (temp_sym, local_symesz, 1, nlist_bfd_global);
-  bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *)sym);
+  bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
   cs->c_naux = sym->n_numaux & 0xff;
   if (cs->c_naux >= 1)
     {
-    bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
-    bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
-			  0, cs->c_naux, (char *)aux);
-    /* If more than one aux entry, read past it (only the first aux
-       is important). */
-    for (i = 1; i < cs->c_naux; i++)
       bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
+      bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
+			    0, cs->c_naux, (char *) aux);
+      /* If more than one aux entry, read past it (only the first aux
+         is important). */
+      for (i = 1; i < cs->c_naux; i++)
+	bfd_read (temp_aux, local_auxesz, 1, nlist_bfd_global);
     }
   cs->c_name = getsymname (sym);
   cs->c_value = sym->n_value;
@@ -1192,7 +1199,7 @@ read_one_sym (cs, sym, aux)
 
 #if 0
   if (cs->c_sclass & 128)
-    printf("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
+    printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
 #endif
 
   symnum += 1 + cs->c_naux;
@@ -1232,8 +1239,8 @@ static char *stringtab = NULL;
 
 static int
 init_stringtab (abfd, offset)
-    bfd *abfd;
-    long offset;
+     bfd *abfd;
+     long offset;
 {
   long length;
   int val;
@@ -1249,9 +1256,9 @@ init_stringtab (abfd, offset)
   if (bfd_seek (abfd, offset, 0) < 0)
     return -1;
 
-  val = bfd_read ((char *)lengthbuf, sizeof lengthbuf, 1, abfd);
+  val = bfd_read ((char *) lengthbuf, sizeof lengthbuf, 1, abfd);
   length = bfd_h_get_32 (symfile_bfd, lengthbuf);
-       
+
   /* If no string table is needed, then the file may end immediately
      after the symbols.  Just return with `stringtab' set to null. */
   if (val != sizeof lengthbuf || length < sizeof lengthbuf)
@@ -1261,7 +1268,7 @@ init_stringtab (abfd, offset)
   /* This is in target format (probably not very useful, and not currently
      used), not host format.  */
   memcpy (stringtab, lengthbuf, sizeof lengthbuf);
-  if (length == sizeof length)		/* Empty table -- just the count */
+  if (length == sizeof length)	/* Empty table -- just the count */
     return 0;
 
   val = bfd_read (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1, abfd);
@@ -1281,15 +1288,15 @@ free_stringtab ()
 
 static char *
 getsymname (symbol_entry)
-    struct internal_syment *symbol_entry;
+     struct internal_syment *symbol_entry;
 {
-  static char buffer[SYMNMLEN+1];
+  static char buffer[SYMNMLEN + 1];
   char *result;
 
   if (symbol_entry->_n._n_n._n_zeroes == 0)
     {
       /* FIXME: Probably should be detecting corrupt symbol files by
-	 seeing whether offset points to within the stringtab.  */
+         seeing whether offset points to within the stringtab.  */
       result = stringtab + symbol_entry->_n._n_n._n_offset;
     }
   else
@@ -1307,7 +1314,7 @@ getsymname (symbol_entry)
 
 static char *
 coff_getfilename (aux_entry)
-    union internal_auxent *aux_entry;
+     union internal_auxent *aux_entry;
 {
   static char buffer[BUFSIZ];
   register char *temp;
@@ -1339,26 +1346,26 @@ static unsigned long linetab_size;
 /* Read in all the line numbers for fast lookups later.  Leave them in
    external (unswapped) format in memory; we'll swap them as we enter
    them into GDB's data structures.  */
- 
+
 static int
 init_lineno (abfd, offset, size)
-    bfd *abfd;
-    long offset;
-    int size;
+     bfd *abfd;
+     long offset;
+     int size;
 {
   int val;
 
   linetab_offset = offset;
   linetab_size = size;
 
-  free_linetab();
+  free_linetab ();
 
   if (size == 0)
     return 0;
 
   if (bfd_seek (abfd, offset, 0) < 0)
     return -1;
-  
+
   /* Allocate the desired table, plus a sentinel */
   linetab = (char *) xmalloc (size + local_linesz);
 
@@ -1395,15 +1402,15 @@ enter_linenos (file_offset, first_line, last_line, section_offsets)
   struct internal_lineno lptr;
 
   if (!linetab)
-    return ;
+    return;
   if (file_offset < linetab_offset)
     {
       complain (&lineno_complaint, file_offset);
       if (file_offset > linetab_size)	/* Too big to be an offset? */
 	return;
-      file_offset += linetab_offset;  /* Try reading at that linetab offset */
+      file_offset += linetab_offset;	/* Try reading at that linetab offset */
     }
-  
+
   rawptr = &linetab[file_offset - linetab_offset];
 
   /* skip first line entry for each function */
@@ -1411,23 +1418,24 @@ enter_linenos (file_offset, first_line, last_line, section_offsets)
   /* line numbers start at one for the first line of the function */
   first_line--;
 
-  for (;;) {
-    bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
-    rawptr += local_linesz;
-    /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
-    if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
-      record_line (current_subfile, first_line + L_LNNO32 (&lptr),
-			lptr.l_addr.l_paddr
-			+ ANOFFSET (section_offsets, SECT_OFF_TEXT));
-    else
-      break;
-  } 
+  for (;;)
+    {
+      bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
+      rawptr += local_linesz;
+      /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
+      if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
+	record_line (current_subfile, first_line + L_LNNO32 (&lptr),
+		     lptr.l_addr.l_paddr
+		     + ANOFFSET (section_offsets, SECT_OFF_TEXT));
+      else
+	break;
+    }
 }
 
 static void
 patch_type (type, real_type)
-    struct type *type;
-    struct type *real_type;
+     struct type *type;
+     struct type *real_type;
 {
   register struct type *target = TYPE_TARGET_TYPE (type);
   register struct type *real_target = TYPE_TARGET_TYPE (real_type);
@@ -1457,15 +1465,15 @@ patch_opaque_types (s)
   register struct block *b;
   register int i;
   register struct symbol *real_sym;
-  
+
   /* Go through the per-file symbols only */
   b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
   for (i = BLOCK_NSYMS (b) - 1; i >= 0; i--)
     {
       /* Find completed typedefs to use to fix opaque ones.
-	 Remove syms from the chain when their types are stored,
-	 but search the whole chain, as there may be several syms
-	 from different files with the same name.  */
+         Remove syms from the chain when their types are stored,
+         but search the whole chain, as there may be several syms
+         from different files with the same name.  */
       real_sym = BLOCK_SYM (b, i);
       if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF &&
 	  SYMBOL_NAMESPACE (real_sym) == VAR_NAMESPACE &&
@@ -1475,7 +1483,7 @@ patch_opaque_types (s)
 	  register char *name = SYMBOL_NAME (real_sym);
 	  register int hash = hashname (name);
 	  register struct symbol *sym, *prev;
-	  
+
 	  prev = 0;
 	  for (sym = opaque_type_chain[hash]; sym;)
 	    {
@@ -1490,9 +1498,9 @@ patch_opaque_types (s)
 		    {
 		      opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
 		    }
-		  
+
 		  patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
-		  
+
 		  if (prev)
 		    {
 		      sym = SYMBOL_VALUE_CHAIN (prev);
@@ -1520,8 +1528,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
      struct objfile *objfile;
 {
   register struct symbol *sym
-    = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
-				       sizeof (struct symbol));
+  = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
+				     sizeof (struct symbol));
   char *name;
 
   memset (sym, 0, sizeof (struct symbol));
@@ -1540,8 +1548,8 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
   if (ISFCN (cs->c_type))
     {
       SYMBOL_VALUE (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
-       SYMBOL_TYPE(sym) = 
-	 lookup_function_type (decode_function_type (cs, cs->c_type, aux));
+      SYMBOL_TYPE (sym) =
+	lookup_function_type (decode_function_type (cs, cs->c_type, aux));
 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
@@ -1556,181 +1564,183 @@ process_coff_symbol (cs, aux, section_offsets, objfile)
       SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
       switch (cs->c_sclass)
 	{
-	  case C_NULL:
-	    break;
+	case C_NULL:
+	  break;
 
-	  case C_AUTO:
-	    SYMBOL_CLASS (sym) = LOC_LOCAL;
-	    add_symbol_to_list (sym, &local_symbols);
-	    break;
+	case C_AUTO:
+	  SYMBOL_CLASS (sym) = LOC_LOCAL;
+	  add_symbol_to_list (sym, &local_symbols);
+	  break;
 
-	  case C_THUMBEXT:
-	  case C_THUMBEXTFUNC:
-	  case C_EXT:
-	    SYMBOL_CLASS (sym) = LOC_STATIC;
-	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
-	    SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
-	    add_symbol_to_list (sym, &global_symbols);
-	    break;
+	case C_THUMBEXT:
+	case C_THUMBEXTFUNC:
+	case C_EXT:
+	  SYMBOL_CLASS (sym) = LOC_STATIC;
+	  SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
+	  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+	  add_symbol_to_list (sym, &global_symbols);
+	  break;
 
-	  case C_THUMBSTAT:
-	  case C_THUMBSTATFUNC:
-	  case C_STAT:
-	    SYMBOL_CLASS (sym) = LOC_STATIC;
-	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
-	    SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
-	    if (within_function) {
+	case C_THUMBSTAT:
+	case C_THUMBSTATFUNC:
+	case C_STAT:
+	  SYMBOL_CLASS (sym) = LOC_STATIC;
+	  SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
+	  SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (section_offsets, SECT_OFF_TEXT);
+	  if (within_function)
+	    {
 	      /* Static symbol of local scope */
 	      add_symbol_to_list (sym, &local_symbols);
 	    }
-	    else {
+	  else
+	    {
 	      /* Static symbol at top level of file */
 	      add_symbol_to_list (sym, &file_symbols);
 	    }
-	    break;
+	  break;
 
 #ifdef C_GLBLREG		/* AMD coff */
-	  case C_GLBLREG:
+	case C_GLBLREG:
 #endif
-	  case C_REG:
-	    SYMBOL_CLASS (sym) = LOC_REGISTER;
-	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    add_symbol_to_list (sym, &local_symbols);
-	    break;
+	case C_REG:
+	  SYMBOL_CLASS (sym) = LOC_REGISTER;
+	  SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+	  add_symbol_to_list (sym, &local_symbols);
+	  break;
 
-	  case C_THUMBLABEL:
-	  case C_LABEL:
-	    break;
+	case C_THUMBLABEL:
+	case C_LABEL:
+	  break;
 
-	  case C_ARG:
-	    SYMBOL_CLASS (sym) = LOC_ARG;
-	    add_symbol_to_list (sym, &local_symbols);
+	case C_ARG:
+	  SYMBOL_CLASS (sym) = LOC_ARG;
+	  add_symbol_to_list (sym, &local_symbols);
 #if !defined (BELIEVE_PCC_PROMOTION)
-	    if (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" of the int.  */
-		struct type *temptype;
-		temptype = lookup_fundamental_type (current_objfile,
-						    FT_INTEGER);
-		if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
-		    && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
-		    && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
-		  {
-		    SYMBOL_VALUE (sym) +=
-		      TYPE_LENGTH (temptype)
-			- TYPE_LENGTH (SYMBOL_TYPE (sym));
-		  }
-	      }
+	  if (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" of the int.  */
+	      struct type *temptype;
+	      temptype = lookup_fundamental_type (current_objfile,
+						  FT_INTEGER);
+	      if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+		  && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
+		  && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
+		{
+		  SYMBOL_VALUE (sym) +=
+		    TYPE_LENGTH (temptype)
+		    - TYPE_LENGTH (SYMBOL_TYPE (sym));
+		}
+	    }
 #endif
-	    break;
+	  break;
 
-	  case C_REGPARM:
-	    SYMBOL_CLASS (sym) = LOC_REGPARM;
-	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    add_symbol_to_list (sym, &local_symbols);
+	case C_REGPARM:
+	  SYMBOL_CLASS (sym) = LOC_REGPARM;
+	  SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+	  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 */
+	  /* FIXME:  This should retain the current type, since it's just
+	     a register value.  gnu@adobe, 26Feb93 */
+	  {
+	    /* If PCC says a parameter is a short or a char,
+	       it is really an int.  */
+	    struct type *temptype;
+	    temptype =
+	      lookup_fundamental_type (current_objfile, FT_INTEGER);
+	    if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
+		&& TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
 	      {
-	        /* If PCC says a parameter is a short or a char,
-		   it is really an int.  */
-		struct type *temptype;
-		temptype =
-		  lookup_fundamental_type (current_objfile, FT_INTEGER);
-		if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
-		    && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
-		  {
-		    SYMBOL_TYPE (sym) =
-		      (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
-		       ? lookup_fundamental_type (current_objfile,
-						  FT_UNSIGNED_INTEGER)
-		       : temptype);
-		  }
+		SYMBOL_TYPE (sym) =
+		  (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
+		   ? lookup_fundamental_type (current_objfile,
+					      FT_UNSIGNED_INTEGER)
+		   : temptype);
 	      }
+	  }
 #endif
-	    break;
-	    
-	  case C_TPDEF:
-	    SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+	  break;
 
-	    /* If type has no name, give it one */
-	    if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
-	      {
-		if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
-		    || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
-		  {
-		    /* If we are giving a name to a type such as "pointer to
-		       foo" or "function returning foo", we better not set
-		       the TYPE_NAME.  If the program contains "typedef char
-		       *caddr_t;", we don't want all variables of type char
-		       * to print as caddr_t.  This is not just a
-		       consequence of GDB's type management; CC and GCC (at
-		       least through version 2.4) both output variables of
-		       either type char * or caddr_t with the type
-		       refering to the C_TPDEF symbol for caddr_t.  If a future
-		       compiler cleans this up it GDB is not ready for it
-		       yet, but if it becomes ready we somehow need to
-		       disable this check (without breaking the PCC/GCC2.4
-		       case).
-
-		       Sigh.
-
-		       Fortunately, this check seems not to be necessary
-		       for anything except pointers or functions.  */
-		    ;
-		  }
-		else
-		  TYPE_NAME (SYMBOL_TYPE (sym)) =
-		    concat (SYMBOL_NAME (sym), NULL);
-	      }
+	case C_TPDEF:
+	  SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+	  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+	  /* If type has no name, give it one */
+	  if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+	    {
+	      if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
+		  || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+		{
+		  /* If we are giving a name to a type such as "pointer to
+		     foo" or "function returning foo", we better not set
+		     the TYPE_NAME.  If the program contains "typedef char
+		     *caddr_t;", we don't want all variables of type char
+		     * to print as caddr_t.  This is not just a
+		     consequence of GDB's type management; CC and GCC (at
+		     least through version 2.4) both output variables of
+		     either type char * or caddr_t with the type
+		     refering to the C_TPDEF symbol for caddr_t.  If a future
+		     compiler cleans this up it GDB is not ready for it
+		     yet, but if it becomes ready we somehow need to
+		     disable this check (without breaking the PCC/GCC2.4
+		     case).
+
+		     Sigh.
+
+		     Fortunately, this check seems not to be necessary
+		     for anything except pointers or functions.  */
+		  ;
+		}
+	      else
+		TYPE_NAME (SYMBOL_TYPE (sym)) =
+		  concat (SYMBOL_NAME (sym), NULL);
+	    }
 #ifdef CXUX_TARGET
-	    /* Ignore vendor section for Harris CX/UX targets. */
-            else if (cs->c_name[0] == '$') 
-	      break;
+	  /* Ignore vendor section for Harris CX/UX targets. */
+	  else if (cs->c_name[0] == '$')
+	    break;
 #endif /* CXUX_TARGET */
 
-	    /* Keep track of any type which points to empty structured type,
-		so it can be filled from a definition from another file.  A
-		simple forward reference (TYPE_CODE_UNDEF) is not an
-		empty structured type, though; the forward references
-		work themselves out via the magic of coff_lookup_type.  */
-	    if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
-		TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
-		TYPE_CODE   (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
-						TYPE_CODE_UNDEF)
-	      {
-		register int i = hashname (SYMBOL_NAME (sym));
-
-		SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
-		opaque_type_chain[i] = sym;
-	      }
-	    add_symbol_to_list (sym, &file_symbols);
-	    break;
+	  /* Keep track of any type which points to empty structured type,
+	     so it can be filled from a definition from another file.  A
+	     simple forward reference (TYPE_CODE_UNDEF) is not an
+	     empty structured type, though; the forward references
+	     work themselves out via the magic of coff_lookup_type.  */
+	  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
+	      TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
+	      TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
+	      TYPE_CODE_UNDEF)
+	    {
+	      register int i = hashname (SYMBOL_NAME (sym));
 
-	  case C_STRTAG:
-	  case C_UNTAG:
-	  case C_ENTAG:
-	    SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-	    SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
-
-            /* Some compilers try to be helpful by inventing "fake"
-               names for anonymous enums, structures, and unions, like
-               "~0fake" or ".0fake".  Thanks, but no thanks... */
-	    if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
-	      if (SYMBOL_NAME(sym) != NULL
-		  && *SYMBOL_NAME(sym) != '~'
-		  && *SYMBOL_NAME(sym) != '.')
-		TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
-		  concat (SYMBOL_NAME (sym), NULL);
+	      SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
+	      opaque_type_chain[i] = sym;
+	    }
+	  add_symbol_to_list (sym, &file_symbols);
+	  break;
 
-	    add_symbol_to_list (sym, &file_symbols);
-	    break;
+	case C_STRTAG:
+	case C_UNTAG:
+	case C_ENTAG:
+	  SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+	  SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+
+	  /* Some compilers try to be helpful by inventing "fake"
+	     names for anonymous enums, structures, and unions, like
+	     "~0fake" or ".0fake".  Thanks, but no thanks... */
+	  if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
+	    if (SYMBOL_NAME (sym) != NULL
+		&& *SYMBOL_NAME (sym) != '~'
+		&& *SYMBOL_NAME (sym) != '.')
+	      TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
+		concat (SYMBOL_NAME (sym), NULL);
+
+	  add_symbol_to_list (sym, &file_symbols);
+	  break;
 
-	  default:
-	    break;
+	default:
+	  break;
 	}
     }
   return sym;
@@ -1826,7 +1836,7 @@ decode_function_type (cs, c_type, aux)
      register union internal_auxent *aux;
 {
   if (aux->x_sym.x_tagndx.l == 0)
-    cs->c_naux = 0;	/* auxent refers to function, not base type */
+    cs->c_naux = 0;		/* auxent refers to function, not base type */
 
   return decode_type (cs, DECREF (c_type), aux);
 }
@@ -1843,140 +1853,140 @@ decode_base_type (cs, c_type, aux)
 
   switch (c_type)
     {
-      case T_NULL:
-        /* shows up with "void (*foo)();" structure members */
-	return lookup_fundamental_type (current_objfile, FT_VOID);
+    case T_NULL:
+      /* shows up with "void (*foo)();" structure members */
+      return lookup_fundamental_type (current_objfile, FT_VOID);
 
 #if 0
 /* DGUX actually defines both T_ARG and T_VOID to the same value.  */
 #ifdef T_ARG
-      case T_ARG:
-	/* Shows up in DGUX, I think.  Not sure where.  */
-	return lookup_fundamental_type (current_objfile, FT_VOID);	/* shouldn't show up here */
+    case T_ARG:
+      /* Shows up in DGUX, I think.  Not sure where.  */
+      return lookup_fundamental_type (current_objfile, FT_VOID);	/* shouldn't show up here */
 #endif
 #endif /* 0 */
 
 #ifdef T_VOID
-      case T_VOID:
-	/* Intel 960 COFF has this symbol and meaning.  */
-	return lookup_fundamental_type (current_objfile, FT_VOID);
+    case T_VOID:
+      /* Intel 960 COFF has this symbol and meaning.  */
+      return lookup_fundamental_type (current_objfile, FT_VOID);
 #endif
 
-      case T_CHAR:
-	return lookup_fundamental_type (current_objfile, FT_CHAR);
-
-      case T_SHORT:
-	return lookup_fundamental_type (current_objfile, FT_SHORT);
+    case T_CHAR:
+      return lookup_fundamental_type (current_objfile, FT_CHAR);
 
-      case T_INT:
-	return lookup_fundamental_type (current_objfile, FT_INTEGER);
+    case T_SHORT:
+      return lookup_fundamental_type (current_objfile, FT_SHORT);
 
-      case T_LONG:
-	if (cs->c_sclass == C_FIELD
-	    && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
-	  return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
-	else
-	  return lookup_fundamental_type (current_objfile, FT_LONG);
+    case T_INT:
+      return lookup_fundamental_type (current_objfile, FT_INTEGER);
 
-      case T_FLOAT:
-	return lookup_fundamental_type (current_objfile, FT_FLOAT);
+    case T_LONG:
+      if (cs->c_sclass == C_FIELD
+	  && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
+	return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
+      else
+	return lookup_fundamental_type (current_objfile, FT_LONG);
 
-      case T_DOUBLE:
-	return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
+    case T_FLOAT:
+      return lookup_fundamental_type (current_objfile, FT_FLOAT);
 
-      case T_LNGDBL:
-	return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
+    case T_DOUBLE:
+      return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
 
-      case T_STRUCT:
-	if (cs->c_naux != 1)
-	  {
-	    /* anonymous structure type */
-	    type = coff_alloc_type (cs->c_symnum);
-	    TYPE_CODE (type) = TYPE_CODE_STRUCT;
-	    TYPE_NAME (type) = NULL;
-	    /* This used to set the tag to "<opaque>".  But I think setting it
-	       to NULL is right, and the printing code can print it as
-	       "struct {...}".  */
-	    TYPE_TAG_NAME (type) = NULL;
-	    INIT_CPLUS_SPECIFIC(type);
-	    TYPE_LENGTH (type) = 0;
-	    TYPE_FIELDS (type) = 0;
-	    TYPE_NFIELDS (type) = 0;
-	  }
-	else
-	  {
-	    type = coff_read_struct_type (cs->c_symnum,
-				    aux->x_sym.x_misc.x_lnsz.x_size,
-				    aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
-	  }
-	return type;
+    case T_LNGDBL:
+      return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
 
-      case T_UNION:
-	if (cs->c_naux != 1)
-	  {
-	    /* anonymous union type */
-	    type = coff_alloc_type (cs->c_symnum);
-	    TYPE_NAME (type) = NULL;
-	    /* This used to set the tag to "<opaque>".  But I think setting it
-	       to NULL is right, and the printing code can print it as
-	       "union {...}".  */
-	    TYPE_TAG_NAME (type) = NULL;
-	    INIT_CPLUS_SPECIFIC(type);
-	    TYPE_LENGTH (type) = 0;
-	    TYPE_FIELDS (type) = 0;
-	    TYPE_NFIELDS (type) = 0;
-	  }
-	else
-	  {
-	    type = coff_read_struct_type (cs->c_symnum,
-				    aux->x_sym.x_misc.x_lnsz.x_size,
-				    aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
-	  }
-	TYPE_CODE (type) = TYPE_CODE_UNION;
-	return type;
+    case T_STRUCT:
+      if (cs->c_naux != 1)
+	{
+	  /* anonymous structure type */
+	  type = coff_alloc_type (cs->c_symnum);
+	  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+	  TYPE_NAME (type) = NULL;
+	  /* This used to set the tag to "<opaque>".  But I think setting it
+	     to NULL is right, and the printing code can print it as
+	     "struct {...}".  */
+	  TYPE_TAG_NAME (type) = NULL;
+	  INIT_CPLUS_SPECIFIC (type);
+	  TYPE_LENGTH (type) = 0;
+	  TYPE_FIELDS (type) = 0;
+	  TYPE_NFIELDS (type) = 0;
+	}
+      else
+	{
+	  type = coff_read_struct_type (cs->c_symnum,
+					aux->x_sym.x_misc.x_lnsz.x_size,
+				      aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+	}
+      return type;
 
-      case T_ENUM:
-	if (cs->c_naux != 1)
-	  {
-	    /* anonymous enum type */
-	    type = coff_alloc_type (cs->c_symnum);
-	    TYPE_CODE (type) = TYPE_CODE_ENUM;
-	    TYPE_NAME (type) = NULL;
-	    /* This used to set the tag to "<opaque>".  But I think setting it
-	       to NULL is right, and the printing code can print it as
-	       "enum {...}".  */
-	    TYPE_TAG_NAME (type) = NULL;
-	    TYPE_LENGTH (type) = 0;
-	    TYPE_FIELDS (type) = 0;
-	    TYPE_NFIELDS(type) = 0;
-	  }
-	else
-	  {
-	    type = coff_read_enum_type (cs->c_symnum,
+    case T_UNION:
+      if (cs->c_naux != 1)
+	{
+	  /* anonymous union type */
+	  type = coff_alloc_type (cs->c_symnum);
+	  TYPE_NAME (type) = NULL;
+	  /* This used to set the tag to "<opaque>".  But I think setting it
+	     to NULL is right, and the printing code can print it as
+	     "union {...}".  */
+	  TYPE_TAG_NAME (type) = NULL;
+	  INIT_CPLUS_SPECIFIC (type);
+	  TYPE_LENGTH (type) = 0;
+	  TYPE_FIELDS (type) = 0;
+	  TYPE_NFIELDS (type) = 0;
+	}
+      else
+	{
+	  type = coff_read_struct_type (cs->c_symnum,
 					aux->x_sym.x_misc.x_lnsz.x_size,
-					aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
-	  }
-	return type;
+				      aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+	}
+      TYPE_CODE (type) = TYPE_CODE_UNION;
+      return type;
 
-      case T_MOE:
-	/* shouldn't show up here */
-	break;
+    case T_ENUM:
+      if (cs->c_naux != 1)
+	{
+	  /* anonymous enum type */
+	  type = coff_alloc_type (cs->c_symnum);
+	  TYPE_CODE (type) = TYPE_CODE_ENUM;
+	  TYPE_NAME (type) = NULL;
+	  /* This used to set the tag to "<opaque>".  But I think setting it
+	     to NULL is right, and the printing code can print it as
+	     "enum {...}".  */
+	  TYPE_TAG_NAME (type) = NULL;
+	  TYPE_LENGTH (type) = 0;
+	  TYPE_FIELDS (type) = 0;
+	  TYPE_NFIELDS (type) = 0;
+	}
+      else
+	{
+	  type = coff_read_enum_type (cs->c_symnum,
+				      aux->x_sym.x_misc.x_lnsz.x_size,
+				      aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+	}
+      return type;
+
+    case T_MOE:
+      /* shouldn't show up here */
+      break;
 
-      case T_UCHAR:
-	return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
+    case T_UCHAR:
+      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
 
-      case T_USHORT:
-	return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
+    case T_USHORT:
+      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
 
-      case T_UINT:
-	return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
+    case T_UINT:
+      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
 
-      case T_ULONG:
-	if (cs->c_sclass == C_FIELD
-	    && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
-	  return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
-	else
-	  return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
+    case T_ULONG:
+      if (cs->c_sclass == C_FIELD
+	  && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
+	return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
+      else
+	return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
     }
   complain (&unexpected_type_complaint, cs->c_name);
   return lookup_fundamental_type (current_objfile, FT_VOID);
@@ -2013,7 +2023,7 @@ coff_read_struct_type (index, length, lastsym)
 
   type = coff_alloc_type (index);
   TYPE_CODE (type) = TYPE_CODE_STRUCT;
-  INIT_CPLUS_SPECIFIC(type);
+  INIT_CPLUS_SPECIFIC (type);
   TYPE_LENGTH (type) = length;
 
   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
@@ -2024,46 +2034,46 @@ coff_read_struct_type (index, length, lastsym)
 
       switch (ms->c_sclass)
 	{
-	  case C_MOS:
-	  case C_MOU:
-
-	    /* Get space to record the next field's data.  */
-	    new = (struct nextfield *) alloca (sizeof (struct nextfield));
-	    new->next = list;
-	    list = new;
-
-	    /* Save the data.  */
-	    list->field.name =
-	      obsavestring (name,
-			    strlen (name),
-			    &current_objfile->symbol_obstack);
-	    FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
-	    FIELD_BITPOS (list->field) = 8 * ms->c_value;
-	    FIELD_BITSIZE (list->field) = 0;
-	    nfields++;
-	    break;
+	case C_MOS:
+	case C_MOU:
+
+	  /* Get space to record the next field's data.  */
+	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	  new->next = list;
+	  list = new;
+
+	  /* Save the data.  */
+	  list->field.name =
+	    obsavestring (name,
+			  strlen (name),
+			  &current_objfile->symbol_obstack);
+	  FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
+	  FIELD_BITPOS (list->field) = 8 * ms->c_value;
+	  FIELD_BITSIZE (list->field) = 0;
+	  nfields++;
+	  break;
 
-	  case C_FIELD:
-
-	    /* Get space to record the next field's data.  */
-	    new = (struct nextfield *) alloca (sizeof (struct nextfield));
-	    new->next = list;
-	    list = new;
-
-	    /* Save the data.  */
-	    list->field.name =
-	      obsavestring (name,
-			    strlen (name),
-			    &current_objfile->symbol_obstack);
-	    FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
-	    FIELD_BITPOS (list->field) = ms->c_value;
-	    FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
-	    nfields++;
-	    break;
+	case C_FIELD:
+
+	  /* Get space to record the next field's data.  */
+	  new = (struct nextfield *) alloca (sizeof (struct nextfield));
+	  new->next = list;
+	  list = new;
+
+	  /* Save the data.  */
+	  list->field.name =
+	    obsavestring (name,
+			  strlen (name),
+			  &current_objfile->symbol_obstack);
+	  FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
+	  FIELD_BITPOS (list->field) = ms->c_value;
+	  FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
+	  nfields++;
+	  break;
 
-	  case C_EOS:
-	    done = 1;
-	    break;
+	case C_EOS:
+	  done = 1;
+	  break;
 	}
     }
   /* Now create the vector of fields, and record how big it is.  */
@@ -2122,28 +2132,28 @@ coff_read_enum_type (index, length, lastsym)
 
       switch (ms->c_sclass)
 	{
-	  case C_MOE:
-	    sym = (struct symbol *) obstack_alloc
-	      (&current_objfile->symbol_obstack,
-	       sizeof (struct symbol));
-	    memset (sym, 0, sizeof (struct symbol));
-
-	    SYMBOL_NAME (sym) =
-	      obsavestring (name, strlen (name),
-			    &current_objfile->symbol_obstack);
-	    SYMBOL_CLASS (sym) = LOC_CONST;
-	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-	    SYMBOL_VALUE (sym) = ms->c_value;
-	    add_symbol_to_list (sym, symlist);
-	    nsyms++;
-	    break;
+	case C_MOE:
+	  sym = (struct symbol *) obstack_alloc
+	    (&current_objfile->symbol_obstack,
+	     sizeof (struct symbol));
+	  memset (sym, 0, sizeof (struct symbol));
+
+	  SYMBOL_NAME (sym) =
+	    obsavestring (name, strlen (name),
+			  &current_objfile->symbol_obstack);
+	  SYMBOL_CLASS (sym) = LOC_CONST;
+	  SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+	  SYMBOL_VALUE (sym) = ms->c_value;
+	  add_symbol_to_list (sym, symlist);
+	  nsyms++;
+	  break;
 
-	  case C_EOS:
-	    /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
-	       up the count of how many symbols to read.  So stop
-	       on .eos.  */
-	    done = 1;
-	    break;
+	case C_EOS:
+	  /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
+	     up the count of how many symbols to read.  So stop
+	     on .eos.  */
+	  done = 1;
+	  break;
 	}
     }
 
@@ -2152,7 +2162,7 @@ coff_read_enum_type (index, length, lastsym)
   if (length > 0)
     TYPE_LENGTH (type) = length;
   else
-    TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */
+    TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;	/* Assume ints */
   TYPE_CODE (type) = TYPE_CODE_ENUM;
   TYPE_NFIELDS (type) = nsyms;
   TYPE_FIELDS (type) = (struct field *)
@@ -2172,7 +2182,7 @@ coff_read_enum_type (index, length, lastsym)
 
       if (syms == osyms)
 	j = o_nsyms;
-      for (; j < syms->nsyms; j++,n++)
+      for (; j < syms->nsyms; j++, n++)
 	{
 	  struct symbol *xsym = syms->symbol[j];
 	  SYMBOL_TYPE (xsym) = type;
@@ -2197,13 +2207,13 @@ coff_read_enum_type (index, length, lastsym)
 static struct sym_fns coff_sym_fns =
 {
   bfd_target_coff_flavour,
-  coff_new_init,	/* sym_new_init: init anything gbl to entire symtab */
-  coff_symfile_init,	/* sym_init: read initial info, setup for sym_read() */
-  coff_symfile_read,	/* sym_read: read a symbol file into symtab */
-  coff_symfile_finish,	/* sym_finish: finished with file, cleanup */
+  coff_new_init,		/* sym_new_init: init anything gbl to entire symtab */
+  coff_symfile_init,		/* sym_init: read initial info, setup for sym_read() */
+  coff_symfile_read,		/* sym_read: read a symbol file into symtab */
+  coff_symfile_finish,		/* sym_finish: finished with file, cleanup */
   default_symfile_offsets,
 			/* sym_offsets:  xlate external to internal form */
-  NULL			/* next: pointer to next struct sym_fns */
+  NULL				/* next: pointer to next struct sym_fns */
 };
 
 void