X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fmdebugread.c;h=78b92a04e2cae8a8a3aa2e7cf59b2e48c6195ea8;hb=4e99ad6974d2233414bccf6989139dead4132704;hp=5207b7e3930dc38c0f352b9c07d95d459a344454;hpb=1f04aa626601752ffbb4af60a478a1f1e8e0ad6b;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index 5207b7e393..78b92a04e2 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -1,8 +1,8 @@
 /* Read a symbol table in ECOFF format (Third-Eye).
 
-   Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
-   Foundation, Inc.
+   Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
+   Free Software Foundation, Inc.
 
    Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
    CMU.  Major work by Per Bothner, John Gilmore and Ian Lance Taylor
@@ -12,7 +12,7 @@
 
    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
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -21,9 +21,7 @@
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* This module provides the function mdebug_build_psymtabs.  It reads
    ECOFF debugging information into partial symbol tables.  The
@@ -56,26 +54,7 @@
 #include "gdb_assert.h"
 #include "block.h"
 #include "dictionary.h"
-
-/* These are needed if the tm.h file does not contain the necessary
-   mips specific definitions.  */
-
-#ifndef MIPS_EFI_SYMBOL_NAME
-#define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
-extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR);
-#include "coff/sym.h"
-#include "coff/symconst.h"
-typedef struct mips_extra_func_info
-  {
-    long numargs;
-    PDR pdr;
-  }
- *mips_extra_func_info_t;
-#ifndef RA_REGNUM
-#define RA_REGNUM 0
-#endif
-#endif
-
+#include "mdebugread.h"
 #include "gdb_stat.h"
 #include "gdb_string.h"
 
@@ -88,7 +67,6 @@ typedef struct mips_extra_func_info
 #include "aout/stab_gnu.h"	/* STABS information */
 
 #include "expression.h"
-#include "language.h"		/* For local_hex_string() */
 
 extern void _initialize_mdebugread (void);
 
@@ -144,39 +122,39 @@ struct symloc
 static void
 index_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, "bad aux index at symbol %s", arg1);
+  complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
 }
 
 static void
 unknown_ext_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, "unknown external symbol %s", arg1);
+  complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
 }
 
 static void
 basic_type_complaint (int arg1, const char *arg2)
 {
-  complaint (&symfile_complaints, "cannot map ECOFF basic type 0x%x for %s",
+  complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
 	     arg1, arg2);
 }
 
 static void
 bad_tag_guess_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, "guessed tag type of %s incorrectly", arg1);
+  complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
 }
 
 static void
 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
 {
-  complaint (&symfile_complaints, "bad rfd entry for %s: file %d, index %d",
+  complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
 	     arg1, arg2, arg3);
 }
 
 static void
 unexpected_type_code_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, "unexpected type code for %s", arg1);
+  complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
 }
 
 /* Macros and extra defs */
@@ -229,39 +207,6 @@ static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs;
 
 static char stabs_symbol[] = STABS_SYMBOL;
 
-/* Types corresponding to mdebug format bt* basic types.  */
-
-static struct type *mdebug_type_void;
-static struct type *mdebug_type_char;
-static struct type *mdebug_type_short;
-static struct type *mdebug_type_int_32;
-#define mdebug_type_int mdebug_type_int_32
-static struct type *mdebug_type_int_64;
-static struct type *mdebug_type_long_32;
-static struct type *mdebug_type_long_64;
-static struct type *mdebug_type_long_long_64;
-static struct type *mdebug_type_unsigned_char;
-static struct type *mdebug_type_unsigned_short;
-static struct type *mdebug_type_unsigned_int_32;
-static struct type *mdebug_type_unsigned_int_64;
-static struct type *mdebug_type_unsigned_long_32;
-static struct type *mdebug_type_unsigned_long_64;
-static struct type *mdebug_type_unsigned_long_long_64;
-static struct type *mdebug_type_adr_32;
-static struct type *mdebug_type_adr_64;
-static struct type *mdebug_type_float;
-static struct type *mdebug_type_double;
-static struct type *mdebug_type_complex;
-static struct type *mdebug_type_double_complex;
-static struct type *mdebug_type_fixed_dec;
-static struct type *mdebug_type_float_dec;
-static struct type *mdebug_type_string;
-
-/* Types for symbols from files compiled without debugging info.  */
-
-static struct type *nodebug_func_symbol_type;
-static struct type *nodebug_var_symbol_type;
-
 /* Nonzero if we have seen ecoff debugging info for a file.  */
 
 static int found_ecoff_debugging_info;
@@ -306,7 +251,7 @@ static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
 
 static void add_block (struct block *, struct symtab *);
 
-static void add_symbol (struct symbol *, struct block *);
+static void add_symbol (struct symbol *, struct symtab *, struct block *);
 
 static int add_line (struct linetable *, int, CORE_ADDR, int);
 
@@ -317,17 +262,6 @@ static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
 
 static char *mdebug_next_symbol_text (struct objfile *);
 
-/* Allocate zeroed memory */
-
-static void *
-xzalloc (unsigned int size)
-{
-  void *p = xmalloc (size);
-
-  memset (p, 0, size);
-  return p;
-}
-
 /* Exported procedure: Builds a symtab from the PST partial one.
    Restores the environment in effect when PST was created, delegates
    most of the work to an ancillary procedure, and sorts
@@ -342,7 +276,7 @@ mdebug_psymtab_to_symtab (struct partial_symtab *pst)
 
   if (info_verbose)
     {
-      printf_filtered ("Reading in symbols for %s...", pst->filename);
+      printf_filtered (_("Reading in symbols for %s..."), pst->filename);
       gdb_flush (gdb_stdout);
     }
 
@@ -355,7 +289,7 @@ mdebug_psymtab_to_symtab (struct partial_symtab *pst)
   scan_file_globals (pst->objfile);
 
   if (info_verbose)
-    printf_filtered ("done.\n");
+    printf_filtered (_("done.\n"));
 }
 
 /* File-level interface functions */
@@ -438,9 +372,9 @@ mdebug_build_psymtabs (struct objfile *objfile,
   if (compare_glevel (max_glevel, GLEVEL_2) < 0)
     {
       if (max_gdbinfo == 0)
-	printf_unfiltered ("\n%s not compiled with -g, debugging support is limited.\n",
+	printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"),
 			   objfile->name);
-      printf_unfiltered ("You should compile with -g2 or -g3 for best debugging support.\n");
+      printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n"));
       gdb_flush (gdb_stdout);
     }
 #endif
@@ -537,9 +471,9 @@ struct mdebug_pending
 
 
 /* The pending information is kept for an entire object file, and used
-   to be in the sym_private field.  I took it out when I split
-   mdebugread from mipsread, because this might not be the only type
-   of symbols read from an object file.  Instead, we allocate the
+   to be in the deprecated_sym_private field.  I took it out when I
+   split mdebugread from mipsread, because this might not be the only
+   type of symbols read from an object file.  Instead, we allocate the
    pending information table when we create the partial symbols, and
    we store a pointer to the single table in each psymtab.  */
 
@@ -593,10 +527,21 @@ add_pending (FDR *fh, char *sh, struct type *t)
    aux symbols are big-endian or little-endian.  Return count of
    SYMR's handled (normally one).  */
 
+static int
+mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
+{
+  return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+}
+
+static const struct symbol_register_ops mdebug_register_funcs = {
+  mdebug_reg_to_regnum
+};
+
 static int
 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	      struct section_offsets *section_offsets, struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
   void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
   char *name;
@@ -663,7 +608,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	  /* It is a FORTRAN common block.  At least for SGI Fortran the
 	     address is not in the symbol; we need to fix it later in
 	     scan_file_globals.  */
-	  int bucket = hashname (DEPRECATED_SYMBOL_NAME (s));
+	  int bucket = hashname (SYMBOL_LINKAGE_NAME (s));
 	  SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
 	  global_sym_chain[bucket] = s;
 	}
@@ -672,26 +617,26 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       goto data;
 
     case stLocal:		/* local variable, goes into current block */
+      b = top_stack->cur_block;
+      s = new_symbol (name);
+      SYMBOL_VALUE (s) = svalue;
       if (sh->sc == scRegister)
 	{
 	  class = LOC_REGISTER;
-	  svalue = ECOFF_REG_TO_REGNUM (svalue);
+	  SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
 	}
       else
 	class = LOC_LOCAL;
-      b = top_stack->cur_block;
-      s = new_symbol (name);
-      SYMBOL_VALUE (s) = svalue;
 
     data:			/* Common code for symbols describing data */
       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
       SYMBOL_CLASS (s) = class;
-      add_symbol (s, b);
+      add_symbol (s, top_stack->cur_st, b);
 
       /* Type could be missing if file is compiled without debugging info.  */
       if (SC_IS_UNDEF (sh->sc)
 	  || sh->sc == scNil || sh->index == indexNil)
-	SYMBOL_TYPE (s) = nodebug_var_symbol_type;
+	SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_data_symbol;
       else
 	SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
       /* Value of a data symbol is its memory address */
@@ -708,12 +653,13 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       s = new_symbol (name);
 
       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
+      SYMBOL_IS_ARGUMENT (s) = 1;
       switch (sh->sc)
 	{
 	case scRegister:
 	  /* Pass by value in register.  */
-	  SYMBOL_CLASS (s) = LOC_REGPARM;
-	  svalue = ECOFF_REG_TO_REGNUM (svalue);
+	  SYMBOL_CLASS (s) = LOC_REGISTER;
+	  SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
 	  break;
 	case scVar:
 	  /* Pass by reference on stack.  */
@@ -722,7 +668,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	case scVarRegister:
 	  /* Pass by reference in register.  */
 	  SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
-	  svalue = ECOFF_REG_TO_REGNUM (svalue);
+	  SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs;
 	  break;
 	default:
 	  /* Pass by value on stack.  */
@@ -731,7 +677,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	}
       SYMBOL_VALUE (s) = svalue;
       SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
-      add_symbol (s, top_stack->cur_block);
+      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
     case stLabel:		/* label, goes into current block */
@@ -739,8 +685,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_DOMAIN (s) = VAR_DOMAIN;	/* so that it can be used */
       SYMBOL_CLASS (s) = LOC_LABEL;	/* but not misused */
       SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
-      SYMBOL_TYPE (s) = mdebug_type_int;
-      add_symbol (s, top_stack->cur_block);
+      SYMBOL_TYPE (s) = builtin_type (gdbarch)->builtin_int;
+      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
     case stProc:		/* Procedure, usually goes into global block */
@@ -771,7 +717,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                     break;
                   default:
                     complaint (&symfile_complaints,
-                               "unknown symbol type 0x%x", sh->st);
+                               _("unknown symbol type 0x%x"), sh->st);
                     break;
                 }
             }
@@ -782,7 +728,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Type of the return value */
       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
-	t = mdebug_type_int;
+	t = builtin_type (gdbarch)->builtin_int;
       else
 	{
 	  t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
@@ -808,7 +754,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	  struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
 	  /* The next test should normally be true, but provides a
 	     hook for nested functions (which we don't want to make
-	     global). */
+	     global).  */
 	  if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
 	    b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 	  /* Irix 5 sometimes has duplicate names for the same
@@ -817,7 +763,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	  else if (sh->value == top_stack->procadr)
 	    b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
 	}
-      add_symbol (s, b);
+      add_symbol (s, top_stack->cur_st, b);
 
       /* Make a type for the procedure itself */
       SYMBOL_TYPE (s) = lookup_function_type (t);
@@ -825,7 +771,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       /* All functions in C++ have prototypes.  For C we don't have enough
          information in the debug info.  */
       if (SYMBOL_LANGUAGE (s) == language_cplus)
-	TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED;
+	TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
 
       /* Create and enter a new lexical context */
       b = new_block (FUNCTION_BLOCK);
@@ -988,7 +934,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 
 	      default:
 		complaint (&symfile_complaints,
-			   "declaration block contains unhandled symbol type %d",
+			   _("declaration block contains unhandled symbol type %d"),
 			   tsym.st);
 	      }
 	  }
@@ -1077,7 +1023,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	       that too.  */
 	    if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
 		|| TYPE_LENGTH (t) == 0)
-	      TYPE_LENGTH (t) = TARGET_INT_BIT / HOST_CHAR_BIT;
+	      TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
 	    for (ext_tsym = ext_sh + external_sym_size;
 		 ;
 		 ext_tsym += external_sym_size)
@@ -1090,33 +1036,32 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 		if (tsym.st != stMember)
 		  break;
 
-		FIELD_BITPOS (*f) = tsym.value;
+		SET_FIELD_BITPOS (*f, tsym.value);
 		FIELD_TYPE (*f) = t;
 		FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
 		FIELD_BITSIZE (*f) = 0;
-		FIELD_STATIC_KIND (*f) = 0;
 
 		enum_sym = ((struct symbol *)
 			    obstack_alloc (&current_objfile->objfile_obstack,
 					   sizeof (struct symbol)));
 		memset (enum_sym, 0, sizeof (struct symbol));
-		DEPRECATED_SYMBOL_NAME (enum_sym) =
-		  obsavestring (f->name, strlen (f->name),
-				&current_objfile->objfile_obstack);
+		SYMBOL_SET_LINKAGE_NAME
+		  (enum_sym, obsavestring (f->name, strlen (f->name),
+					   &current_objfile->objfile_obstack));
 		SYMBOL_CLASS (enum_sym) = LOC_CONST;
 		SYMBOL_TYPE (enum_sym) = t;
 		SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
 		SYMBOL_VALUE (enum_sym) = tsym.value;
 		if (SYMBOL_VALUE (enum_sym) < 0)
 		  unsigned_enum = 0;
-		add_symbol (enum_sym, top_stack->cur_block);
+		add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block);
 
 		/* Skip the stMembers that we've handled. */
 		count++;
 		f++;
 	      }
 	    if (unsigned_enum)
-	      TYPE_FLAGS (t) |= TYPE_FLAG_UNSIGNED;
+	      TYPE_UNSIGNED (t) = 1;
 	  }
 	/* make this the current type */
 	top_stack->cur_type = t;
@@ -1130,7 +1075,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	   do not create a symbol for it either.  */
 	if (TYPE_NFIELDS (t) == 0)
 	  {
-	    TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
+	    TYPE_STUB (t) = 1;
 	    break;
 	  }
 
@@ -1139,7 +1084,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	SYMBOL_CLASS (s) = LOC_TYPEDEF;
 	SYMBOL_VALUE (s) = 0;
 	SYMBOL_TYPE (s) = t;
-	add_symbol (s, top_stack->cur_block);
+	add_symbol (s, top_stack->cur_st, top_stack->cur_block);
 	break;
 
 	/* End of local variables shared by struct, union, enum, and
@@ -1182,7 +1127,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	{
 	  /* Finished with procedure */
 	  struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
-	  struct mips_extra_func_info *e;
+	  struct mdebug_extra_func_info *e;
 	  struct block *b = top_stack->cur_block;
 	  struct type *ftype = top_stack->cur_type;
 	  int i;
@@ -1190,18 +1135,18 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	  BLOCK_END (top_stack->cur_block) += sh->value;	/* size */
 
 	  /* Make up special symbol to contain procedure specific info */
-	  s = new_symbol (MIPS_EFI_SYMBOL_NAME);
+	  s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
 	  SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
 	  SYMBOL_CLASS (s) = LOC_CONST;
-	  SYMBOL_TYPE (s) = mdebug_type_void;
-	  e = ((struct mips_extra_func_info *)
+	  SYMBOL_TYPE (s) = builtin_type_void;
+	  e = ((struct mdebug_extra_func_info *)
 	       obstack_alloc (&current_objfile->objfile_obstack,
-			      sizeof (struct mips_extra_func_info)));
-	  memset (e, 0, sizeof (struct mips_extra_func_info));
-	  SYMBOL_VALUE (s) = (long) e;
+			      sizeof (struct mdebug_extra_func_info)));
+	  memset (e, 0, sizeof (struct mdebug_extra_func_info));
+	  SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
 	  e->numargs = top_stack->numargs;
 	  e->pdr.framereg = -1;
-	  add_symbol (s, top_stack->cur_block);
+	  add_symbol (s, top_stack->cur_st, top_stack->cur_block);
 
 	  /* f77 emits proc-level with address bounds==[0,0],
 	     So look for such child blocks, and patch them.  */
@@ -1238,18 +1183,11 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 		      if (iparams == nparams)
 			break;
 
-		      switch (SYMBOL_CLASS (sym))
+		      if (SYMBOL_IS_ARGUMENT (sym))
 			{
-			case LOC_ARG:
-			case LOC_REF_ARG:
-			case LOC_REGPARM:
-			case LOC_REGPARM_ADDR:
 			  TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
 			  TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
 			  iparams++;
-			  break;
-			default:
-			  break;
 			}
 		    }
 		}
@@ -1276,7 +1214,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	}
       else
 	complaint (&symfile_complaints,
-		   "stEnd with storage class %d not handled", sh->sc);
+		   _("stEnd with storage class %d not handled"), sh->sc);
 
       pop_parse_stack ();	/* restore previous lexical context */
       break;
@@ -1284,11 +1222,10 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
     case stMember:		/* member of struct or union */
       f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
       FIELD_NAME (*f) = name;
-      FIELD_BITPOS (*f) = sh->value;
+      SET_FIELD_BITPOS (*f, sh->value);
       bitsize = 0;
       FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
       FIELD_BITSIZE (*f) = bitsize;
-      FIELD_STATIC_KIND (*f) = 0;
       break;
 
     case stIndirect:		/* forward declaration on Irix5 */
@@ -1340,7 +1277,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_CLASS (s) = LOC_TYPEDEF;
       SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
       SYMBOL_TYPE (s) = t;
-      add_symbol (s, top_stack->cur_block);
+      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
 
       /* Incomplete definitions of structs should not get a name.  */
       if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
@@ -1371,7 +1308,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 	         for anything except pointers or functions.  */
 	    }
 	  else
-	    TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s);
+	    TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
 	}
       break;
 
@@ -1388,13 +1325,186 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
     case stConstant:
       break;			/* constant */
     default:
-      complaint (&symfile_complaints, "unknown symbol type 0x%x", sh->st);
+      complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
       break;
     }
 
   return count;
 }
 
+/* Basic types.  */
+
+static const struct objfile_data *basic_type_data;
+
+static struct type *
+basic_type (int bt, struct objfile *objfile)
+{
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct type **map_bt = objfile_data (objfile, basic_type_data);
+  struct type *tp;
+
+  if (bt >= btMax)
+    return NULL;
+
+  if (!map_bt)
+    {
+      map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
+			       btMax, struct type *);
+      set_objfile_data (objfile, basic_type_data, map_bt);
+    }
+
+  if (map_bt[bt])
+    return map_bt[bt];
+
+  switch (bt)
+    {
+    case btNil:
+      tp = builtin_type_void;
+      break;
+
+    case btAdr:
+      tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED,
+		      "adr_32", objfile);
+      TYPE_TARGET_TYPE (tp) = builtin_type_void;
+      break;
+
+    case btChar:
+      tp = init_type (TYPE_CODE_INT, 1, 0,
+		      "char", objfile);
+      break;
+
+    case btUChar:
+      tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
+		      "unsigned char", objfile);
+      break;
+
+    case btShort:
+      tp = init_type (TYPE_CODE_INT, 2, 0,
+		      "short", objfile);
+      break;
+
+    case btUShort:
+      tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
+		      "unsigned short", objfile);
+      break;
+
+    case btInt:
+      tp = init_type (TYPE_CODE_INT, 4, 0,
+		      "int", objfile);
+      break;
+
+   case btUInt:
+      tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+		      "unsigned int", objfile);
+      break;
+
+    case btLong:
+      tp = init_type (TYPE_CODE_INT, 4, 0,
+		      "long", objfile);
+      break;
+
+    case btULong:
+      tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
+		      "unsigned long", objfile);
+      break;
+
+    case btFloat:
+      tp = init_type (TYPE_CODE_FLT,
+		      gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "float", objfile);
+      break;
+
+    case btDouble:
+      tp = init_type (TYPE_CODE_FLT,
+		      gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "double", objfile);
+      break;
+
+    case btComplex:
+      tp = init_type (TYPE_CODE_COMPLEX,
+		      2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "complex", objfile);
+      TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile);
+      break;
+
+    case btDComplex:
+      tp = init_type (TYPE_CODE_COMPLEX,
+		      2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "double complex", objfile);
+      TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile);
+      break;
+
+    case btFixedDec:
+      /* We use TYPE_CODE_INT to print these as integers.  Does this do any
+	 good?  Would we be better off with TYPE_CODE_ERROR?  Should
+	 TYPE_CODE_ERROR print things in hex if it knows the size?  */
+      tp = init_type (TYPE_CODE_INT,
+		      gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "fixed decimal", objfile);
+      break;
+
+    case btFloatDec:
+      tp = init_type (TYPE_CODE_ERROR,
+		      gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0,
+		      "floating decimal", objfile);
+      break;
+
+    case btString:
+      /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
+	 FIXME.  */
+      tp = init_type (TYPE_CODE_STRING, 1, 0,
+		      "string", objfile);
+      break;
+
+    case btVoid:
+      tp = builtin_type_void;
+      break;
+
+    case btLong64:
+      tp = init_type (TYPE_CODE_INT, 8, 0,
+		      "long", objfile);
+      break;
+
+    case btULong64:
+      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+		      "unsigned long", objfile);
+      break;
+
+    case btLongLong64:
+      tp = init_type (TYPE_CODE_INT, 8, 0,
+		      "long long", objfile);
+      break;
+
+    case btULongLong64:
+      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+		      "unsigned long long", objfile);
+      break;
+
+    case btAdr64:
+      tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED,
+		      "adr_64", objfile);
+      TYPE_TARGET_TYPE (tp) = builtin_type_void;
+      break;
+
+    case btInt64:
+      tp = init_type (TYPE_CODE_INT, 8, 0,
+		      "int", objfile);
+      break;
+
+    case btUInt64:
+      tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
+		      "unsigned int", objfile);
+      break;
+
+    default:
+      tp = NULL;
+      break;
+    }
+
+  map_bt[bt] = tp;
+  return tp;
+}
+
 /* Parse the type information provided in the raw AX entries for
    the symbol SH. Return the bitfield size in BS, in case.
    We must byte-swap the AX entries before we use them; BIGEND says whether
@@ -1404,78 +1514,27 @@ static struct type *
 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 	    int bigend, char *sym_name)
 {
-  /* Null entries in this map are treated specially */
-  static struct type **map_bt[] =
-  {
-    &mdebug_type_void,		/* btNil */
-    &mdebug_type_adr_32,	/* btAdr */
-    &mdebug_type_char,		/* btChar */
-    &mdebug_type_unsigned_char,	/* btUChar */
-    &mdebug_type_short,		/* btShort */
-    &mdebug_type_unsigned_short,	/* btUShort */
-    &mdebug_type_int_32,	/* btInt */
-    &mdebug_type_unsigned_int_32,	/* btUInt */
-    &mdebug_type_long_32,	/* btLong */
-    &mdebug_type_unsigned_long_32,	/* btULong */
-    &mdebug_type_float,		/* btFloat */
-    &mdebug_type_double,	/* btDouble */
-    0,				/* btStruct */
-    0,				/* btUnion */
-    0,				/* btEnum */
-    0,				/* btTypedef */
-    0,				/* btRange */
-    0,				/* btSet */
-    &mdebug_type_complex,	/* btComplex */
-    &mdebug_type_double_complex,	/* btDComplex */
-    0,				/* btIndirect */
-    &mdebug_type_fixed_dec,	/* btFixedDec */
-    &mdebug_type_float_dec,	/* btFloatDec */
-    &mdebug_type_string,	/* btString */
-    0,				/* btBit */
-    0,				/* btPicture */
-    &mdebug_type_void,		/* btVoid */
-    0,				/* DEC C++:  Pointer to member */
-    0,				/* DEC C++:  Virtual function table */
-    0,				/* DEC C++:  Class (Record) */
-    &mdebug_type_long_64,	/* btLong64  */
-    &mdebug_type_unsigned_long_64,	/* btULong64 */
-    &mdebug_type_long_long_64,	/* btLongLong64  */
-    &mdebug_type_unsigned_long_long_64,		/* btULongLong64 */
-    &mdebug_type_adr_64,	/* btAdr64 */
-    &mdebug_type_int_64,	/* btInt64  */
-    &mdebug_type_unsigned_int_64,	/* btUInt64 */
-  };
-
   TIR t[1];
   struct type *tp = 0;
   enum type_code type_code = TYPE_CODE_UNDEF;
 
   /* Handle undefined types, they have indexNil. */
   if (aux_index == indexNil)
-    return mdebug_type_int;
+    return basic_type (btInt, current_objfile);
 
   /* Handle corrupt aux indices.  */
   if (aux_index >= (debug_info->fdr + fd)->caux)
     {
       index_complaint (sym_name);
-      return mdebug_type_int;
+      return basic_type (btInt, current_objfile);
     }
   ax += aux_index;
 
   /* Use aux as a type information record, map its basic type.  */
   (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
-  if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
-    {
-      basic_type_complaint (t->bt, sym_name);
-      return mdebug_type_int;
-    }
-  if (map_bt[t->bt])
+  tp = basic_type (t->bt, current_objfile);
+  if (tp == NULL)
     {
-      tp = *map_bt[t->bt];
-    }
-  else
-    {
-      tp = NULL;
       /* Cannot use builtin types -- build our own */
       switch (t->bt)
 	{
@@ -1506,7 +1565,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 	  break;
 	default:
 	  basic_type_complaint (t->bt, sym_name);
-	  return mdebug_type_int;
+	  return basic_type (btInt, current_objfile);
 	}
     }
 
@@ -1523,13 +1582,13 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 	     as short and unsigned short types with a field width of 8.
 	     Enum types also have a field width which we ignore for now.  */
 	  if (t->bt == btShort && width == 8)
-	    tp = mdebug_type_char;
+	    tp = basic_type (btChar, current_objfile);
 	  else if (t->bt == btUShort && width == 8)
-	    tp = mdebug_type_unsigned_char;
+	    tp = basic_type (btUChar, current_objfile);
 	  else if (t->bt == btEnum)
 	    ;
 	  else
-	    complaint (&symfile_complaints, "can't handle TIR fBitfield for %s",
+	    complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
 		       sym_name);
 	}
       else
@@ -1559,8 +1618,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
       if (rf == -1)
 	{
 	  complaint (&symfile_complaints,
-		     "unable to cross ref btIndirect for %s", sym_name);
-	  return mdebug_type_int;
+		     _("unable to cross ref btIndirect for %s"), sym_name);
+	  return basic_type (btInt, current_objfile);
 	}
       xref_fh = get_rfd (fd, rf);
       xref_fd = xref_fh - debug_info->fdr;
@@ -1676,8 +1735,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
       if (tp == (struct type *) NULL)
 	{
 	  complaint (&symfile_complaints,
-		     "unable to cross ref btTypedef for %s", sym_name);
-	  tp = mdebug_type_int;
+		     _("unable to cross ref btTypedef for %s"), sym_name);
+	  tp = basic_type (btInt, current_objfile);
 	}
     }
 
@@ -1689,11 +1748,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 			  TYPE_ALLOC (tp, 2 * sizeof (struct field)));
       TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
 					    &current_objfile->objfile_obstack);
-      TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
+      TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
       ax++;
       TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
 					    &current_objfile->objfile_obstack);
-      TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
+      TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
       ax++;
     }
 
@@ -1726,7 +1785,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 
   /* Complain for illegal continuations due to corrupt aux entries.  */
   if (t->continued)
-    complaint (&symfile_complaints, "illegal TIR continued for %s", sym_name);
+    complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
 
   return tp;
 }
@@ -1789,8 +1848,8 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
       if (TYPE_CODE (indx) != TYPE_CODE_INT)
 	{
 	  complaint (&symfile_complaints,
-		     "illegal array index type for %s, assuming int", sym_name);
-	  indx = mdebug_type_int;
+		     _("illegal array index type for %s, assuming int"), sym_name);
+	  indx = builtin_type_int32;
 	}
 
       /* Get the bounds, and create the array type.  */
@@ -1820,12 +1879,9 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
          ignore the erroneous bitsize from the auxiliary entry safely.
          dbx seems to ignore it too.  */
 
-      /* TYPE_FLAG_TARGET_STUB now takes care of the zero TYPE_LENGTH
-         problem.  */
+      /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem.  */
       if (TYPE_LENGTH (*tpp) == 0)
-	{
-	  TYPE_FLAGS (t) |= TYPE_FLAG_TARGET_STUB;
-	}
+	TYPE_TARGET_STUB (t) = 1;
 
       *tpp = t;
       return 4 + off;
@@ -1839,7 +1895,7 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
       return 0;
 
     default:
-      complaint (&symfile_complaints, "unknown type qualifier 0x%x", tq);
+      complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
       return 0;
     }
 }
@@ -1847,13 +1903,13 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
 
 /* Parse a procedure descriptor record PR.  Note that the procedure is
    parsed _after_ the local symbols, now we just insert the extra
-   information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
+   information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has
    already been placed in the procedure's main block.  Note also that
    images that have been partially stripped (ld -x) have been deprived
    of local symbols, and we have to cope with them here.  FIRST_OFF is
    the offset of the first procedure for this FDR; we adjust the
    address by this amount, but I don't know why.  SEARCH_SYMTAB is the symtab
-   to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
+   to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol
    in question, or NULL to use top_stack->cur_block.  */
 
 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
@@ -1862,9 +1918,9 @@ static void
 parse_procedure (PDR *pr, struct symtab *search_symtab,
 		 struct partial_symtab *pst)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (pst->objfile);
   struct symbol *s, *i;
   struct block *b;
-  struct mips_extra_func_info *e;
   char *sh_name;
 
   /* Simple rule to find files linked "-x" */
@@ -1875,7 +1931,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
 	  /* Static procedure at address pr->adr.  Sigh. */
 	  /* FIXME-32x64.  assuming pr->adr fits in long.  */
 	  complaint (&symfile_complaints,
-		     "can't handle PDR for static proc at 0x%lx",
+		     _("can't handle PDR for static proc at 0x%lx"),
 		     (unsigned long) pr->adr);
 	  return;
 	}
@@ -1916,7 +1972,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
          the same name exists, lookup_symbol will eventually read in the symtab
          for the global function and clobber cur_fdr.  */
       FDR *save_cur_fdr = cur_fdr;
-      s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL);
+      s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
       cur_fdr = save_cur_fdr;
 #else
       s = mylookup_symbol
@@ -1936,7 +1992,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
     }
   else
     {
-      complaint (&symfile_complaints, "PDR for %s, but no symbol", sh_name);
+      complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
 #if 1
       return;
 #else
@@ -1945,8 +2001,9 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
       SYMBOL_DOMAIN (s) = VAR_DOMAIN;
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Donno its type, hope int is ok */
-      SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
-      add_symbol (s, top_stack->cur_block);
+      SYMBOL_TYPE (s)
+	= lookup_function_type (builtin_type (gdbarch)->builtin_int);
+      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       /* Wont have symbols for this one */
       b = new_block (2);
       SYMBOL_BLOCK_VALUE (s) = b;
@@ -1960,13 +2017,14 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
 #endif
     }
 
-  i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
+  i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
 
   if (i)
     {
-      e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
+      struct mdebug_extra_func_info *e;
+      
+      e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i);
       e->pdr = *pr;
-      e->pdr.isym = (long) s;
 
       /* GDB expects the absolute function start address for the
          procedure descriptor in e->pdr.adr.
@@ -1979,17 +2037,6 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
          To work around these problems, we replace e->pdr.adr with
          the start address of the function.  */
       e->pdr.adr = BLOCK_START (b);
-
-      /* Correct incorrect setjmp procedure descriptor from the library
-         to make backtrace through setjmp work.  */
-      if (e->pdr.pcreg == 0
-	  && strcmp (sh_name, "setjmp") == 0)
-	{
-	  complaint (&symfile_complaints, "fixing bad setjmp PDR from libc");
-	  e->pdr.pcreg = RA_REGNUM;
-	  e->pdr.regmask = 0x80000000;
-	  e->pdr.regoffset = -4;
-	}
     }
 
   /* It would be reasonable that functions that have been compiled
@@ -2010,19 +2057,7 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
   if (processing_gcc_compilation == 0
       && found_ecoff_debugging_info == 0
       && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
-    SYMBOL_TYPE (s) = nodebug_func_symbol_type;
-}
-
-/* Relocate the extra function info pointed to by the symbol table.  */
-
-void
-ecoff_relocate_efi (struct symbol *sym, CORE_ADDR delta)
-{
-  struct mips_extra_func_info *e;
-
-  e = (struct mips_extra_func_info *) SYMBOL_VALUE (sym);
-
-  e->pdr.adr += delta;
+    SYMBOL_TYPE (s) = builtin_type (gdbarch)->nodebug_text_symbol;
 }
 
 /* Parse the external symbol ES. Just call parse_symbol() after
@@ -2082,7 +2117,7 @@ parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
       n_undef_symbols++;
       /* FIXME:  Turn this into a complaint? */
       if (info_verbose)
-	printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
+	printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"),
 			 what, debug_info->ssext + es->asym.iss,
 			 fdr_name (cur_fdr));
       return;
@@ -2183,7 +2218,7 @@ parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
 	  if (lt->nitems >= maxlines)
 	    {
 	      complaint (&symfile_complaints,
-			 "guessed size of linetable for %s incorrectly",
+			 _("guessed size of linetable for %s incorrectly"),
 			 fdr_name (fh));
 	      break;
 	    }
@@ -2197,16 +2232,96 @@ static void
 function_outside_compilation_unit_complaint (const char *arg1)
 {
   complaint (&symfile_complaints,
-	     "function `%s' appears to be defined outside of all compilation units",
+	     _("function `%s' appears to be defined outside of all compilation units"),
 	     arg1);
 }
 
+/* Use the STORAGE_CLASS to compute which section the given symbol
+   belongs to, and then records this new minimal symbol.  */
+
+static void
+record_minimal_symbol (const char *name, const CORE_ADDR address,
+                       enum minimal_symbol_type ms_type, int storage_class,
+                       struct objfile *objfile)
+{
+  int section;
+  asection *bfd_section;
+
+  switch (storage_class)
+    {
+      case scText:
+        section = SECT_OFF_TEXT (objfile);
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".text");
+        break;
+      case scData:
+        section = SECT_OFF_DATA (objfile);
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".data");
+        break;
+      case scBss:
+        section = SECT_OFF_BSS (objfile);
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".bss");
+        break;
+      case scSData:
+        section = get_section_index (objfile, ".sdata");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata");
+        break;
+      case scSBss:
+        section = get_section_index (objfile, ".sbss");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss");
+        break;
+      case scRData:
+        section = get_section_index (objfile, ".rdata");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata");
+        break;
+      case scInit:
+        section = get_section_index (objfile, ".init");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".init");
+        break;
+      case scXData:
+        section = get_section_index (objfile, ".xdata");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata");
+        break;
+      case scPData:
+        section = get_section_index (objfile, ".pdata");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata");
+        break;
+      case scFini:
+        section = get_section_index (objfile, ".fini");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".fini");
+        break;
+      case scRConst:
+        section = get_section_index (objfile, ".rconst");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst");
+        break;
+#ifdef scTlsData
+      case scTlsData:
+        section = get_section_index (objfile, ".tlsdata");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata");
+        break;
+#endif
+#ifdef scTlsBss
+      case scTlsBss:
+        section = get_section_index (objfile, ".tlsbss");
+        bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss");
+        break;
+#endif
+      default:
+        /* This kind of symbol is not associated to a section.  */
+        section = -1;
+        bfd_section = NULL;
+    }
+
+  prim_record_minimal_symbol_and_info (name, address, ms_type,
+                                       section, bfd_section, objfile);
+}
+
 /* Master parsing procedure for first-pass reading of file symbols
    into a partial_symtab.  */
 
 static void
 parse_partial_symbols (struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
   const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
   const bfd_size_type external_ext_size = debug_swap->external_ext_size;
@@ -2378,14 +2493,14 @@ parse_partial_symbols (struct objfile *objfile)
       if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
 	{
 	  complaint (&symfile_complaints,
-		     "bad ifd for external symbol: %d (max %ld)", ext_in->ifd,
+		     _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd,
 		     hdr->ifdMax);
 	  continue;
 	}
       if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
 	{
 	  complaint (&symfile_complaints,
-		     "bad iss for external symbol: %ld (max %ld)",
+		     _("bad iss for external symbol: %ld (max %ld)"),
 		     ext_in->asym.iss, hdr->issExtMax);
 	  continue;
 	}
@@ -2515,7 +2630,8 @@ parse_partial_symbols (struct objfile *objfile)
 	  unknown_ext_complaint (name);
 	}
       if (!ECOFF_IN_ELF (cur_bfd))
-	prim_record_minimal_symbol (name, svalue, ms_type, objfile);
+        record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
+                               objfile);
     }
 
   /* Pass 3 over files, over local syms: fill in static symbols */
@@ -2632,13 +2748,9 @@ parse_partial_symbols (struct objfile *objfile)
 		      if (sh.st == stStaticProc)
 			{
 			  namestring = debug_info->ss + fh->issBase + sh.iss;
-			  prim_record_minimal_symbol_and_info (namestring,
-							       sh.value,
-							       mst_file_text,
-							       NULL,
-							       SECT_OFF_TEXT (objfile),
-							       NULL,
-							       objfile);
+                          record_minimal_symbol (namestring, sh.value,
+                                                 mst_file_text, sh.sc,
+                                                 objfile);
 			}
 		      procaddr = sh.value;
 
@@ -2680,13 +2792,9 @@ parse_partial_symbols (struct objfile *objfile)
 			case scXData:
 			  namestring = debug_info->ss + fh->issBase + sh.iss;
 			  sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
-			  prim_record_minimal_symbol_and_info (namestring,
-							       sh.value,
-							       mst_file_data,
-							       NULL,
-							       SECT_OFF_DATA (objfile),
-							       NULL,
-							       objfile);
+                          record_minimal_symbol (namestring, sh.value,
+                                                 mst_file_data, sh.sc,
+                                                 objfile);
 			  break;
 
 			default:
@@ -2694,13 +2802,9 @@ parse_partial_symbols (struct objfile *objfile)
 			     then have the default be abs? */
 			  namestring = debug_info->ss + fh->issBase + sh.iss;
 			  sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
-			  prim_record_minimal_symbol_and_info (namestring,
-							       sh.value,
-							       mst_file_bss,
-							       NULL,
-							       SECT_OFF_BSS (objfile),
-							       NULL,
-							       objfile);
+                          record_minimal_symbol (namestring, sh.value,
+                                                 mst_file_bss, sh.sc,
+                                                 objfile);
 			  break;
 			}
 		    }
@@ -2836,21 +2940,19 @@ parse_partial_symbols (struct objfile *objfile)
 
 		      prev_textlow_not_set = textlow_not_set;
 
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
 		      /* A zero value is probably an indication for the SunPRO 3.0
 			 compiler. end_psymtab explicitly tests for zero, so
 			 don't relocate it.  */
 
-		      if (sh.value == 0)
+		      if (sh.value == 0
+			  && gdbarch_sofun_address_maybe_missing (gdbarch))
 			{
 			  textlow_not_set = 1;
 			  valu = 0;
 			}
 		      else
 			textlow_not_set = 0;
-#else
-		      textlow_not_set = 0;
-#endif
+
 		      past_first_source_file = 1;
 
 		      if (prev_so_symnum != symnum - 1)
@@ -2991,9 +3093,11 @@ parse_partial_symbols (struct objfile *objfile)
 		      {
 		      case 'S':
 			sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
-#ifdef STATIC_TRANSFORM_NAME
-			namestring = STATIC_TRANSFORM_NAME (namestring);
-#endif
+
+			if (gdbarch_static_transform_name_p (gdbarch))
+			  namestring = gdbarch_static_transform_name
+					 (gdbarch, namestring);
+
 			add_psymbol_to_list (namestring, p - namestring,
 					     VAR_DOMAIN, LOC_STATIC,
 					     &objfile->static_psymbols,
@@ -3204,7 +3308,7 @@ parse_partial_symbols (struct objfile *objfile)
 			   a backslash.  */
 
 			complaint (&symfile_complaints,
-				   "unknown symbol descriptor `%c'", p[1]);
+				   _("unknown symbol descriptor `%c'"), p[1]);
 
 			/* Ignore it; perhaps it is an extension that we don't
 			   know about.  */
@@ -3215,19 +3319,18 @@ parse_partial_symbols (struct objfile *objfile)
 		    continue;
 
 		  case N_ENDM:
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
 		    /* Solaris 2 end of module, finish current partial
 		       symbol table.  END_PSYMTAB will set
 		       pst->texthigh to the proper value, which is
 		       necessary if a module compiled without
 		       debugging info follows this module.  */
-		    if (pst)
+		    if (pst
+			&& gdbarch_sofun_address_maybe_missing (gdbarch))
 		      {
 			pst = (struct partial_symtab *) 0;
 			includes_used = 0;
 			dependencies_used = 0;
 		      }
-#endif
 		    continue;
 
 		  case N_RBRAC:
@@ -3265,8 +3368,8 @@ parse_partial_symbols (struct objfile *objfile)
 		  default:
 		    /* If we haven't found it yet, ignore it.  It's probably some
 		       new type we don't know about yet.  */
-		    complaint (&symfile_complaints, "unknown symbol type %s",
-			       local_hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
+		    complaint (&symfile_complaints, _("unknown symbol type %s"),
+			       hex_string (type_code)); /*CUR_SYMBOL_TYPE*/
 		    continue;
 		  }
 		if (stabstring
@@ -3337,7 +3440,7 @@ parse_partial_symbols (struct objfile *objfile)
 
 		case stStaticProc:
 		  prim_record_minimal_symbol_and_info (name, sh.value,
-						       mst_file_text, NULL,
+						       mst_file_text,
 						       SECT_OFF_TEXT (objfile), NULL,
 						       objfile);
 
@@ -3362,7 +3465,7 @@ parse_partial_symbols (struct objfile *objfile)
 		    {
 		      /* This should not happen either... FIXME.  */
 		      complaint (&symfile_complaints,
-				 "bad proc end in aux found from symbol %s",
+				 _("bad proc end in aux found from symbol %s"),
 				 name);
 		      new_sdx = cur_sdx + 1;	/* Don't skip backward */
 		    }
@@ -3423,13 +3526,13 @@ parse_partial_symbols (struct objfile *objfile)
 		case stStatic:	/* Variable */
 		  if (SC_IS_DATA (sh.sc))
 		    prim_record_minimal_symbol_and_info (name, sh.value,
-							 mst_file_data, NULL,
+							 mst_file_data,
 							 SECT_OFF_DATA (objfile),
 							 NULL,
 							 objfile);
 		  else
 		    prim_record_minimal_symbol_and_info (name, sh.value,
-							 mst_file_bss, NULL,
+							 mst_file_bss,
 							 SECT_OFF_BSS (objfile),
 							 NULL,
 							 objfile);
@@ -3477,7 +3580,7 @@ parse_partial_symbols (struct objfile *objfile)
 		    {
 		      /* This happens with the Ultrix kernel. */
 		      complaint (&symfile_complaints,
-				 "bad aux index at block symbol %s", name);
+				 _("bad aux index at block symbol %s"), name);
 		      new_sdx = cur_sdx + 1;	/* Don't skip backward */
 		    }
 		  cur_sdx = new_sdx;
@@ -3497,9 +3600,9 @@ parse_partial_symbols (struct objfile *objfile)
 		default:
 		  /* Both complaints are valid:  one gives symbol name,
 		     the other the offending symbol type.  */
-		  complaint (&symfile_complaints, "unknown local symbol %s",
+		  complaint (&symfile_complaints, _("unknown local symbol %s"),
 			     name);
-		  complaint (&symfile_complaints, "with type %d", sh.st);
+		  complaint (&symfile_complaints, _("with type %d"), sh.st);
 		  cur_sdx++;
 		  continue;
 		}
@@ -3525,7 +3628,7 @@ parse_partial_symbols (struct objfile *objfile)
 	      CORE_ADDR svalue;
 
 	      if (ext_ptr->ifd != f_idx)
-		internal_error (__FILE__, __LINE__, "failed internal consistency check");
+		internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 	      psh = &ext_ptr->asym;
 
 	      /* Do not add undefined symbols to the partial symbol table.  */
@@ -3658,7 +3761,7 @@ parse_partial_symbols (struct objfile *objfile)
 			  &rh);
 	  if (rh < 0 || rh >= hdr->ifdMax)
 	    {
-	      complaint (&symfile_complaints, "bad file number %ld", rh);
+	      complaint (&symfile_complaints, _("bad file number %ld"), rh);
 	      continue;
 	    }
 
@@ -3930,17 +4033,17 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
 		{
 		  /* Make up special symbol to contain
 		     procedure specific info */
-		  struct mips_extra_func_info *e =
-		  ((struct mips_extra_func_info *)
+		  struct mdebug_extra_func_info *e =
+		  ((struct mdebug_extra_func_info *)
 		   obstack_alloc (&current_objfile->objfile_obstack,
-				  sizeof (struct mips_extra_func_info)));
-		  struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
+				  sizeof (struct mdebug_extra_func_info)));
+		  struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
 
-		  memset (e, 0, sizeof (struct mips_extra_func_info));
+		  memset (e, 0, sizeof (struct mdebug_extra_func_info));
 		  SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
 		  SYMBOL_CLASS (s) = LOC_CONST;
-		  SYMBOL_TYPE (s) = mdebug_type_void;
-		  SYMBOL_VALUE (s) = (long) e;
+		  SYMBOL_TYPE (s) = builtin_type_void;
+		  SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
 		  e->pdr.framereg = -1;
 		  add_symbol_to_list (s, &local_symbols);
 		}
@@ -3965,7 +4068,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
 	    /* These are generated by gcc-2.x, do not complain */
 	    ;
 	  else
-	    complaint (&symfile_complaints, "unknown stabs symbol %s", name);
+	    complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
 	}
 
       if (! last_symtab_ended)
@@ -4148,7 +4251,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
          from a shared library, so tell the user only if verbose is on.  */
       if (info_verbose && n_undef_symbols)
 	{
-	  printf_filtered ("File %s contains %d unresolved references:",
+	  printf_filtered (_("File %s contains %d unresolved references:"),
 			   st->filename, n_undef_symbols);
 	  printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n",
 			   n_undef_vars, n_undef_procs, n_undef_labels);
@@ -4321,7 +4424,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
 				      &tir);
 	  if (tir.tq0 != tqNil)
 	    complaint (&symfile_complaints,
-		       "illegal tq0 in forward typedef for %s", sym_name);
+		       _("illegal tq0 in forward typedef for %s"), sym_name);
 	  switch (tir.bt)
 	    {
 	    case btVoid:
@@ -4359,7 +4462,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
 
 	    default:
 	      complaint (&symfile_complaints,
-			 "illegal bt %d in forward typedef for %s", tir.bt,
+			 _("illegal bt %d in forward typedef for %s"), tir.bt,
 			 sym_name);
 	      *tpp = init_type (type_code, 0, 0, (char *) NULL,
 				current_objfile);
@@ -4414,10 +4517,10 @@ mylookup_symbol (char *name, struct block *block,
   inc = name[0];
   ALL_BLOCK_SYMBOLS (block, iter, sym)
     {
-      if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc
+      if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
 	  && SYMBOL_DOMAIN (sym) == domain
 	  && SYMBOL_CLASS (sym) == class
-	  && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0)
+	  && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
 	return sym;
     }
 
@@ -4431,8 +4534,9 @@ mylookup_symbol (char *name, struct block *block,
 /* Add a new symbol S to a block B.  */
 
 static void
-add_symbol (struct symbol *s, struct block *b)
+add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
 {
+  SYMBOL_SYMTAB (s) = symtab;
   dict_add_symbol (BLOCK_DICT (b), s);
 }
 
@@ -4728,7 +4832,7 @@ elfmdebug_build_psymtabs (struct objfile *objfile,
 			 sizeof (struct ecoff_debug_info)));
 
   if (!(*swap->read_debug_info) (abfd, sec, info))
-    error ("Error reading ECOFF debugging information: %s",
+    error (_("Error reading ECOFF debugging information: %s"),
 	   bfd_errmsg (bfd_get_error ()));
 
   mdebug_build_psymtabs (objfile, swap, info);
@@ -4740,122 +4844,5 @@ elfmdebug_build_psymtabs (struct objfile *objfile,
 void
 _initialize_mdebugread (void)
 {
-  mdebug_type_void =
-    init_type (TYPE_CODE_VOID, 1,
-	       0,
-	       "void", (struct objfile *) NULL);
-  mdebug_type_char =
-    init_type (TYPE_CODE_INT, 1,
-	       0,
-	       "char", (struct objfile *) NULL);
-  mdebug_type_unsigned_char =
-    init_type (TYPE_CODE_INT, 1,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned char", (struct objfile *) NULL);
-  mdebug_type_short =
-    init_type (TYPE_CODE_INT, 2,
-	       0,
-	       "short", (struct objfile *) NULL);
-  mdebug_type_unsigned_short =
-    init_type (TYPE_CODE_INT, 2,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned short", (struct objfile *) NULL);
-  mdebug_type_int_32 =
-    init_type (TYPE_CODE_INT, 4,
-	       0,
-	       "int", (struct objfile *) NULL);
-  mdebug_type_unsigned_int_32 =
-    init_type (TYPE_CODE_INT, 4,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned int", (struct objfile *) NULL);
-  mdebug_type_int_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       0,
-	       "int", (struct objfile *) NULL);
-  mdebug_type_unsigned_int_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned int", (struct objfile *) NULL);
-  mdebug_type_long_32 =
-    init_type (TYPE_CODE_INT, 4,
-	       0,
-	       "long", (struct objfile *) NULL);
-  mdebug_type_unsigned_long_32 =
-    init_type (TYPE_CODE_INT, 4,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned long", (struct objfile *) NULL);
-  mdebug_type_long_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       0,
-	       "long", (struct objfile *) NULL);
-  mdebug_type_unsigned_long_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned long", (struct objfile *) NULL);
-  mdebug_type_long_long_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       0,
-	       "long long", (struct objfile *) NULL);
-  mdebug_type_unsigned_long_long_64 =
-    init_type (TYPE_CODE_INT, 8,
-	       TYPE_FLAG_UNSIGNED,
-	       "unsigned long long", (struct objfile *) NULL);
-  mdebug_type_adr_32 =
-    init_type (TYPE_CODE_PTR, 4,
-	       TYPE_FLAG_UNSIGNED,
-	       "adr_32", (struct objfile *) NULL);
-  TYPE_TARGET_TYPE (mdebug_type_adr_32) = mdebug_type_void;
-  mdebug_type_adr_64 =
-    init_type (TYPE_CODE_PTR, 8,
-	       TYPE_FLAG_UNSIGNED,
-	       "adr_64", (struct objfile *) NULL);
-  TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
-  mdebug_type_float =
-    init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-	       0,
-	       "float", (struct objfile *) NULL);
-  mdebug_type_double =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-	       0,
-	       "double", (struct objfile *) NULL);
-  mdebug_type_complex =
-    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-	       0,
-	       "complex", (struct objfile *) NULL);
-  TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
-  mdebug_type_double_complex =
-    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-	       0,
-	       "double complex", (struct objfile *) NULL);
-  TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
-
-  /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
-     FIXME.  */
-  mdebug_type_string =
-    init_type (TYPE_CODE_STRING,
-	       TARGET_CHAR_BIT / TARGET_CHAR_BIT,
-	       0, "string",
-	       (struct objfile *) NULL);
-
-  /* We use TYPE_CODE_INT to print these as integers.  Does this do any
-     good?  Would we be better off with TYPE_CODE_ERROR?  Should
-     TYPE_CODE_ERROR print things in hex if it knows the size?  */
-  mdebug_type_fixed_dec =
-    init_type (TYPE_CODE_INT,
-	       TARGET_INT_BIT / TARGET_CHAR_BIT,
-	       0, "fixed decimal",
-	       (struct objfile *) NULL);
-
-  mdebug_type_float_dec =
-    init_type (TYPE_CODE_ERROR,
-	       TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-	       0, "floating decimal",
-	       (struct objfile *) NULL);
-
-  nodebug_func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
-					"<function, no debug info>", NULL);
-  TYPE_TARGET_TYPE (nodebug_func_symbol_type) = mdebug_type_int;
-  nodebug_var_symbol_type =
-    init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
-	       "<variable, no debug info>", NULL);
+  basic_type_data = register_objfile_data ();
 }