bfd:
[deliverable/binutils-gdb.git] / gdb / mdebugread.c
index 8ce2d0f23bd74621d6b5ea30a0be36c53a81cf11..4f9841982b78e391a109dbf06bf3cc34a11699e1 100644 (file)
@@ -1,7 +1,9 @@
 /* Read a symbol table in ECOFF format (Third-Eye).
 /* 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
+
+   Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
    Free Software Foundation, Inc.
    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
    at Cygnus Support.
    Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
    CMU.  Major work by Per Bothner, John Gilmore and Ian Lance Taylor
    at Cygnus Support.
@@ -10,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
 
    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,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -19,9 +21,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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
 
 /* This module provides the function mdebug_build_psymtabs.  It reads
    ECOFF debugging information into partial symbol tables.  The
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "gdbcore.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "gdbcore.h"
-#include "symfile.h"
 #include "objfiles.h"
 #include "objfiles.h"
-#include "obstack.h"
+#include "gdb_obstack.h"
 #include "buildsym.h"
 #include "stabsread.h"
 #include "complaints.h"
 #include "demangle.h"
 #include "buildsym.h"
 #include "stabsread.h"
 #include "complaints.h"
 #include "demangle.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
-
-#ifdef USG
-#include <sys/types.h>
-#endif
-
+#include "gdb_assert.h"
+#include "block.h"
+#include "dictionary.h"
+#include "mdebugread.h"
 #include "gdb_stat.h"
 #include "gdb_string.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 "aout/stab_gnu.h"     /* STABS information */
 
 #include "expression.h"
-#include "language.h"          /* For local_hex_string() */
 
 extern void _initialize_mdebugread (void);
 
 
 extern void _initialize_mdebugread (void);
 
@@ -105,11 +83,6 @@ extern void _initialize_mdebugread (void);
 
 struct symloc
   {
 
 struct symloc
   {
-    /* Our running best guess as to the range of text addresses for
-       this psymtab.  After we've read everything in, we use this to
-       build pst->text_addrs.  */
-    CORE_ADDR textlow, texthigh;
-
     /* Index of the FDR that this psymtab represents.  */
     int fdr_idx;
     /* The BFD that the psymtab was created from.  */
     /* Index of the FDR that this psymtab represents.  */
     int fdr_idx;
     /* The BFD that the psymtab was created from.  */
@@ -125,8 +98,6 @@ struct symloc
   };
 
 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
   };
 
 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
-#define TEXTLOW(p) (PST_PRIVATE(p)->textlow)
-#define TEXTHIGH(p) (PST_PRIVATE(p)->texthigh)
 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap)
@@ -143,105 +114,48 @@ struct symloc
                   || (sc) == scPData \
                   || (sc) == scXData)
 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
                   || (sc) == scPData \
                   || (sc) == scXData)
 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon)
-#define SC_IS_BSS(sc) ((sc) == scBss || (sc) == scSBss)
+#define SC_IS_BSS(sc) ((sc) == scBss)
+#define SC_IS_SBSS(sc) ((sc) == scSBss)
 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
 \f
 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined)
 \f
-
-/* Things we import explicitly from other modules */
-
-extern int info_verbose;
-
 /* Various complaints about symbol reading that don't abort the process */
 /* Various complaints about symbol reading that don't abort the process */
+static void
+index_complaint (const char *arg1)
+{
+  complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
+}
 
 
-static struct complaint bad_file_number_complaint =
-{"bad file number %d", 0, 0};
-
-static struct complaint index_complaint =
-{"bad aux index at symbol %s", 0, 0};
-
-static struct complaint aux_index_complaint =
-{"bad proc end in aux found from symbol %s", 0, 0};
-
-static struct complaint block_index_complaint =
-{"bad aux index at block symbol %s", 0, 0};
-
-static struct complaint unknown_ext_complaint =
-{"unknown external symbol %s", 0, 0};
-
-static struct complaint unknown_sym_complaint =
-{"unknown local symbol %s", 0, 0};
-
-static struct complaint unknown_st_complaint =
-{"with type %d", 0, 0};
-
-static struct complaint block_overflow_complaint =
-{"block containing %s overfilled", 0, 0};
-
-static struct complaint basic_type_complaint =
-{"cannot map ECOFF basic type 0x%x for %s", 0, 0};
-
-static struct complaint unknown_type_qual_complaint =
-{"unknown type qualifier 0x%x", 0, 0};
-
-static struct complaint array_index_type_complaint =
-{"illegal array index type for %s, assuming int", 0, 0};
-
-static struct complaint bad_tag_guess_complaint =
-{"guessed tag type of %s incorrectly", 0, 0};
-
-static struct complaint block_member_complaint =
-{"declaration block contains unhandled symbol type %d", 0, 0};
-
-static struct complaint stEnd_complaint =
-{"stEnd with storage class %d not handled", 0, 0};
-
-static struct complaint unknown_mdebug_symtype_complaint =
-{"unknown symbol type 0x%x", 0, 0};
-
-static struct complaint stab_unknown_complaint =
-{"unknown stabs symbol %s", 0, 0};
-
-static struct complaint pdr_for_nonsymbol_complaint =
-{"PDR for %s, but no symbol", 0, 0};
-
-static struct complaint pdr_static_symbol_complaint =
-{"can't handle PDR for static proc at 0x%lx", 0, 0};
-
-static struct complaint bad_setjmp_pdr_complaint =
-{"fixing bad setjmp PDR from libc", 0, 0};
-
-static struct complaint bad_fbitfield_complaint =
-{"can't handle TIR fBitfield for %s", 0, 0};
-
-static struct complaint bad_continued_complaint =
-{"illegal TIR continued for %s", 0, 0};
-
-static struct complaint bad_rfd_entry_complaint =
-{"bad rfd entry for %s: file %d, index %d", 0, 0};
-
-static struct complaint unexpected_type_code_complaint =
-{"unexpected type code for %s", 0, 0};
-
-static struct complaint unable_to_cross_ref_complaint =
-{"unable to cross ref btTypedef for %s", 0, 0};
-
-static struct complaint bad_indirect_xref_complaint =
-{"unable to cross ref btIndirect for %s", 0, 0};
-
-static struct complaint illegal_forward_tq0_complaint =
-{"illegal tq0 in forward typedef for %s", 0, 0};
+static void
+unknown_ext_complaint (const char *arg1)
+{
+  complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
+}
 
 
-static struct complaint illegal_forward_bt_complaint =
-{"illegal bt %d in forward typedef for %s", 0, 0};
+static void
+basic_type_complaint (int arg1, const char *arg2)
+{
+  complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
+            arg1, arg2);
+}
 
 
-static struct complaint bad_linetable_guess_complaint =
-{"guessed size of linetable for %s incorrectly", 0, 0};
+static void
+bad_tag_guess_complaint (const char *arg1)
+{
+  complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1);
+}
 
 
-static struct complaint bad_ext_ifd_complaint =
-{"bad ifd for external symbol: %d (max %d)", 0, 0};
+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"),
+            arg1, arg2, arg3);
+}
 
 
-static struct complaint bad_ext_iss_complaint =
-{"bad iss for external symbol: %ld (max %ld)", 0, 0};
+static void
+unexpected_type_code_complaint (const char *arg1)
+{
+  complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
+}
 
 /* Macros and extra defs */
 
 
 /* Macros and extra defs */
 
@@ -321,104 +235,61 @@ static struct type *mdebug_type_fixed_dec;
 static struct type *mdebug_type_float_dec;
 static struct type *mdebug_type_string;
 
 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;
 
 /* Forward declarations */
 
 /* Nonzero if we have seen ecoff debugging info for a file.  */
 
 static int found_ecoff_debugging_info;
 
 /* Forward declarations */
 
-static void add_pending (FDR *, char *, struct type *);
-
-static struct mdebug_pending *is_pending_symbol (FDR *, char *);
-
-static void pop_parse_stack (void);
-
-static void push_parse_stack (void);
-
-static char *fdr_name (FDR *);
-
-static void mdebug_psymtab_to_symtab (struct partial_symtab *);
-
-static int
-upgrade_type (int, struct type **, int, union aux_ext *, int, char *);
+static int upgrade_type (int, struct type **, int, union aux_ext *,
+                        int, char *);
 
 static void parse_partial_symbols (struct objfile *);
 
 
 static void parse_partial_symbols (struct objfile *);
 
-static FDR * get_rfd (int, int);
-
 static int has_opaque_xref (FDR *, SYMR *);
 
 static int has_opaque_xref (FDR *, SYMR *);
 
-static int
-cross_ref (int, union aux_ext *, struct type **, enum type_code,
-          char **, int, char *);
+static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
+                     char **, int, char *);
 
 static struct symbol *new_symbol (char *);
 
 static struct type *new_type (char *);
 
 
 static struct symbol *new_symbol (char *);
 
 static struct type *new_type (char *);
 
-static struct block *new_block (int);
+enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
+
+static struct block *new_block (enum block_type);
 
 
-static struct symtab *new_symtab (char *, int, int, struct objfile *);
+static struct symtab *new_symtab (char *, int, struct objfile *);
 
 static struct linetable *new_linetable (int);
 
 static struct blockvector *new_bvect (int);
 
 
 static struct linetable *new_linetable (int);
 
 static struct blockvector *new_bvect (int);
 
-static int
-parse_symbol (SYMR *, union aux_ext *, char *, int, struct section_offsets *,
-             struct objfile *);
-
 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
                                int, char *);
 
 static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
                                int, char *);
 
-static struct symbol *mylookup_symbol (char *, struct block *, namespace_enum,
+static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
                                       enum address_class);
 
                                       enum address_class);
 
-static struct block *shrink_block (struct block *, struct symtab *);
-
-static PTR xzalloc (unsigned int);
-
 static void sort_blocks (struct symtab *);
 
 static void sort_blocks (struct symtab *);
 
-static int compare_blocks (const PTR, const PTR);
-
 static struct partial_symtab *new_psymtab (char *, struct objfile *);
 
 static void psymtab_to_symtab_1 (struct partial_symtab *, char *);
 
 static void add_block (struct block *, struct symtab *);
 
 static struct partial_symtab *new_psymtab (char *, struct objfile *);
 
 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);
 
 static struct linetable *shrink_linetable (struct linetable *);
 
 
 static int add_line (struct linetable *, int, CORE_ADDR, int);
 
 static struct linetable *shrink_linetable (struct linetable *);
 
-static void
-handle_psymbol_enumerators (struct objfile *, FDR *, int, CORE_ADDR);
+static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
+                                       CORE_ADDR);
 
 static char *mdebug_next_symbol_text (struct objfile *);
 \f
 
 static char *mdebug_next_symbol_text (struct objfile *);
 \f
-/* Address bounds for the signal trampoline in inferior, if any */
-
-CORE_ADDR sigtramp_address, sigtramp_end;
-
-/* Allocate zeroed memory */
-
-static PTR
-xzalloc (unsigned int size)
-{
-  PTR 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
 /* 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
@@ -433,7 +304,7 @@ mdebug_psymtab_to_symtab (struct partial_symtab *pst)
 
   if (info_verbose)
     {
 
   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);
     }
 
       gdb_flush (gdb_stdout);
     }
 
@@ -446,7 +317,7 @@ mdebug_psymtab_to_symtab (struct partial_symtab *pst)
   scan_file_globals (pst->objfile);
 
   if (info_verbose)
   scan_file_globals (pst->objfile);
 
   if (info_verbose)
-    printf_filtered ("done.\n");
+    printf_filtered (_("done.\n"));
 }
 \f
 /* File-level interface functions */
 }
 \f
 /* File-level interface functions */
@@ -457,7 +328,7 @@ static FDR *
 get_rfd (int cf, int rf)
 {
   FDR *fdrs;
 get_rfd (int cf, int rf)
 {
   FDR *fdrs;
-  register FDR *f;
+  FDR *f;
   RFDT rfd;
 
   fdrs = debug_info->fdr;
   RFDT rfd;
 
   fdrs = debug_info->fdr;
@@ -510,7 +381,7 @@ mdebug_build_psymtabs (struct objfile *objfile,
       char *fdr_end;
       FDR *fdr_ptr;
 
       char *fdr_end;
       FDR *fdr_ptr;
 
-      info->fdr = (FDR *) obstack_alloc (&objfile->psymbol_obstack,
+      info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
                                         (info->symbolic_header.ifdMax
                                          * sizeof (FDR)));
       fdr_src = info->external_fdr;
                                         (info->symbolic_header.ifdMax
                                          * sizeof (FDR)));
       fdr_src = info->external_fdr;
@@ -523,28 +394,15 @@ mdebug_build_psymtabs (struct objfile *objfile,
 
   parse_partial_symbols (objfile);
 
 
   parse_partial_symbols (objfile);
 
-  /* Take the text ranges the partial symbol scanner computed for each
-     of the psymtabs and convert it into the canonical form for
-     psymtabs.  */
-  {
-    struct partial_symtab *p;
-
-    ALL_OBJFILE_PSYMTABS (objfile, p)
-      {
-        p->textlow = TEXTLOW (p);
-        p->texthigh = TEXTHIGH (p);
-      }
-  }
-
 #if 0
   /* Check to make sure file was compiled with -g.  If not, warn the
      user of this limitation.  */
   if (compare_glevel (max_glevel, GLEVEL_2) < 0)
     {
       if (max_gdbinfo == 0)
 #if 0
   /* Check to make sure file was compiled with -g.  If not, warn the
      user of this limitation.  */
   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);
                           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
       gdb_flush (gdb_stdout);
     }
 #endif
@@ -581,7 +439,6 @@ static struct parse_stack
 
     int blocktype;
 
 
     int blocktype;
 
-    int maxsyms;               /* Max symbols in this block. */
     struct type *cur_type;     /* Type we parse fields for. */
     int cur_field;             /* Field number in cur_type. */
     CORE_ADDR procadr;         /* Start addres of this procedure */
     struct type *cur_type;     /* Type we parse fields for. */
     int cur_field;             /* Field number in cur_type. */
     CORE_ADDR procadr;         /* Start addres of this procedure */
@@ -606,7 +463,7 @@ push_parse_stack (void)
   /* Initialize new frame with previous content */
   if (top_stack)
     {
   /* Initialize new frame with previous content */
   if (top_stack)
     {
-      register struct parse_stack *prev = new->prev;
+      struct parse_stack *prev = new->prev;
 
       *new = *top_stack;
       top_stack->prev = new;
 
       *new = *top_stack;
       top_stack->prev = new;
@@ -642,9 +499,9 @@ struct mdebug_pending
 
 
 /* The pending information is kept for an entire object file, and used
 
 
 /* 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.  */
 
    pending information table when we create the partial symbols, and
    we store a pointer to the single table in each psymtab.  */
 
@@ -656,7 +513,7 @@ static struct mdebug_pending *
 is_pending_symbol (FDR *fh, char *sh)
 {
   int f_idx = fh - debug_info->fdr;
 is_pending_symbol (FDR *fh, char *sh)
 {
   int f_idx = fh - debug_info->fdr;
-  register struct mdebug_pending *p;
+  struct mdebug_pending *p;
 
   /* Linear search is ok, list is typically no more than 10 deep */
   for (p = pending_list[f_idx]; p; p = p->next)
 
   /* Linear search is ok, list is typically no more than 10 deep */
   for (p = pending_list[f_idx]; p; p = p->next)
@@ -677,7 +534,7 @@ add_pending (FDR *fh, char *sh, struct type *t)
   if (!p)
     {
       p = ((struct mdebug_pending *)
   if (!p)
     {
       p = ((struct mdebug_pending *)
-          obstack_alloc (&current_objfile->psymbol_obstack,
+          obstack_alloc (&current_objfile->objfile_obstack,
                          sizeof (struct mdebug_pending)));
       p->s = sh;
       p->t = t;
                          sizeof (struct mdebug_pending)));
       p->s = sh;
       p->t = t;
@@ -702,8 +559,9 @@ static int
 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
              struct section_offsets *section_offsets, struct objfile *objfile)
 {
 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;
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
-  void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
+  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
   char *name;
   struct symbol *s;
   struct block *b;
   char *name;
   struct symbol *s;
   struct block *b;
@@ -768,7 +626,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.  */
          /* 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 (SYMBOL_NAME (s));
+         int bucket = hashname (DEPRECATED_SYMBOL_NAME (s));
          SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
          global_sym_chain[bucket] = s;
        }
          SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
          global_sym_chain[bucket] = s;
        }
@@ -780,7 +638,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       if (sh->sc == scRegister)
        {
          class = LOC_REGISTER;
       if (sh->sc == scRegister)
        {
          class = LOC_REGISTER;
-         svalue = ECOFF_REG_TO_REGNUM (svalue);
+         svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
        }
       else
        class = LOC_LOCAL;
        }
       else
        class = LOC_LOCAL;
@@ -789,14 +647,14 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       SYMBOL_VALUE (s) = svalue;
 
     data:                      /* Common code for symbols describing data */
       SYMBOL_VALUE (s) = svalue;
 
     data:                      /* Common code for symbols describing data */
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
       SYMBOL_CLASS (s) = class;
       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)
 
       /* 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 */
       else
        SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name);
       /* Value of a data symbol is its memory address */
@@ -812,13 +670,14 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
        name = "this";          /* FIXME, not alloc'd in obstack */
       s = new_symbol (name);
 
        name = "this";          /* FIXME, not alloc'd in obstack */
       s = new_symbol (name);
 
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
+      SYMBOL_IS_ARGUMENT (s) = 1;
       switch (sh->sc)
        {
        case scRegister:
          /* Pass by value in register.  */
       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;
+         svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
          break;
        case scVar:
          /* Pass by reference on stack.  */
          break;
        case scVar:
          /* Pass by reference on stack.  */
@@ -827,7 +686,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;
        case scVarRegister:
          /* Pass by reference in register.  */
          SYMBOL_CLASS (s) = LOC_REGPARM_ADDR;
-         svalue = ECOFF_REG_TO_REGNUM (svalue);
+         svalue = gdbarch_ecoff_reg_to_regnum (current_gdbarch, svalue);
          break;
        default:
          /* Pass by value on stack.  */
          break;
        default:
          /* Pass by value on stack.  */
@@ -836,22 +695,54 @@ 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);
        }
       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 */
       s = new_symbol (name);
       break;
 
     case stLabel:              /* label, goes into current block */
       s = new_symbol (name);
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;    /* so that it can be used */
+      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;
       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);
+      add_symbol (s, top_stack->cur_st, top_stack->cur_block);
       break;
 
     case stProc:               /* Procedure, usually goes into global block */
     case stStaticProc:         /* Static procedure, goes into current block */
       break;
 
     case stProc:               /* Procedure, usually goes into global block */
     case stStaticProc:         /* Static procedure, goes into current block */
+      /* For stProc symbol records, we need to check the storage class
+         as well, as only (stProc, scText) entries represent "real"
+         procedures - See the Compaq document titled "Object File /
+         Symbol Table Format Specification" for more information.
+         If the storage class is not scText, we discard the whole block
+         of symbol records for this stProc.  */
+      if (sh->st == stProc && sh->sc != scText)
+        {
+          char *ext_tsym = ext_sh;
+          int keep_counting = 1;
+          SYMR tsym;
+
+          while (keep_counting)
+            {
+              ext_tsym += external_sym_size;
+              (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
+              count++;
+              switch (tsym.st)
+                {
+                  case stParam:
+                    break;
+                  case stEnd:
+                    keep_counting = 0;
+                    break;
+                  default:
+                    complaint (&symfile_complaints,
+                               _("unknown symbol type 0x%x"), sh->st);
+                    break;
+                }
+            }
+          break;
+        }
       s = new_symbol (name);
       s = new_symbol (name);
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Type of the return value */
       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
       SYMBOL_CLASS (s) = LOC_BLOCK;
       /* Type of the return value */
       if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
@@ -859,7 +750,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       else
        {
          t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
       else
        {
          t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
-         if (STREQ (name, "malloc") && t->code == TYPE_CODE_VOID)
+         if (strcmp (name, "malloc") == 0
+             && TYPE_CODE (t) == TYPE_CODE_VOID)
            {
              /* I don't know why, but, at least under Alpha GNU/Linux,
                 when linking against a malloc without debugging
            {
              /* I don't know why, but, at least under Alpha GNU/Linux,
                 when linking against a malloc without debugging
@@ -880,7 +772,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
          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
          if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
            b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
          /* Irix 5 sometimes has duplicate names for the same
@@ -889,13 +781,18 @@ 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);
        }
          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);
 
 
       /* Make a type for the procedure itself */
       SYMBOL_TYPE (s) = lookup_function_type (t);
 
+      /* 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;
+
       /* Create and enter a new lexical context */
       /* Create and enter a new lexical context */
-      b = new_block (top_stack->maxsyms);
+      b = new_block (FUNCTION_BLOCK);
       SYMBOL_BLOCK_VALUE (s) = b;
       BLOCK_FUNCTION (b) = s;
       BLOCK_START (b) = BLOCK_END (b) = sh->value;
       SYMBOL_BLOCK_VALUE (s) = b;
       BLOCK_FUNCTION (b) = s;
       BLOCK_START (b) = BLOCK_END (b) = sh->value;
@@ -964,7 +861,28 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
            switch (tsym.st)
              {
              case stEnd:
            switch (tsym.st)
              {
              case stEnd:
-               goto end_of_fields;
+                /* C++ encodes class types as structures where there the
+                   methods are encoded as stProc. The scope of stProc
+                   symbols also ends with stEnd, thus creating a risk of
+                   taking the wrong stEnd symbol record as the end of
+                   the current struct, which would cause GDB to undercount
+                   the real number of fields in this struct.  To make sure
+                   we really reached the right stEnd symbol record, we
+                   check the associated name, and match it against the
+                   struct name.  Since method names are mangled while
+                   the class name is not, there is no risk of having a
+                   method whose name is identical to the class name
+                   (in particular constructor method names are different
+                   from the class name).  There is therefore no risk that
+                   this check stops the count on the StEnd of a method.
+                  
+                  Also, assume that we're really at the end when tsym.iss
+                  is 0 (issNull).  */
+                if (tsym.iss == issNull
+                   || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
+                               name) == 0)
+                  goto end_of_fields;
+                break;
 
              case stMember:
                if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
 
              case stMember:
                if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
@@ -1033,7 +951,9 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                break;
 
              default:
                break;
 
              default:
-               complain (&block_member_complaint, tsym.st);
+               complaint (&symfile_complaints,
+                          _("declaration block contains unhandled symbol type %d"),
+                          tsym.st);
              }
          }
       end_of_fields:;
              }
          }
       end_of_fields:;
@@ -1095,7 +1015,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
        if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
          TYPE_TAG_NAME (t) = NULL;
        else
        if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
          TYPE_TAG_NAME (t) = NULL;
        else
-         TYPE_TAG_NAME (t) = obconcat (&current_objfile->symbol_obstack,
+         TYPE_TAG_NAME (t) = obconcat (&current_objfile->objfile_obstack,
                                        "", "", name);
 
        TYPE_CODE (t) = type_code;
                                        "", "", name);
 
        TYPE_CODE (t) = type_code;
@@ -1121,7 +1041,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)
               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)
            for (ext_tsym = ext_sh + external_sym_size;
                 ;
                 ext_tsym += external_sym_size)
@@ -1138,21 +1058,22 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                FIELD_TYPE (*f) = t;
                FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
                FIELD_BITSIZE (*f) = 0;
                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 *)
 
                enum_sym = ((struct symbol *)
-                           obstack_alloc (&current_objfile->symbol_obstack,
+                           obstack_alloc (&current_objfile->objfile_obstack,
                                           sizeof (struct symbol)));
                                           sizeof (struct symbol)));
-               memset ((PTR) enum_sym, 0, sizeof (struct symbol));
-               SYMBOL_NAME (enum_sym) =
+               memset (enum_sym, 0, sizeof (struct symbol));
+               DEPRECATED_SYMBOL_NAME (enum_sym) =
                  obsavestring (f->name, strlen (f->name),
                  obsavestring (f->name, strlen (f->name),
-                               &current_objfile->symbol_obstack);
+                               &current_objfile->objfile_obstack);
                SYMBOL_CLASS (enum_sym) = LOC_CONST;
                SYMBOL_TYPE (enum_sym) = t;
                SYMBOL_CLASS (enum_sym) = LOC_CONST;
                SYMBOL_TYPE (enum_sym) = t;
-               SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
+               SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
                SYMBOL_VALUE (enum_sym) = tsym.value;
                if (SYMBOL_VALUE (enum_sym) < 0)
                  unsigned_enum = 0;
                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++;
 
                /* Skip the stMembers that we've handled. */
                count++;
@@ -1178,11 +1099,11 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
          }
 
        s = new_symbol (name);
          }
 
        s = new_symbol (name);
-       SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
+       SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
        SYMBOL_CLASS (s) = LOC_TYPEDEF;
        SYMBOL_VALUE (s) = 0;
        SYMBOL_TYPE (s) = t;
        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
        break;
 
        /* End of local variables shared by struct, union, enum, and
@@ -1206,7 +1127,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
        }
 
       top_stack->blocktype = stBlock;
        }
 
       top_stack->blocktype = stBlock;
-      b = new_block (top_stack->maxsyms);
+      b = new_block (NON_FUNCTION_BLOCK);
       BLOCK_START (b) = sh->value + top_stack->procadr;
       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
       top_stack->cur_block = b;
       BLOCK_START (b) = sh->value + top_stack->procadr;
       BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
       top_stack->cur_block = b;
@@ -1225,29 +1146,26 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
        {
          /* Finished with procedure */
          struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
        {
          /* Finished with procedure */
          struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
-         struct mips_extra_func_info *e;
-         struct block *b;
+         struct mdebug_extra_func_info *e;
+         struct block *b = top_stack->cur_block;
          struct type *ftype = top_stack->cur_type;
          int i;
 
          BLOCK_END (top_stack->cur_block) += sh->value;        /* size */
 
          /* Make up special symbol to contain procedure specific info */
          struct type *ftype = top_stack->cur_type;
          int i;
 
          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);
-         SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
+         s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
+         SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
          SYMBOL_CLASS (s) = LOC_CONST;
          SYMBOL_TYPE (s) = mdebug_type_void;
          SYMBOL_CLASS (s) = LOC_CONST;
          SYMBOL_TYPE (s) = mdebug_type_void;
-         e = ((struct mips_extra_func_info *)
-              obstack_alloc (&current_objfile->symbol_obstack,
-                             sizeof (struct mips_extra_func_info)));
-         memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
+         e = ((struct mdebug_extra_func_info *)
+              obstack_alloc (&current_objfile->objfile_obstack,
+                             sizeof (struct mdebug_extra_func_info)));
+         memset (e, 0, sizeof (struct mdebug_extra_func_info));
          SYMBOL_VALUE (s) = (long) e;
          e->numargs = top_stack->numargs;
          e->pdr.framereg = -1;
          SYMBOL_VALUE (s) = (long) e;
          e->numargs = top_stack->numargs;
          e->pdr.framereg = -1;
-         add_symbol (s, top_stack->cur_block);
-
-         /* Reallocate symbols, saving memory */
-         b = shrink_block (top_stack->cur_block, top_stack->cur_st);
+         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.  */
 
          /* f77 emits proc-level with address bounds==[0,0],
             So look for such child blocks, and patch them.  */
@@ -1273,24 +1191,22 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
 
              if (nparams > 0)
                {
 
              if (nparams > 0)
                {
+                 struct dict_iterator iter;
                  TYPE_NFIELDS (ftype) = nparams;
                  TYPE_FIELDS (ftype) = (struct field *)
                    TYPE_ALLOC (ftype, nparams * sizeof (struct field));
 
                  TYPE_NFIELDS (ftype) = nparams;
                  TYPE_FIELDS (ftype) = (struct field *)
                    TYPE_ALLOC (ftype, nparams * sizeof (struct field));
 
-                 for (i = iparams = 0; iparams < nparams; i++)
+                 iparams = 0;
+                 ALL_BLOCK_SYMBOLS (b, iter, sym)
                    {
                    {
-                     sym = BLOCK_SYM (b, i);
-                     switch (SYMBOL_CLASS (sym))
+                     if (iparams == nparams)
+                       break;
+
+                     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_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
+                         TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
                          iparams++;
                          iparams++;
-                         break;
-                       default:
-                         break;
                        }
                    }
                }
                        }
                    }
                }
@@ -1302,7 +1218,6 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
             displacement from the procedure`s start address of the
             end of this block. */
          BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
             displacement from the procedure`s start address of the
             end of this block. */
          BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
-         shrink_block (top_stack->cur_block, top_stack->cur_st);
        }
       else if (sh->sc == scText && top_stack->blocktype == stNil)
        {
        }
       else if (sh->sc == scText && top_stack->blocktype == stNil)
        {
@@ -1317,7 +1232,8 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
          ;
        }
       else
          ;
        }
       else
-       complain (&stEnd_complaint, sh->sc);
+       complaint (&symfile_complaints,
+                  _("stEnd with storage class %d not handled"), sh->sc);
 
       pop_parse_stack ();      /* restore previous lexical context */
       break;
 
       pop_parse_stack ();      /* restore previous lexical context */
       break;
@@ -1329,6 +1245,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       bitsize = 0;
       FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name);
       FIELD_BITSIZE (*f) = bitsize;
       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 */
       break;
 
     case stIndirect:           /* forward declaration on Irix5 */
@@ -1376,11 +1293,11 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
       if (has_opaque_xref (cur_fdr, sh))
        break;
       s = new_symbol (name);
       if (has_opaque_xref (cur_fdr, sh))
        break;
       s = new_symbol (name);
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+      SYMBOL_DOMAIN (s) = VAR_DOMAIN;
       SYMBOL_CLASS (s) = LOC_TYPEDEF;
       SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
       SYMBOL_TYPE (s) = t;
       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
 
       /* Incomplete definitions of structs should not get a name.  */
       if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
@@ -1411,7 +1328,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
                 for anything except pointers or functions.  */
            }
          else
                 for anything except pointers or functions.  */
            }
          else
-           TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
+           TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s);
        }
       break;
 
        }
       break;
 
@@ -1428,7 +1345,7 @@ parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
     case stConstant:
       break;                   /* constant */
     default:
     case stConstant:
       break;                   /* constant */
     default:
-      complain (&unknown_mdebug_symtype_complaint, sh->st);
+      complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
       break;
     }
 
       break;
     }
 
@@ -1497,7 +1414,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
   /* Handle corrupt aux indices.  */
   if (aux_index >= (debug_info->fdr + fd)->caux)
     {
   /* Handle corrupt aux indices.  */
   if (aux_index >= (debug_info->fdr + fd)->caux)
     {
-      complain (&index_complaint, sym_name);
+      index_complaint (sym_name);
       return mdebug_type_int;
     }
   ax += aux_index;
       return mdebug_type_int;
     }
   ax += aux_index;
@@ -1506,7 +1423,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
   (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
   if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
     {
   (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t);
   if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
     {
-      complain (&basic_type_complaint, t->bt, sym_name);
+      basic_type_complaint (t->bt, sym_name);
       return mdebug_type_int;
     }
   if (map_bt[t->bt])
       return mdebug_type_int;
     }
   if (map_bt[t->bt])
@@ -1545,7 +1462,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          type_code = TYPE_CODE_ERROR;
          break;
        default:
          type_code = TYPE_CODE_ERROR;
          break;
        default:
-         complain (&basic_type_complaint, t->bt, sym_name);
+         basic_type_complaint (t->bt, sym_name);
          return mdebug_type_int;
        }
     }
          return mdebug_type_int;
        }
     }
@@ -1556,9 +1473,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
   if (t->fBitfield)
     {
       int width = AUX_GET_WIDTH (bigend, ax);
   if (t->fBitfield)
     {
       int width = AUX_GET_WIDTH (bigend, ax);
-
-      /* Inhibit core dumps with some cfront generated objects that
-         corrupt the TIR.  */
+      /* Inhibit core dumps if TIR is corrupted.  */
       if (bs == (int *) NULL)
        {
          /* Alpha cc -migrate encodes char and unsigned char types
       if (bs == (int *) NULL)
        {
          /* Alpha cc -migrate encodes char and unsigned char types
@@ -1571,7 +1486,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          else if (t->bt == btEnum)
            ;
          else
          else if (t->bt == btEnum)
            ;
          else
-           complain (&bad_fbitfield_complaint, sym_name);
+           complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"),
+                      sym_name);
        }
       else
        *bs = width;
        }
       else
        *bs = width;
@@ -1599,7 +1515,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 
       if (rf == -1)
        {
 
       if (rf == -1)
        {
-         complain (&bad_indirect_xref_complaint, sym_name);
+         complaint (&symfile_complaints,
+                    _("unable to cross ref btIndirect for %s"), sym_name);
          return mdebug_type_int;
        }
       xref_fh = get_rfd (fd, rf);
          return mdebug_type_int;
        }
       xref_fh = get_rfd (fd, rf);
@@ -1630,7 +1547,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          dereference them.  */
       while (TYPE_CODE (tp) == TYPE_CODE_PTR
             || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
          dereference them.  */
       while (TYPE_CODE (tp) == TYPE_CODE_PTR
             || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
-       tp = tp->target_type;
+       tp = TYPE_TARGET_TYPE (tp);
 
       /* Make sure that TYPE_CODE(tp) has an expected type code.
          Any type may be returned from cross_ref if file indirect entries
 
       /* Make sure that TYPE_CODE(tp) has an expected type code.
          Any type may be returned from cross_ref if file indirect entries
@@ -1639,7 +1556,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          && TYPE_CODE (tp) != TYPE_CODE_UNION
          && TYPE_CODE (tp) != TYPE_CODE_ENUM)
        {
          && TYPE_CODE (tp) != TYPE_CODE_UNION
          && TYPE_CODE (tp) != TYPE_CODE_ENUM)
        {
-         complain (&unexpected_type_code_complaint, sym_name);
+         unexpected_type_code_complaint (sym_name);
        }
       else
        {
        }
       else
        {
@@ -1653,7 +1570,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
              || (TYPE_CODE (tp) != TYPE_CODE_ENUM
                  && type_code == TYPE_CODE_ENUM))
            {
              || (TYPE_CODE (tp) != TYPE_CODE_ENUM
                  && type_code == TYPE_CODE_ENUM))
            {
-             complain (&bad_tag_guess_complaint, sym_name);
+             bad_tag_guess_complaint (sym_name);
            }
 
          if (TYPE_CODE (tp) != type_code)
            }
 
          if (TYPE_CODE (tp) != type_code)
@@ -1666,9 +1583,9 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          if (name[0] == '.' || name[0] == '\0')
            TYPE_TAG_NAME (tp) = NULL;
          else if (TYPE_TAG_NAME (tp) == NULL
          if (name[0] == '.' || name[0] == '\0')
            TYPE_TAG_NAME (tp) = NULL;
          else if (TYPE_TAG_NAME (tp) == NULL
-                  || !STREQ (TYPE_TAG_NAME (tp), name))
+                  || strcmp (TYPE_TAG_NAME (tp), name) != 0)
            TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
            TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
-                                           &current_objfile->type_obstack);
+                                           &current_objfile->objfile_obstack);
        }
     }
 
        }
     }
 
@@ -1690,7 +1607,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
          are corrupted.  */
       if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
        {
          are corrupted.  */
       if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
        {
-         complain (&unexpected_type_code_complaint, sym_name);
+         unexpected_type_code_complaint (sym_name);
        }
       else
        {
        }
       else
        {
@@ -1698,12 +1615,13 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
             exception is if we guessed wrong re struct/union/enum. */
          if (TYPE_CODE (tp) != type_code)
            {
             exception is if we guessed wrong re struct/union/enum. */
          if (TYPE_CODE (tp) != type_code)
            {
-             complain (&bad_tag_guess_complaint, sym_name);
+             bad_tag_guess_complaint (sym_name);
              TYPE_CODE (tp) = type_code;
            }
              TYPE_CODE (tp) = type_code;
            }
-         if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
+         if (TYPE_NAME (tp) == NULL
+             || strcmp (TYPE_NAME (tp), name) != 0)
            TYPE_NAME (tp) = obsavestring (name, strlen (name),
            TYPE_NAME (tp) = obsavestring (name, strlen (name),
-                                          &current_objfile->type_obstack);
+                                          &current_objfile->objfile_obstack);
        }
     }
   if (t->bt == btTypedef)
        }
     }
   if (t->bt == btTypedef)
@@ -1714,7 +1632,8 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
       if (tp == (struct type *) NULL)
        {
       ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
       if (tp == (struct type *) NULL)
        {
-         complain (&unable_to_cross_ref_complaint, sym_name);
+         complaint (&symfile_complaints,
+                    _("unable to cross ref btTypedef for %s"), sym_name);
          tp = mdebug_type_int;
        }
     }
          tp = mdebug_type_int;
        }
     }
@@ -1726,11 +1645,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
       TYPE_FIELDS (tp) = ((struct field *)
                          TYPE_ALLOC (tp, 2 * sizeof (struct field)));
       TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
       TYPE_FIELDS (tp) = ((struct field *)
                          TYPE_ALLOC (tp, 2 * sizeof (struct field)));
       TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
-                                           &current_objfile->type_obstack);
+                                           &current_objfile->objfile_obstack);
       TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
       ax++;
       TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
       TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
       ax++;
       TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
-                                           &current_objfile->type_obstack);
+                                           &current_objfile->objfile_obstack);
       TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
       ax++;
     }
       TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
       ax++;
     }
@@ -1764,7 +1683,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)
 
   /* Complain for illegal continuations due to corrupt aux entries.  */
   if (t->continued)
-    complain (&bad_continued_complaint, sym_name);
+    complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name);
 
   return tp;
 }
 
   return tp;
 }
@@ -1826,7 +1745,8 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
          else due to corrupt aux entries.  */
       if (TYPE_CODE (indx) != TYPE_CODE_INT)
        {
          else due to corrupt aux entries.  */
       if (TYPE_CODE (indx) != TYPE_CODE_INT)
        {
-         complain (&array_index_type_complaint, sym_name);
+         complaint (&symfile_complaints,
+                    _("illegal array index type for %s, assuming int"), sym_name);
          indx = mdebug_type_int;
        }
 
          indx = mdebug_type_int;
        }
 
@@ -1876,7 +1796,7 @@ upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
       return 0;
 
     default:
       return 0;
 
     default:
-      complain (&unknown_type_qual_complaint, tq);
+      complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
       return 0;
     }
 }
       return 0;
     }
 }
@@ -1884,13 +1804,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
 
 /* 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
    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 *);
    in question, or NULL to use top_stack->cur_block.  */
 
 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *);
@@ -1899,9 +1819,10 @@ static void
 parse_procedure (PDR *pr, struct symtab *search_symtab,
                 struct partial_symtab *pst)
 {
 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 symbol *s, *i;
   struct block *b;
-  struct mips_extra_func_info *e;
+  struct mdebug_extra_func_info *e;
   char *sh_name;
 
   /* Simple rule to find files linked "-x" */
   char *sh_name;
 
   /* Simple rule to find files linked "-x" */
@@ -1911,7 +1832,9 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
        {
          /* Static procedure at address pr->adr.  Sigh. */
          /* FIXME-32x64.  assuming pr->adr fits in long.  */
        {
          /* Static procedure at address pr->adr.  Sigh. */
          /* FIXME-32x64.  assuming pr->adr fits in long.  */
-         complain (&pdr_static_symbol_complaint, (unsigned long) pr->adr);
+         complaint (&symfile_complaints,
+                    _("can't handle PDR for static proc at 0x%lx"),
+                    (unsigned long) pr->adr);
          return;
        }
       else
          return;
        }
       else
@@ -1951,19 +1874,19 @@ 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;
          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_NAMESPACE, 0, NULL);
+      s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0);
       cur_fdr = save_cur_fdr;
 #else
       s = mylookup_symbol
        (sh_name,
         BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
       cur_fdr = save_cur_fdr;
 #else
       s = mylookup_symbol
        (sh_name,
         BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
-        VAR_NAMESPACE,
+        VAR_DOMAIN,
         LOC_BLOCK);
 #endif
     }
   else
     s = mylookup_symbol (sh_name, top_stack->cur_block,
         LOC_BLOCK);
 #endif
     }
   else
     s = mylookup_symbol (sh_name, top_stack->cur_block,
-                        VAR_NAMESPACE, LOC_BLOCK);
+                        VAR_DOMAIN, LOC_BLOCK);
 
   if (s != 0)
     {
 
   if (s != 0)
     {
@@ -1971,17 +1894,17 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
     }
   else
     {
     }
   else
     {
-      complain (&pdr_for_nonsymbol_complaint, sh_name);
+      complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
 #if 1
       return;
 #else
 /* FIXME -- delete.  We can't do symbol allocation now; it's all done.  */
       s = new_symbol (sh_name);
 #if 1
       return;
 #else
 /* FIXME -- delete.  We can't do symbol allocation now; it's all done.  */
       s = new_symbol (sh_name);
-      SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+      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);
       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);
+      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;
       /* Wont have symbols for this one */
       b = new_block (2);
       SYMBOL_BLOCK_VALUE (s) = b;
@@ -1995,11 +1918,11 @@ parse_procedure (PDR *pr, struct symtab *search_symtab,
 #endif
     }
 
 #endif
     }
 
-  i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
+  i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
 
   if (i)
     {
 
   if (i)
     {
-      e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
+      e = (struct mdebug_extra_func_info *) SYMBOL_VALUE (i);
       e->pdr = *pr;
       e->pdr.isym = (long) s;
 
       e->pdr = *pr;
       e->pdr.isym = (long) s;
 
@@ -2014,16 +1937,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);
          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 && STREQ (sh_name, "setjmp"))
-       {
-         complain (&bad_setjmp_pdr_complaint, 0);
-         e->pdr.pcreg = RA_REGNUM;
-         e->pdr.regmask = 0x80000000;
-         e->pdr.regoffset = -4;
-       }
     }
 
   /* It would be reasonable that functions that have been compiled
     }
 
   /* It would be reasonable that functions that have been compiled
@@ -2044,19 +1957,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)
   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
 }
 
 /* Parse the external symbol ES. Just call parse_symbol() after
@@ -2116,7 +2017,7 @@ parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
       n_undef_symbols++;
       /* FIXME:  Turn this into a complaint? */
       if (info_verbose)
       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;
                         what, debug_info->ssext + es->asym.iss,
                         fdr_name (cur_fdr));
       return;
@@ -2194,7 +2095,7 @@ parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
        halt = base + fh->cbLine;
       base += pr->cbLineOffset;
 
        halt = base + fh->cbLine;
       base += pr->cbLineOffset;
 
-      adr = TEXTLOW (pst) + pr->adr - lowest_pdr_addr;
+      adr = pst->textlow + pr->adr - lowest_pdr_addr;
 
       l = adr >> 2;            /* in words */
       for (lineno = pr->lnLow; base < halt;)
 
       l = adr >> 2;            /* in words */
       for (lineno = pr->lnLow; base < halt;)
@@ -2216,7 +2117,9 @@ parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
             with corrupt binaries.  */
          if (lt->nitems >= maxlines)
            {
             with corrupt binaries.  */
          if (lt->nitems >= maxlines)
            {
-             complain (&bad_linetable_guess_complaint, fdr_name (fh));
+             complaint (&symfile_complaints,
+                        _("guessed size of linetable for %s incorrectly"),
+                        fdr_name (fh));
              break;
            }
          k = add_line (lt, lineno, l, k);
              break;
            }
          k = add_line (lt, lineno, l, k);
@@ -2225,18 +2128,106 @@ parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
     }
 }
 \f
     }
 }
 \f
+static void
+function_outside_compilation_unit_complaint (const char *arg1)
+{
+  complaint (&symfile_complaints,
+            _("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, NULL,
+                                       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)
 {
 /* 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;
   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;
-  void (*const swap_ext_in) (bfd *, PTR, EXTR *) = debug_swap->swap_ext_in;
-  void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
-  void (*const swap_rfd_in) (bfd *, PTR, RFDT *) = debug_swap->swap_rfd_in;
+  void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in;
+  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
+  void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in;
   int f_idx, s_idx;
   HDRR *hdr = &debug_info->symbolic_header;
   /* Running pointers */
   int f_idx, s_idx;
   HDRR *hdr = &debug_info->symbolic_header;
   /* Running pointers */
@@ -2244,7 +2235,7 @@ parse_partial_symbols (struct objfile *objfile)
   char *ext_out;
   char *ext_out_end;
   EXTR *ext_block;
   char *ext_out;
   char *ext_out_end;
   EXTR *ext_block;
-  register EXTR *ext_in;
+  EXTR *ext_in;
   EXTR *ext_in_end;
   SYMR sh;
   struct partial_symtab *pst;
   EXTR *ext_in_end;
   SYMR sh;
   struct partial_symtab *pst;
@@ -2277,7 +2268,7 @@ parse_partial_symbols (struct objfile *objfile)
       && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
     relocatable = 1;
 
       && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
     relocatable = 1;
 
-  extern_tab = (EXTR *) obstack_alloc (&objfile->psymbol_obstack,
+  extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
                                       sizeof (EXTR) * hdr->iextMax);
 
   includes_allocated = 30;
                                       sizeof (EXTR) * hdr->iextMax);
 
   includes_allocated = 30;
@@ -2321,9 +2312,9 @@ parse_partial_symbols (struct objfile *objfile)
   /* Allocate the global pending list.  */
   pending_list =
     ((struct mdebug_pending **)
   /* Allocate the global pending list.  */
   pending_list =
     ((struct mdebug_pending **)
-     obstack_alloc (&objfile->psymbol_obstack,
+     obstack_alloc (&objfile->objfile_obstack,
                    hdr->ifdMax * sizeof (struct mdebug_pending *)));
                    hdr->ifdMax * sizeof (struct mdebug_pending *)));
-  memset ((PTR) pending_list, 0,
+  memset (pending_list, 0,
          hdr->ifdMax * sizeof (struct mdebug_pending *));
 
   /* Pass 0 over external syms: swap them in.  */
          hdr->ifdMax * sizeof (struct mdebug_pending *));
 
   /* Pass 0 over external syms: swap them in.  */
@@ -2401,13 +2392,16 @@ parse_partial_symbols (struct objfile *objfile)
          external symbols.  */
       if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
        {
          external symbols.  */
       if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
        {
-         complain (&bad_ext_ifd_complaint, ext_in->ifd, hdr->ifdMax);
+         complaint (&symfile_complaints,
+                    _("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)
        {
          continue;
        }
       if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
        {
-         complain (&bad_ext_iss_complaint, ext_in->asym.iss,
-                   hdr->issExtMax);
+         complaint (&symfile_complaints,
+                    _("bad iss for external symbol: %ld (max %ld)"),
+                    ext_in->asym.iss, hdr->issExtMax);
          continue;
        }
 
          continue;
        }
 
@@ -2452,26 +2446,72 @@ parse_partial_symbols (struct objfile *objfile)
              ms_type = mst_bss;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
            }
              ms_type = mst_bss;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
            }
+          else if (SC_IS_SBSS (ext_in->asym.sc))
+            {
+              ms_type = mst_bss;
+              svalue += ANOFFSET (objfile->section_offsets, 
+                                  get_section_index (objfile, ".sbss"));
+            }
          else
            ms_type = mst_abs;
          break;
        case stLabel:
          /* Label */
          else
            ms_type = mst_abs;
          break;
        case stLabel:
          /* Label */
+
+          /* On certain platforms, some extra label symbols can be
+             generated by the linker. One possible usage for this kind
+             of symbols is to represent the address of the begining of a
+             given section. For instance, on Tru64 5.1, the address of
+             the _ftext label is the start address of the .text section.
+
+             The storage class of these symbols is usually directly
+             related to the section to which the symbol refers. For
+             instance, on Tru64 5.1, the storage class for the _fdata
+             label is scData, refering to the .data section.
+
+             It is actually possible that the section associated to the
+             storage class of the label does not exist. On True64 5.1
+             for instance, the libm.so shared library does not contain
+             any .data section, although it contains a _fpdata label
+             which storage class is scData... Since these symbols are
+             usually useless for the debugger user anyway, we just
+             discard these symbols.
+           */
+          
          if (SC_IS_TEXT (ext_in->asym.sc))
            {
          if (SC_IS_TEXT (ext_in->asym.sc))
            {
+              if (objfile->sect_index_text == -1)
+                continue;
+                
              ms_type = mst_file_text;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
            }
          else if (SC_IS_DATA (ext_in->asym.sc))
            {
              ms_type = mst_file_text;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
            }
          else if (SC_IS_DATA (ext_in->asym.sc))
            {
+              if (objfile->sect_index_data == -1)
+                continue;
+
              ms_type = mst_file_data;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
            }
          else if (SC_IS_BSS (ext_in->asym.sc))
            {
              ms_type = mst_file_data;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
            }
          else if (SC_IS_BSS (ext_in->asym.sc))
            {
+              if (objfile->sect_index_bss == -1)
+                continue;
+
              ms_type = mst_file_bss;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
            }
              ms_type = mst_file_bss;
              svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
            }
+          else if (SC_IS_SBSS (ext_in->asym.sc))
+            {
+              const int sbss_sect_index = get_section_index (objfile, ".sbss");
+
+              if (sbss_sect_index == -1)
+                continue;
+
+              ms_type = mst_file_bss;
+              svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index);
+            }
          else
            ms_type = mst_abs;
          break;
          else
            ms_type = mst_abs;
          break;
@@ -2487,10 +2527,11 @@ parse_partial_symbols (struct objfile *objfile)
          /* Fall through.  */
        default:
          ms_type = mst_unknown;
          /* Fall through.  */
        default:
          ms_type = mst_unknown;
-         complain (&unknown_ext_complaint, name);
+         unknown_ext_complaint (name);
        }
       if (!ECOFF_IN_ELF (cur_bfd))
        }
       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 */
     }
 
   /* Pass 3 over files, over local syms: fill in static symbols */
@@ -2524,13 +2565,11 @@ parse_partial_symbols (struct objfile *objfile)
                                  objfile->global_psymbols.next,
                                  objfile->static_psymbols.next);
       pst->read_symtab_private = ((char *)
                                  objfile->global_psymbols.next,
                                  objfile->static_psymbols.next);
       pst->read_symtab_private = ((char *)
-                                 obstack_alloc (&objfile->psymbol_obstack,
+                                 obstack_alloc (&objfile->objfile_obstack,
                                                 sizeof (struct symloc)));
                                                 sizeof (struct symloc)));
-      memset ((PTR) pst->read_symtab_private, 0, sizeof (struct symloc));
+      memset (pst->read_symtab_private, 0, sizeof (struct symloc));
 
       save_pst = pst;
 
       save_pst = pst;
-      TEXTLOW (pst) = pst->textlow;
-      TEXTHIGH (pst) = pst->texthigh;
       FDR_IDX (pst) = f_idx;
       CUR_BFD (pst) = cur_bfd;
       DEBUG_SWAP (pst) = debug_swap;
       FDR_IDX (pst) = f_idx;
       CUR_BFD (pst) = cur_bfd;
       DEBUG_SWAP (pst) = debug_swap;
@@ -2566,7 +2605,7 @@ parse_partial_symbols (struct objfile *objfile)
        psymtab_language = prev_language;
       PST_PRIVATE (pst)->pst_language = psymtab_language;
 
        psymtab_language = prev_language;
       PST_PRIVATE (pst)->pst_language = psymtab_language;
 
-      TEXTHIGH (pst) = TEXTLOW (pst);
+      pst->texthigh = pst->textlow;
 
       /* For stabs-in-ecoff files, the second symbol must be @stab.
          This symbol is emitted by mips-tfile to signal that the
 
       /* For stabs-in-ecoff files, the second symbol must be @stab.
          This symbol is emitted by mips-tfile to signal that the
@@ -2581,7 +2620,8 @@ parse_partial_symbols (struct objfile *objfile)
                          ((char *) debug_info->external_sym
                           + (fh->isymBase + 1) * external_sym_size),
                          &sh);
                          ((char *) debug_info->external_sym
                           + (fh->isymBase + 1) * external_sym_size),
                          &sh);
-         if (STREQ (debug_info->ss + fh->issBase + sh.iss, stabs_symbol))
+         if (strcmp (debug_info->ss + fh->issBase + sh.iss,
+                     stabs_symbol) == 0)
            processing_gcc_compilation = 2;
        }
 
            processing_gcc_compilation = 2;
        }
 
@@ -2608,13 +2648,9 @@ parse_partial_symbols (struct objfile *objfile)
                      if (sh.st == stStaticProc)
                        {
                          namestring = debug_info->ss + fh->issBase + sh.iss;
                      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;
 
                        }
                      procaddr = sh.value;
 
@@ -2633,10 +2669,10 @@ parse_partial_symbols (struct objfile *objfile)
 
                          /* Kludge for Irix 5.2 zero fh->adr.  */
                          if (!relocatable
 
                          /* Kludge for Irix 5.2 zero fh->adr.  */
                          if (!relocatable
-                         && (TEXTLOW (pst) == 0 || procaddr < TEXTLOW (pst)))
-                           TEXTLOW (pst) = procaddr;
-                         if (high > TEXTHIGH (pst))
-                           TEXTHIGH (pst) = high;
+                         && (pst->textlow == 0 || procaddr < pst->textlow))
+                           pst->textlow = procaddr;
+                         if (high > pst->texthigh)
+                           pst->texthigh = high;
                        }
                    }
                  else if (sh.st == stStatic)
                        }
                    }
                  else if (sh.st == stStatic)
@@ -2656,13 +2692,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));
                        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:
                          break;
 
                        default:
@@ -2670,13 +2702,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));
                             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;
                        }
                    }
                          break;
                        }
                    }
@@ -2711,17 +2739,16 @@ parse_partial_symbols (struct objfile *objfile)
                     && stabstring != debug_info->ss + fh->issBase + sh.iss)
                      stabstring = xrealloc (stabstring, len + len2 + 1);
                    else
                     && stabstring != debug_info->ss + fh->issBase + sh.iss)
                      stabstring = xrealloc (stabstring, len + len2 + 1);
                    else
-                     stabstring = xmalloc (len + len2 + 1);
-                   strcpy (stabstring, stabstring1);
+                     {
+                       stabstring = xmalloc (len + len2 + 1);
+                       strcpy (stabstring, stabstring1);
+                     }
                    strcpy (stabstring + len, stabstring2);
                    len += len2;
                  }
 
                switch (type_code)
                  {
                    strcpy (stabstring + len, stabstring2);
                    len += len2;
                  }
 
                switch (type_code)
                  {
-                   static struct complaint function_outside_compilation_unit = {
-                     "function `%s' appears to be defined outside of all compilation units", 0, 0
-                   };
                    char *p;
                    /*
                     * Standard, external, non-debugger, symbols
                    char *p;
                    /*
                     * Standard, external, non-debugger, symbols
@@ -2813,21 +2840,19 @@ parse_partial_symbols (struct objfile *objfile)
 
                      prev_textlow_not_set = textlow_not_set;
 
 
                      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.  */
 
                      /* 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;
                        {
                          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)
                      past_first_source_file = 1;
 
                      if (prev_so_symnum != symnum - 1)
@@ -2903,12 +2928,13 @@ parse_partial_symbols (struct objfile *objfile)
                         things like "break c-exp.y:435" need to work (I
                         suppose the psymtab_include_list could be hashed or put
                         in a binary tree, if profiling shows this is a major hog).  */
                         things like "break c-exp.y:435" need to work (I
                         suppose the psymtab_include_list could be hashed or put
                         in a binary tree, if profiling shows this is a major hog).  */
-                     if (pst && STREQ (namestring, pst->filename))
+                     if (pst && strcmp (namestring, pst->filename) == 0)
                        continue;
                      {
                        continue;
                      {
-                       register int i;
+                       int i;
                        for (i = 0; i < includes_used; i++)
                        for (i = 0; i < includes_used; i++)
-                         if (STREQ (namestring, psymtab_include_list[i]))
+                         if (strcmp (namestring,
+                                     psymtab_include_list[i]) == 0)
                            {
                              i = -1;
                              break;
                            {
                              i = -1;
                              break;
@@ -2925,7 +2951,7 @@ parse_partial_symbols (struct objfile *objfile)
                          psymtab_include_list = (char **)
                            alloca ((includes_allocated *= 2) *
                                    sizeof (char *));
                          psymtab_include_list = (char **)
                            alloca ((includes_allocated *= 2) *
                                    sizeof (char *));
-                         memcpy ((PTR) psymtab_include_list, (PTR) orig,
+                         memcpy (psymtab_include_list, orig,
                                  includes_used * sizeof (char *));
                        }
                      continue;
                                  includes_used * sizeof (char *));
                        }
                      continue;
@@ -2967,11 +2993,13 @@ parse_partial_symbols (struct objfile *objfile)
                      {
                      case 'S':
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (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,
                        add_psymbol_to_list (namestring, p - namestring,
-                                            VAR_NAMESPACE, LOC_STATIC,
+                                            VAR_DOMAIN, LOC_STATIC,
                                             &objfile->static_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
                                             &objfile->static_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
@@ -2981,7 +3009,7 @@ parse_partial_symbols (struct objfile *objfile)
                        /* The addresses in these entries are reported to be
                           wrong.  See the code that reads 'G's for symtabs. */
                        add_psymbol_to_list (namestring, p - namestring,
                        /* The addresses in these entries are reported to be
                           wrong.  See the code that reads 'G's for symtabs. */
                        add_psymbol_to_list (namestring, p - namestring,
-                                            VAR_NAMESPACE, LOC_STATIC,
+                                            VAR_DOMAIN, LOC_STATIC,
                                             &objfile->global_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
                                             &objfile->global_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
@@ -2999,7 +3027,7 @@ parse_partial_symbols (struct objfile *objfile)
                                && namestring[0] != ' '))
                          {
                            add_psymbol_to_list (namestring, p - namestring,
                                && namestring[0] != ' '))
                          {
                            add_psymbol_to_list (namestring, p - namestring,
-                                                STRUCT_NAMESPACE, LOC_TYPEDEF,
+                                                STRUCT_DOMAIN, LOC_TYPEDEF,
                                                 &objfile->static_psymbols,
                                                 sh.value, 0,
                                                 psymtab_language, objfile);
                                                 &objfile->static_psymbols,
                                                 sh.value, 0,
                                                 psymtab_language, objfile);
@@ -3007,33 +3035,19 @@ parse_partial_symbols (struct objfile *objfile)
                              {
                                /* Also a typedef with the same name.  */
                                add_psymbol_to_list (namestring, p - namestring,
                              {
                                /* Also a typedef with the same name.  */
                                add_psymbol_to_list (namestring, p - namestring,
-                                                    VAR_NAMESPACE, LOC_TYPEDEF,
+                                                    VAR_DOMAIN, LOC_TYPEDEF,
                                                     &objfile->static_psymbols,
                                                     sh.value, 0,
                                                     psymtab_language, objfile);
                                p += 1;
                              }
                                                     &objfile->static_psymbols,
                                                     sh.value, 0,
                                                     psymtab_language, objfile);
                                p += 1;
                              }
-                           /* The semantics of C++ state that "struct foo { ... }"
-                              also defines a typedef for "foo".  Unfortuantely, cfront
-                              never makes the typedef when translating from C++ to C.
-                              We make the typedef here so that "ptype foo" works as
-                              expected for cfront translated code.  */
-                           else if (psymtab_language == language_cplus)
-                             {
-                               /* Also a typedef with the same name.  */
-                               add_psymbol_to_list (namestring, p - namestring,
-                                                    VAR_NAMESPACE, LOC_TYPEDEF,
-                                                    &objfile->static_psymbols,
-                                                    sh.value, 0,
-                                                    psymtab_language, objfile);
-                             }
                          }
                        goto check_enum;
                      case 't':
                        if (p != namestring)    /* a name is there, not just :T... */
                          {
                            add_psymbol_to_list (namestring, p - namestring,
                          }
                        goto check_enum;
                      case 't':
                        if (p != namestring)    /* a name is there, not just :T... */
                          {
                            add_psymbol_to_list (namestring, p - namestring,
-                                                VAR_NAMESPACE, LOC_TYPEDEF,
+                                                VAR_DOMAIN, LOC_TYPEDEF,
                                                 &objfile->static_psymbols,
                                                 sh.value, 0,
                                                 psymtab_language, objfile);
                                                 &objfile->static_psymbols,
                                                 sh.value, 0,
                                                 psymtab_language, objfile);
@@ -3095,7 +3109,7 @@ parse_partial_symbols (struct objfile *objfile)
                                /* Note that the value doesn't matter for
                                   enum constants in psymtabs, just in symtabs.  */
                                add_psymbol_to_list (p, q - p,
                                /* Note that the value doesn't matter for
                                   enum constants in psymtabs, just in symtabs.  */
                                add_psymbol_to_list (p, q - p,
-                                                    VAR_NAMESPACE, LOC_CONST,
+                                                    VAR_DOMAIN, LOC_CONST,
                                                     &objfile->static_psymbols, 0,
                                                     0, psymtab_language, objfile);
                                /* Point past the name.  */
                                                     &objfile->static_psymbols, 0,
                                                     0, psymtab_language, objfile);
                                /* Point past the name.  */
@@ -3112,7 +3126,7 @@ parse_partial_symbols (struct objfile *objfile)
                      case 'c':
                        /* Constant, e.g. from "const" in Pascal.  */
                        add_psymbol_to_list (namestring, p - namestring,
                      case 'c':
                        /* Constant, e.g. from "const" in Pascal.  */
                        add_psymbol_to_list (namestring, p - namestring,
-                                            VAR_NAMESPACE, LOC_CONST,
+                                            VAR_DOMAIN, LOC_CONST,
                                             &objfile->static_psymbols, sh.value,
                                             0, psymtab_language, objfile);
                        continue;
                                             &objfile->static_psymbols, sh.value,
                                             0, psymtab_language, objfile);
                        continue;
@@ -3124,12 +3138,12 @@ parse_partial_symbols (struct objfile *objfile)
                            char *name = xmalloc (name_len + 1);
                            memcpy (name, namestring, name_len);
                            name[name_len] = '\0';
                            char *name = xmalloc (name_len + 1);
                            memcpy (name, namestring, name_len);
                            name[name_len] = '\0';
-                           complain (&function_outside_compilation_unit, name);
+                           function_outside_compilation_unit_complaint (name);
                            xfree (name);
                          }
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
                        add_psymbol_to_list (namestring, p - namestring,
                            xfree (name);
                          }
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
                        add_psymbol_to_list (namestring, p - namestring,
-                                            VAR_NAMESPACE, LOC_BLOCK,
+                                            VAR_DOMAIN, LOC_BLOCK,
                                             &objfile->static_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
                                             &objfile->static_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
@@ -3145,12 +3159,12 @@ parse_partial_symbols (struct objfile *objfile)
                            char *name = xmalloc (name_len + 1);
                            memcpy (name, namestring, name_len);
                            name[name_len] = '\0';
                            char *name = xmalloc (name_len + 1);
                            memcpy (name, namestring, name_len);
                            name[name_len] = '\0';
-                           complain (&function_outside_compilation_unit, name);
+                           function_outside_compilation_unit_complaint (name);
                            xfree (name);
                          }
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
                        add_psymbol_to_list (namestring, p - namestring,
                            xfree (name);
                          }
                        sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
                        add_psymbol_to_list (namestring, p - namestring,
-                                            VAR_NAMESPACE, LOC_BLOCK,
+                                            VAR_DOMAIN, LOC_BLOCK,
                                             &objfile->global_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
                                             &objfile->global_psymbols,
                                             0, sh.value,
                                             psymtab_language, objfile);
@@ -3173,9 +3187,6 @@ parse_partial_symbols (struct objfile *objfile)
                      case '9':
                      case '-':
                      case '#':         /* for symbol identification (used in live ranges) */
                      case '9':
                      case '-':
                      case '#':         /* for symbol identification (used in live ranges) */
-                       /* added to support cfront stabs strings */
-                     case 'Z':         /* for definition continuations */
-                     case 'P':         /* for prototypes */
                        continue;
 
                      case ':':
                        continue;
 
                      case ':':
@@ -3196,7 +3207,8 @@ parse_partial_symbols (struct objfile *objfile)
                           time searching to the end of every string looking for
                           a backslash.  */
 
                           time searching to the end of every string looking for
                           a backslash.  */
 
-                       complain (&unknown_symchar_complaint, p[1]);
+                       complaint (&symfile_complaints,
+                                  _("unknown symbol descriptor `%c'"), p[1]);
 
                        /* Ignore it; perhaps it is an extension that we don't
                           know about.  */
 
                        /* Ignore it; perhaps it is an extension that we don't
                           know about.  */
@@ -3207,23 +3219,23 @@ parse_partial_symbols (struct objfile *objfile)
                    continue;
 
                  case N_ENDM:
                    continue;
 
                  case N_ENDM:
-#ifdef SOFUN_ADDRESS_MAYBE_MISSING
-                   /* Solaris 2 end of module, finish current partial symbol table.
-                      END_PSYMTAB will set TEXTHIGH (pst) to the proper value, which
-                      is necessary if a module compiled without debugging info
-                      follows this module.  */
-                   if (pst)
+                   /* 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
+                       && gdbarch_sofun_address_maybe_missing (gdbarch))
                      {
                        pst = (struct partial_symtab *) 0;
                        includes_used = 0;
                        dependencies_used = 0;
                      }
                      {
                        pst = (struct partial_symtab *) 0;
                        includes_used = 0;
                        dependencies_used = 0;
                      }
-#endif
                    continue;
 
                  case N_RBRAC:
                    continue;
 
                  case N_RBRAC:
-                   if (sh.value > TEXTHIGH (save_pst))
-                     TEXTHIGH (save_pst) = sh.value;
+                   if (sh.value > save_pst->texthigh)
+                     save_pst->texthigh = sh.value;
                    continue;
                  case N_EINCL:
                  case N_DSLINE:
                    continue;
                  case N_EINCL:
                  case N_DSLINE:
@@ -3256,8 +3268,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.  */
                  default:
                    /* If we haven't found it yet, ignore it.  It's probably some
                       new type we don't know about yet.  */
-                   complain (&unknown_symtype_complaint,
-                             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
                    continue;
                  }
                if (stabstring
@@ -3335,6 +3347,39 @@ parse_partial_symbols (struct objfile *objfile)
                  /* FALLTHROUGH */
 
                case stProc:
                  /* FALLTHROUGH */
 
                case stProc:
+                 /* Ignore all parameter symbol records.  */
+                 if (sh.index >= hdr->iauxMax)
+                   {
+                     /* Should not happen, but does when cross-compiling
+                        with the MIPS compiler.  FIXME -- pull later.  */
+                     index_complaint (name);
+                     new_sdx = cur_sdx + 1;    /* Don't skip at all */
+                   }
+                 else
+                   new_sdx = AUX_GET_ISYM (fh->fBigendian,
+                                           (debug_info->external_aux
+                                            + fh->iauxBase
+                                            + sh.index));
+
+                 if (new_sdx <= cur_sdx)
+                   {
+                     /* This should not happen either... FIXME.  */
+                     complaint (&symfile_complaints,
+                                _("bad proc end in aux found from symbol %s"),
+                                name);
+                     new_sdx = cur_sdx + 1;    /* Don't skip backward */
+                   }
+
+                  /* For stProc symbol records, we need to check the
+                     storage class as well, as only (stProc, scText)
+                     entries represent "real" procedures - See the
+                     Compaq document titled "Object File / Symbol Table
+                     Format Specification" for more information.  If the
+                     storage class is not scText, we discard the whole
+                     block of symbol records for this stProc.  */
+                  if (sh.st == stProc && sh.sc != scText)
+                    goto skip;
+
                  /* Usually there is a local and a global stProc symbol
                     for a function. This means that the function name
                     has already been entered into the mimimal symbol table
                  /* Usually there is a local and a global stProc symbol
                     for a function. This means that the function name
                     has already been entered into the mimimal symbol table
@@ -3348,37 +3393,17 @@ parse_partial_symbols (struct objfile *objfile)
                     symbol table.  */
                  if (sh.st == stProc)
                    add_psymbol_to_list (name, strlen (name),
                     symbol table.  */
                  if (sh.st == stProc)
                    add_psymbol_to_list (name, strlen (name),
-                                        VAR_NAMESPACE, LOC_BLOCK,
+                                        VAR_DOMAIN, LOC_BLOCK,
                                         &objfile->global_psymbols,
                                    0, sh.value, psymtab_language, objfile);
                  else
                    add_psymbol_to_list (name, strlen (name),
                                         &objfile->global_psymbols,
                                    0, sh.value, psymtab_language, objfile);
                  else
                    add_psymbol_to_list (name, strlen (name),
-                                        VAR_NAMESPACE, LOC_BLOCK,
+                                        VAR_DOMAIN, LOC_BLOCK,
                                         &objfile->static_psymbols,
                                    0, sh.value, psymtab_language, objfile);
 
                                         &objfile->static_psymbols,
                                    0, sh.value, psymtab_language, objfile);
 
-                 /* Skip over procedure to next one. */
-                 if (sh.index >= hdr->iauxMax)
-                   {
-                     /* Should not happen, but does when cross-compiling
-                        with the MIPS compiler.  FIXME -- pull later.  */
-                     complain (&index_complaint, name);
-                     new_sdx = cur_sdx + 1;    /* Don't skip at all */
-                   }
-                 else
-                   new_sdx = AUX_GET_ISYM (fh->fBigendian,
-                                           (debug_info->external_aux
-                                            + fh->iauxBase
-                                            + sh.index));
                  procaddr = sh.value;
 
                  procaddr = sh.value;
 
-                 if (new_sdx <= cur_sdx)
-                   {
-                     /* This should not happen either... FIXME.  */
-                     complain (&aux_index_complaint, name);
-                     new_sdx = cur_sdx + 1;    /* Don't skip backward */
-                   }
-
                  cur_sdx = new_sdx;
                  (*swap_sym_in) (cur_bfd,
                                  ((char *) debug_info->external_sym
                  cur_sdx = new_sdx;
                  (*swap_sym_in) (cur_bfd,
                                  ((char *) debug_info->external_sym
@@ -3390,12 +3415,12 @@ parse_partial_symbols (struct objfile *objfile)
 
                  /* Kludge for Irix 5.2 zero fh->adr.  */
                  if (!relocatable
 
                  /* Kludge for Irix 5.2 zero fh->adr.  */
                  if (!relocatable
-                     && (TEXTLOW (pst) == 0 || procaddr < TEXTLOW (pst)))
-                   TEXTLOW (pst) = procaddr;
+                     && (pst->textlow == 0 || procaddr < pst->textlow))
+                   pst->textlow = procaddr;
 
                  high = procaddr + sh.value;
 
                  high = procaddr + sh.value;
-                 if (high > TEXTHIGH (pst))
-                   TEXTHIGH (pst) = high;
+                 if (high > pst->texthigh)
+                   pst->texthigh = high;
                  continue;
 
                case stStatic:  /* Variable */
                  continue;
 
                case stStatic:  /* Variable */
@@ -3442,7 +3467,7 @@ parse_partial_symbols (struct objfile *objfile)
                      && sh.index != cur_sdx + 2)
                    {
                      add_psymbol_to_list (name, strlen (name),
                      && sh.index != cur_sdx + 2)
                    {
                      add_psymbol_to_list (name, strlen (name),
-                                          STRUCT_NAMESPACE, LOC_TYPEDEF,
+                                          STRUCT_DOMAIN, LOC_TYPEDEF,
                                           &objfile->static_psymbols,
                                           0, (CORE_ADDR) 0,
                                           psymtab_language, objfile);
                                           &objfile->static_psymbols,
                                           0, (CORE_ADDR) 0,
                                           psymtab_language, objfile);
@@ -3454,7 +3479,8 @@ parse_partial_symbols (struct objfile *objfile)
                  if (new_sdx <= cur_sdx)
                    {
                      /* This happens with the Ultrix kernel. */
                  if (new_sdx <= cur_sdx)
                    {
                      /* This happens with the Ultrix kernel. */
-                     complain (&block_index_complaint, name);
+                     complaint (&symfile_complaints,
+                                _("bad aux index at block symbol %s"), name);
                      new_sdx = cur_sdx + 1;    /* Don't skip backward */
                    }
                  cur_sdx = new_sdx;
                      new_sdx = cur_sdx + 1;    /* Don't skip backward */
                    }
                  cur_sdx = new_sdx;
@@ -3474,14 +3500,15 @@ parse_partial_symbols (struct objfile *objfile)
                default:
                  /* Both complaints are valid:  one gives symbol name,
                     the other the offending symbol type.  */
                default:
                  /* Both complaints are valid:  one gives symbol name,
                     the other the offending symbol type.  */
-                 complain (&unknown_sym_complaint, name);
-                 complain (&unknown_st_complaint, sh.st);
+                 complaint (&symfile_complaints, _("unknown local symbol %s"),
+                            name);
+                 complaint (&symfile_complaints, _("with type %d"), sh.st);
                  cur_sdx++;
                  continue;
                }
              /* Use this gdb symbol */
              add_psymbol_to_list (name, strlen (name),
                  cur_sdx++;
                  continue;
                }
              /* Use this gdb symbol */
              add_psymbol_to_list (name, strlen (name),
-                                  VAR_NAMESPACE, class,
+                                  VAR_DOMAIN, class,
                                   &objfile->static_psymbols,
                                   0, sh.value, psymtab_language, objfile);
            skip:
                                   &objfile->static_psymbols,
                                   0, sh.value, psymtab_language, objfile);
            skip:
@@ -3501,7 +3528,7 @@ parse_partial_symbols (struct objfile *objfile)
              CORE_ADDR svalue;
 
              if (ext_ptr->ifd != f_idx)
              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.  */
              psh = &ext_ptr->asym;
 
              /* Do not add undefined symbols to the partial symbol table.  */
@@ -3544,8 +3571,7 @@ parse_partial_symbols (struct objfile *objfile)
                  class = LOC_LABEL;
                  break;
                default:
                  class = LOC_LABEL;
                  break;
                default:
-                 complain (&unknown_ext_complaint,
-                           debug_info->ssext + psh->iss);
+                 unknown_ext_complaint (debug_info->ssext + psh->iss);
                  /* Fall through, pretend it's global.  */
                case stGlobal:
                  /* Global common symbols are resolved by the runtime loader,
                  /* Fall through, pretend it's global.  */
                case stGlobal:
                  /* Global common symbols are resolved by the runtime loader,
@@ -3558,7 +3584,7 @@ parse_partial_symbols (struct objfile *objfile)
                }
              name = debug_info->ssext + psh->iss;
              add_psymbol_to_list (name, strlen (name),
                }
              name = debug_info->ssext + psh->iss;
              add_psymbol_to_list (name, strlen (name),
-                                  VAR_NAMESPACE, class,
+                                  VAR_DOMAIN, class,
                                   &objfile->global_psymbols,
                                   0, svalue,
                                   psymtab_language, objfile);
                                   &objfile->global_psymbols,
                                   0, svalue,
                                   psymtab_language, objfile);
@@ -3569,18 +3595,11 @@ parse_partial_symbols (struct objfile *objfile)
          empty and put on the free list.  */
       fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
                                        psymtab_include_list, includes_used,
          empty and put on the free list.  */
       fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
                                        psymtab_include_list, includes_used,
-                                          -1, TEXTHIGH (save_pst),
+                                          -1, save_pst->texthigh,
                       dependency_list, dependencies_used, textlow_not_set);
       includes_used = 0;
       dependencies_used = 0;
 
                       dependency_list, dependencies_used, textlow_not_set);
       includes_used = 0;
       dependencies_used = 0;
 
-      if (objfile->ei.entry_point >= TEXTLOW (save_pst) &&
-         objfile->ei.entry_point < TEXTHIGH (save_pst))
-       {
-         objfile->ei.entry_file_lowpc = TEXTLOW (save_pst);
-         objfile->ei.entry_file_highpc = TEXTHIGH (save_pst);
-       }
-
       /* The objfile has its functions reordered if this partial symbol
          table overlaps any other partial symbol table.
          We cannot assume a reordered objfile if a partial symbol table
       /* The objfile has its functions reordered if this partial symbol
          table overlaps any other partial symbol table.
          We cannot assume a reordered objfile if a partial symbol table
@@ -3594,15 +3613,15 @@ parse_partial_symbols (struct objfile *objfile)
          other cases.  */
       save_pst = fdr_to_pst[f_idx].pst;
       if (save_pst != NULL
          other cases.  */
       save_pst = fdr_to_pst[f_idx].pst;
       if (save_pst != NULL
-         && TEXTLOW (save_pst) != 0
+         && save_pst->textlow != 0
          && !(objfile->flags & OBJF_REORDERED))
        {
          ALL_OBJFILE_PSYMTABS (objfile, pst)
          {
            if (save_pst != pst
          && !(objfile->flags & OBJF_REORDERED))
        {
          ALL_OBJFILE_PSYMTABS (objfile, pst)
          {
            if (save_pst != pst
-               && TEXTLOW (save_pst) >= TEXTLOW (pst)
-               && TEXTLOW (save_pst) < TEXTHIGH (pst)
-               && TEXTHIGH (save_pst) > TEXTHIGH (pst))
+               && save_pst->textlow >= pst->textlow
+               && save_pst->textlow < pst->texthigh
+               && save_pst->texthigh > pst->texthigh)
              {
                objfile->flags |= OBJF_REORDERED;
                break;
              {
                objfile->flags |= OBJF_REORDERED;
                break;
@@ -3629,7 +3648,7 @@ parse_partial_symbols (struct objfile *objfile)
       pst->number_of_dependencies = 0;
       pst->dependencies =
        ((struct partial_symtab **)
       pst->number_of_dependencies = 0;
       pst->dependencies =
        ((struct partial_symtab **)
-        obstack_alloc (&objfile->psymbol_obstack,
+        obstack_alloc (&objfile->objfile_obstack,
                        ((fh->crfd - 1)
                         * sizeof (struct partial_symtab *))));
       for (s_idx = 1; s_idx < fh->crfd; s_idx++)
                        ((fh->crfd - 1)
                         * sizeof (struct partial_symtab *))));
       for (s_idx = 1; s_idx < fh->crfd; s_idx++)
@@ -3642,7 +3661,7 @@ parse_partial_symbols (struct objfile *objfile)
                          &rh);
          if (rh < 0 || rh >= hdr->ifdMax)
            {
                          &rh);
          if (rh < 0 || rh >= hdr->ifdMax)
            {
-             complain (&bad_file_number_complaint, rh);
+             complaint (&symfile_complaints, _("bad file number %ld"), rh);
              continue;
            }
 
              continue;
            }
 
@@ -3675,7 +3694,7 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
                            CORE_ADDR svalue)
 {
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
                            CORE_ADDR svalue)
 {
   const bfd_size_type external_sym_size = debug_swap->external_sym_size;
-  void (*const swap_sym_in) (bfd *, PTR, SYMR *) = debug_swap->swap_sym_in;
+  void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
   char *ext_sym = ((char *) debug_info->external_sym
                   + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
   SYMR sh;
   char *ext_sym = ((char *) debug_info->external_sym
                   + ((fh->isymBase + cur_sdx + 1) * external_sym_size));
   SYMR sh;
@@ -3728,7 +3747,7 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
       /* Note that the value doesn't matter for enum constants
          in psymtabs, just in symtabs.  */
       add_psymbol_to_list (name, strlen (name),
       /* Note that the value doesn't matter for enum constants
          in psymtabs, just in symtabs.  */
       add_psymbol_to_list (name, strlen (name),
-                          VAR_NAMESPACE, LOC_CONST,
+                          VAR_DOMAIN, LOC_CONST,
                           &objfile->static_psymbols, 0,
                           (CORE_ADDR) 0, psymtab_language, objfile);
       ext_sym += external_sym_size;
                           &objfile->static_psymbols, 0,
                           (CORE_ADDR) 0, psymtab_language, objfile);
       ext_sym += external_sym_size;
@@ -3766,8 +3785,8 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
 {
   bfd_size_type external_sym_size;
   bfd_size_type external_pdr_size;
 {
   bfd_size_type external_sym_size;
   bfd_size_type external_pdr_size;
-  void (*swap_sym_in) (bfd *, PTR, SYMR *);
-  void (*swap_pdr_in) (bfd *, PTR, PDR *);
+  void (*swap_sym_in) (bfd *, void *, SYMR *);
+  void (*swap_pdr_in) (bfd *, void *, PDR *);
   int i;
   struct symtab *st = NULL;
   FDR *fh;
   int i;
   struct symtab *st = NULL;
   FDR *fh;
@@ -3806,7 +3825,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
   /* Do nothing if this is a dummy psymtab.  */
 
   if (pst->n_global_syms == 0 && pst->n_static_syms == 0
   /* Do nothing if this is a dummy psymtab.  */
 
   if (pst->n_global_syms == 0 && pst->n_static_syms == 0
-      && TEXTLOW (pst) == 0 && TEXTHIGH (pst) == 0)
+      && pst->textlow == 0 && pst->texthigh == 0)
     return;
 
   /* Now read the symbols for this symtab */
     return;
 
   /* Now read the symbols for this symtab */
@@ -3836,8 +3855,8 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
                      ((char *) debug_info->external_sym
                       + (fh->isymBase + 1) * external_sym_size),
                      &sh);
                      ((char *) debug_info->external_sym
                       + (fh->isymBase + 1) * external_sym_size),
                      &sh);
-      if (STREQ (debug_info->ss + fh->issBase + sh.iss,
-                stabs_symbol))
+      if (strcmp (debug_info->ss + fh->issBase + sh.iss,
+                 stabs_symbol) == 0)
        {
          /* We indicate that this is a GCC compilation so that certain
             features will be enabled in stabsread/dbxread.  */
        {
          /* We indicate that this is a GCC compilation so that certain
             features will be enabled in stabsread/dbxread.  */
@@ -3914,14 +3933,14 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
                {
                  /* Make up special symbol to contain
                     procedure specific info */
                {
                  /* Make up special symbol to contain
                     procedure specific info */
-                 struct mips_extra_func_info *e =
-                 ((struct mips_extra_func_info *)
-                  obstack_alloc (&current_objfile->symbol_obstack,
-                                 sizeof (struct mips_extra_func_info)));
-                 struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
-
-                 memset ((PTR) e, 0, sizeof (struct mips_extra_func_info));
-                 SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
+                 struct mdebug_extra_func_info *e =
+                 ((struct mdebug_extra_func_info *)
+                  obstack_alloc (&current_objfile->objfile_obstack,
+                                 sizeof (struct mdebug_extra_func_info)));
+                 struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
+
+                 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_CLASS (s) = LOC_CONST;
                  SYMBOL_TYPE (s) = mdebug_type_void;
                  SYMBOL_VALUE (s) = (long) e;
@@ -3949,19 +3968,15 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
            /* These are generated by gcc-2.x, do not complain */
            ;
          else
            /* These are generated by gcc-2.x, do not complain */
            ;
          else
-           complain (&stab_unknown_complaint, name);
+           complaint (&symfile_complaints, _("unknown stabs symbol %s"), name);
        }
 
       if (! last_symtab_ended)
        {
        }
 
       if (! last_symtab_ended)
        {
-         st = end_symtab (TEXTHIGH (pst), pst->objfile, SECT_OFF_TEXT (pst->objfile));
+         st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile));
          end_stabs ();
        }
 
          end_stabs ();
        }
 
-      /* Sort the symbol table now, we are done adding symbols to it.
-         We must do this before parse_procedure calls lookup_symbol.  */
-      sort_symtab_syms (st);
-
       /* There used to be a call to sort_blocks here, but this should not
          be necessary for stabs symtabs.  And as sort_blocks modifies the
          start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
       /* There used to be a call to sort_blocks here, but this should not
          be necessary for stabs symtabs.  And as sort_blocks modifies the
          start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
@@ -4015,19 +4030,15 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
       int maxlines;
       EXTR *ext_ptr;
 
       int maxlines;
       EXTR *ext_ptr;
 
-      /* How many symbols will we need */
-      /* FIXME, this does not count enum values. */
-      f_max = pst->n_global_syms + pst->n_static_syms;
       if (fh == 0)
        {
          maxlines = 0;
       if (fh == 0)
        {
          maxlines = 0;
-         st = new_symtab ("unknown", f_max, 0, pst->objfile);
+         st = new_symtab ("unknown", 0, pst->objfile);
        }
       else
        {
        }
       else
        {
-         f_max += fh->csym + fh->cpd;
          maxlines = 2 * fh->cline;
          maxlines = 2 * fh->cline;
-         st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
+         st = new_symtab (pst->filename, maxlines, pst->objfile);
 
          /* The proper language was already determined when building
             the psymtab, use it.  */
 
          /* The proper language was already determined when building
             the psymtab, use it.  */
@@ -4044,10 +4055,9 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
       top_stack->cur_st = st;
       top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
                                                STATIC_BLOCK);
       top_stack->cur_st = st;
       top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
                                                STATIC_BLOCK);
-      BLOCK_START (top_stack->cur_block) = TEXTLOW (pst);
+      BLOCK_START (top_stack->cur_block) = pst->textlow;
       BLOCK_END (top_stack->cur_block) = 0;
       top_stack->blocktype = stFile;
       BLOCK_END (top_stack->cur_block) = 0;
       top_stack->blocktype = stFile;
-      top_stack->maxsyms = 2 * f_max;
       top_stack->cur_type = 0;
       top_stack->procadr = 0;
       top_stack->numargs = 0;
       top_stack->cur_type = 0;
       top_stack->procadr = 0;
       top_stack->numargs = 0;
@@ -4131,10 +4141,6 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
       top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
                                                GLOBAL_BLOCK);
       top_stack->blocktype = stFile;
       top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
                                                GLOBAL_BLOCK);
       top_stack->blocktype = stFile;
-      top_stack->maxsyms
-       = (debug_info->symbolic_header.isymMax
-          + debug_info->symbolic_header.ipdMax
-          + debug_info->symbolic_header.iextMax);
 
       ext_ptr = PST_PRIVATE (pst)->extern_tab;
       for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
 
       ext_ptr = PST_PRIVATE (pst)->extern_tab;
       for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
@@ -4145,7 +4151,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)
        {
          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);
                           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);
@@ -4156,9 +4162,6 @@ psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename)
 
       st->primary = 1;
 
 
       st->primary = 1;
 
-      /* Sort the symbol table now, we are done adding symbols to it. */
-      sort_symtab_syms (st);
-
       sort_blocks (st);
     }
 
       sort_blocks (st);
     }
 
@@ -4239,8 +4242,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
   if (rf == -1)
     {
       *pname = "<undefined>";
   if (rf == -1)
     {
       *pname = "<undefined>";
-      *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
-      TYPE_FLAGS (*tpp) |= TYPE_FLAG_STUB;
+      *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile);
       return result;
     }
 
       return result;
     }
 
@@ -4261,8 +4263,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
     {
       /* File indirect entry is corrupt.  */
       *pname = "<illegal>";
     {
       /* File indirect entry is corrupt.  */
       *pname = "<illegal>";
-      complain (&bad_rfd_entry_complaint,
-               sym_name, xref_fd, rn->index);
+      bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
       return result;
     }
 
       return result;
     }
 
@@ -4286,8 +4287,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
     {
       /* File indirect entry is corrupt.  */
       *pname = "<illegal>";
     {
       /* File indirect entry is corrupt.  */
       *pname = "<illegal>";
-      complain (&bad_rfd_entry_complaint,
-               sym_name, xref_fd, rn->index);
+      bad_rfd_entry_complaint (sym_name, xref_fd, rn->index);
       return result;
     }
 
       return result;
     }
 
@@ -4323,7 +4323,8 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
                                        + fh->iauxBase + sh.index)->a_ti,
                                      &tir);
          if (tir.tq0 != tqNil)
                                        + fh->iauxBase + sh.index)->a_ti,
                                      &tir);
          if (tir.tq0 != tqNil)
-           complain (&illegal_forward_tq0_complaint, sym_name);
+           complaint (&symfile_complaints,
+                      _("illegal tq0 in forward typedef for %s"), sym_name);
          switch (tir.bt)
            {
            case btVoid:
          switch (tir.bt)
            {
            case btVoid:
@@ -4360,7 +4361,9 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
              break;
 
            default:
              break;
 
            default:
-             complain (&illegal_forward_bt_complaint, tir.bt, sym_name);
+             complaint (&symfile_complaints,
+                        _("illegal bt %d in forward typedef for %s"), tir.bt,
+                        sym_name);
              *tpp = init_type (type_code, 0, 0, (char *) NULL,
                                current_objfile);
              break;
              *tpp = init_type (type_code, 0, 0, (char *) NULL,
                                current_objfile);
              break;
@@ -4404,63 +4407,37 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_cod
    keeping the symtab sorted */
 
 static struct symbol *
    keeping the symtab sorted */
 
 static struct symbol *
-mylookup_symbol (char *name, register struct block *block,
-                namespace_enum namespace, enum address_class class)
+mylookup_symbol (char *name, struct block *block,
+                domain_enum domain, enum address_class class)
 {
 {
-  int i, inc;
+  struct dict_iterator iter;
+  int inc;
   struct symbol *sym;
 
   inc = name[0];
   struct symbol *sym;
 
   inc = name[0];
-  ALL_BLOCK_SYMBOLS (block, i, sym)
+  ALL_BLOCK_SYMBOLS (block, iter, sym)
     {
     {
-      if (SYMBOL_NAME (sym)[0] == inc
-         && SYMBOL_NAMESPACE (sym) == namespace
+      if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc
+         && SYMBOL_DOMAIN (sym) == domain
          && SYMBOL_CLASS (sym) == class
          && SYMBOL_CLASS (sym) == class
-         && strcmp (SYMBOL_NAME (sym), name) == 0)
+         && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0)
        return sym;
     }
 
   block = BLOCK_SUPERBLOCK (block);
   if (block)
        return sym;
     }
 
   block = BLOCK_SUPERBLOCK (block);
   if (block)
-    return mylookup_symbol (name, block, namespace, class);
+    return mylookup_symbol (name, block, domain, class);
   return 0;
 }
 
 
   return 0;
 }
 
 
-/* Add a new symbol S to a block B.
-   Infrequently, we will need to reallocate the block to make it bigger.
-   We only detect this case when adding to top_stack->cur_block, since
-   that's the only time we know how big the block is.  FIXME.  */
+/* Add a new symbol S to a block B.  */
 
 static void
 
 static void
-add_symbol (struct symbol *s, struct block *b)
+add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
 {
 {
-  int nsyms = BLOCK_NSYMS (b)++;
-  struct block *origb;
-  struct parse_stack *stackp;
-
-  if (b == top_stack->cur_block &&
-      nsyms >= top_stack->maxsyms)
-    {
-      complain (&block_overflow_complaint, SYMBOL_NAME (s));
-      /* In this case shrink_block is actually grow_block, since
-         BLOCK_NSYMS(b) is larger than its current size.  */
-      origb = b;
-      b = shrink_block (top_stack->cur_block, top_stack->cur_st);
-
-      /* Now run through the stack replacing pointers to the
-         original block.  shrink_block has already done this
-         for the blockvector and BLOCK_FUNCTION.  */
-      for (stackp = top_stack; stackp; stackp = stackp->next)
-       {
-         if (stackp->cur_block == origb)
-           {
-             stackp->cur_block = b;
-             stackp->maxsyms = BLOCK_NSYMS (b);
-           }
-       }
-    }
-  BLOCK_SYM (b, nsyms) = s;
+  SYMBOL_SYMTAB (s) = symtab;
+  dict_add_symbol (BLOCK_DICT (b), s);
 }
 
 /* Add a new block B to a symtab S */
 }
 
 /* Add a new block B to a symtab S */
@@ -4470,7 +4447,7 @@ add_block (struct block *b, struct symtab *s)
 {
   struct blockvector *bv = BLOCKVECTOR (s);
 
 {
   struct blockvector *bv = BLOCKVECTOR (s);
 
-  bv = (struct blockvector *) xrealloc ((PTR) bv,
+  bv = (struct blockvector *) xrealloc ((void *) bv,
                                        (sizeof (struct blockvector)
                                         + BLOCKVECTOR_NBLOCKS (bv)
                                         * sizeof (bv->block)));
                                        (sizeof (struct blockvector)
                                         + BLOCKVECTOR_NBLOCKS (bv)
                                         * sizeof (bv->block)));
@@ -4518,9 +4495,9 @@ add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last)
 /* Blocks with a smaller low bound should come first */
 
 static int
 /* Blocks with a smaller low bound should come first */
 
 static int
-compare_blocks (const PTR arg1, const PTR arg2)
+compare_blocks (const void *arg1, const void *arg2)
 {
 {
-  register int addr_diff;
+  LONGEST addr_diff;
   struct block **b1 = (struct block **) arg1;
   struct block **b2 = (struct block **) arg2;
 
   struct block **b1 = (struct block **) arg1;
   struct block **b2 = (struct block **) arg2;
 
@@ -4561,8 +4538,8 @@ sort_blocks (struct symtab *s)
           compare_blocks);
 
   {
           compare_blocks);
 
   {
-    register CORE_ADDR high = 0;
-    register int i, j = BLOCKVECTOR_NBLOCKS (bv);
+    CORE_ADDR high = 0;
+    int i, j = BLOCKVECTOR_NBLOCKS (bv);
 
     for (i = FIRST_LOCAL_BLOCK; i < j; i++)
       if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
 
     for (i = FIRST_LOCAL_BLOCK; i < j; i++)
       if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)))
@@ -4582,11 +4559,11 @@ sort_blocks (struct symtab *s)
 
 /* Constructor/restructor/destructor procedures */
 
 
 /* Constructor/restructor/destructor procedures */
 
-/* Allocate a new symtab for NAME.  Needs an estimate of how many symbols
-   MAXSYMS and linenumbers MAXLINES we'll put in it */
+/* Allocate a new symtab for NAME.  Needs an estimate of how many
+   linenumbers MAXLINES we'll put in it */
 
 static struct symtab *
 
 static struct symtab *
-new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile)
+new_symtab (char *name, int maxlines, struct objfile *objfile)
 {
   struct symtab *s = allocate_symtab (name, objfile);
 
 {
   struct symtab *s = allocate_symtab (name, objfile);
 
@@ -4594,14 +4571,16 @@ new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile)
 
   /* All symtabs must have at least two blocks */
   BLOCKVECTOR (s) = new_bvect (2);
 
   /* All symtabs must have at least two blocks */
   BLOCKVECTOR (s) = new_bvect (2);
-  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms);
-  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms);
+  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
+    = new_block (NON_FUNCTION_BLOCK);
+  BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
+    = new_block (NON_FUNCTION_BLOCK);
   BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
     BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 
   s->free_code = free_linetable;
   s->debugformat = obsavestring ("ECOFF", 5,
   BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
     BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 
   s->free_code = free_linetable;
   s->debugformat = obsavestring ("ECOFF", 5,
-                                &objfile->symbol_obstack);
+                                &objfile->objfile_obstack);
   return (s);
 }
 
   return (s);
 }
 
@@ -4618,9 +4597,9 @@ new_psymtab (char *name, struct objfile *objfile)
   /* Keep a backpointer to the file's symbols */
 
   psymtab->read_symtab_private = ((char *)
   /* Keep a backpointer to the file's symbols */
 
   psymtab->read_symtab_private = ((char *)
-                                 obstack_alloc (&objfile->psymbol_obstack,
+                                 obstack_alloc (&objfile->objfile_obstack,
                                                 sizeof (struct symloc)));
                                                 sizeof (struct symloc)));
-  memset ((PTR) psymtab->read_symtab_private, 0, sizeof (struct symloc));
+  memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
   CUR_BFD (psymtab) = cur_bfd;
   DEBUG_SWAP (psymtab) = debug_swap;
   DEBUG_INFO (psymtab) = debug_info;
   CUR_BFD (psymtab) = cur_bfd;
   DEBUG_SWAP (psymtab) = debug_swap;
   DEBUG_INFO (psymtab) = debug_info;
@@ -4657,7 +4636,7 @@ static struct linetable *
 shrink_linetable (struct linetable *lt)
 {
 
 shrink_linetable (struct linetable *lt)
 {
 
-  return (struct linetable *) xrealloc ((PTR) lt,
+  return (struct linetable *) xrealloc ((void *) lt,
                                        (sizeof (struct linetable)
                                         + ((lt->nitems - 1)
                                            * sizeof (lt->item))));
                                        (sizeof (struct linetable)
                                         + ((lt->nitems - 1)
                                            * sizeof (lt->item))));
@@ -4679,43 +4658,25 @@ new_bvect (int nblocks)
   return bv;
 }
 
   return bv;
 }
 
-/* Allocate and zero a new block of MAXSYMS symbols */
+/* Allocate and zero a new block, and set its BLOCK_DICT.  If function
+   is non-zero, assume the block is associated to a function, and make
+   sure that the symbols are stored linearly; otherwise, store them
+   hashed.  */
 
 static struct block *
 
 static struct block *
-new_block (int maxsyms)
+new_block (enum block_type type)
 {
 {
-  int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *);
-
-  return (struct block *) xzalloc (size);
-}
+  /* FIXME: carlton/2003-09-11: This should use allocate_block to
+     allocate the block.  Which, in turn, suggests that the block
+     should be allocated on an obstack.  */
+  struct block *retval = xzalloc (sizeof (struct block));
 
 
-/* Ooops, too big. Shrink block B in symtab S to its minimal size.
-   Shrink_block can also be used by add_symbol to grow a block.  */
-
-static struct block *
-shrink_block (struct block *b, struct symtab *s)
-{
-  struct block *new;
-  struct blockvector *bv = BLOCKVECTOR (s);
-  int i;
+  if (type == FUNCTION_BLOCK)
+    BLOCK_DICT (retval) = dict_create_linear_expandable ();
+  else
+    BLOCK_DICT (retval) = dict_create_hashed_expandable ();
 
 
-  /* Just reallocate it and fix references to the old one */
-
-  new = (struct block *) xrealloc ((PTR) b,
-                                  (sizeof (struct block)
-                                   + ((BLOCK_NSYMS (b) - 1)
-                                      * sizeof (struct symbol *))));
-
-  /* Should chase pointers to old one.  Fortunately, that`s just
-     the block`s function and inferior blocks */
-  if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b)
-    SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
-  for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
-    if (BLOCKVECTOR_BLOCK (bv, i) == b)
-      BLOCKVECTOR_BLOCK (bv, i) = new;
-    else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b)
-      BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new;
-  return new;
+  return retval;
 }
 
 /* Create a new symbol with printname NAME */
 }
 
 /* Create a new symbol with printname NAME */
@@ -4724,14 +4685,12 @@ static struct symbol *
 new_symbol (char *name)
 {
   struct symbol *s = ((struct symbol *)
 new_symbol (char *name)
 {
   struct symbol *s = ((struct symbol *)
-                     obstack_alloc (&current_objfile->symbol_obstack,
+                     obstack_alloc (&current_objfile->objfile_obstack,
                                     sizeof (struct symbol)));
 
                                     sizeof (struct symbol)));
 
-  memset ((PTR) s, 0, sizeof (*s));
-  SYMBOL_NAME (s) = obsavestring (name, strlen (name),
-                                 &current_objfile->symbol_obstack);
+  memset (s, 0, sizeof (*s));
   SYMBOL_LANGUAGE (s) = psymtab_language;
   SYMBOL_LANGUAGE (s) = psymtab_language;
-  SYMBOL_INIT_DEMANGLED_NAME (s, &current_objfile->symbol_obstack);
+  SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile);
   return s;
 }
 
   return s;
 }
 
@@ -4759,138 +4718,29 @@ elfmdebug_build_psymtabs (struct objfile *objfile,
 {
   bfd *abfd = objfile->obfd;
   struct ecoff_debug_info *info;
 {
   bfd *abfd = objfile->obfd;
   struct ecoff_debug_info *info;
+  struct cleanup *back_to;
+
+  /* FIXME: It's not clear whether we should be getting minimal symbol
+     information from .mdebug in an ELF file, or whether we will.
+     Re-initialize the minimal symbol reader in case we do.  */
+
+  init_minimal_symbol_collection ();
+  back_to = make_cleanup_discard_minimal_symbols ();
 
   info = ((struct ecoff_debug_info *)
 
   info = ((struct ecoff_debug_info *)
-         obstack_alloc (&objfile->psymbol_obstack,
+         obstack_alloc (&objfile->objfile_obstack,
                         sizeof (struct ecoff_debug_info)));
 
   if (!(*swap->read_debug_info) (abfd, sec, info))
                         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);
           bfd_errmsg (bfd_get_error ()));
 
   mdebug_build_psymtabs (objfile, swap, info);
-}
-\f
-
-/* Things used for calling functions in the inferior.
-   These functions are exported to our companion
-   mips-tdep.c file and are here because they play
-   with the symbol-table explicitly. */
-
-/* Sigtramp: make sure we have all the necessary information
-   about the signal trampoline code. Since the official code
-   from MIPS does not do so, we make up that information ourselves.
-   If they fix the library (unlikely) this code will neutralize itself. */
 
 
-/* FIXME: This function is called only by mips-tdep.c.  It needs to be
-   here because it calls functions defined in this file, but perhaps
-   this could be handled in a better way.  Only compile it in when
-   tm-mips.h is included. */
-
-#ifdef TM_MIPS_H
-
-void
-fixup_sigtramp (void)
-{
-  struct symbol *s;
-  struct symtab *st;
-  struct block *b, *b0 = NULL;
-
-  sigtramp_address = -1;
-
-  /* We have to handle the following cases here:
-     a) The Mips library has a sigtramp label within sigvec.
-     b) Irix has a _sigtramp which we want to use, but it also has sigvec.  */
-  s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
-  if (s != 0)
-    {
-      b0 = SYMBOL_BLOCK_VALUE (s);
-      s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
-    }
-  if (s == 0)
-    {
-      /* No sigvec or no sigtramp inside sigvec, try _sigtramp.  */
-      s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
-    }
-
-  /* But maybe this program uses its own version of sigvec */
-  if (s == 0)
-    return;
-
-  /* Did we or MIPSco fix the library ? */
-  if (SYMBOL_CLASS (s) == LOC_BLOCK)
-    {
-      sigtramp_address = BLOCK_START (SYMBOL_BLOCK_VALUE (s));
-      sigtramp_end = BLOCK_END (SYMBOL_BLOCK_VALUE (s));
-      return;
-    }
-
-  sigtramp_address = SYMBOL_VALUE (s);
-  sigtramp_end = sigtramp_address + 0x88;      /* black magic */
-
-  /* But what symtab does it live in ? */
-  st = find_pc_symtab (SYMBOL_VALUE (s));
-
-  /*
-   * Ok, there goes the fix: turn it into a procedure, with all the
-   * needed info.  Note we make it a nested procedure of sigvec,
-   * which is the way the (assembly) code is actually written.
-   */
-  SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
-  SYMBOL_CLASS (s) = LOC_BLOCK;
-  SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
-                              st->objfile);
-  TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void;
-
-  /* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
-  b = new_block (1);
-  SYMBOL_BLOCK_VALUE (s) = b;
-  BLOCK_START (b) = sigtramp_address;
-  BLOCK_END (b) = sigtramp_end;
-  BLOCK_FUNCTION (b) = s;
-  BLOCK_SUPERBLOCK (b) = BLOCK_SUPERBLOCK (b0);
-  add_block (b, st);
-  sort_blocks (st);
-
-  /* Make a MIPS_EFI_SYMBOL_NAME entry for it */
-  {
-    struct mips_extra_func_info *e =
-    ((struct mips_extra_func_info *)
-     xzalloc (sizeof (struct mips_extra_func_info)));
-
-    e->numargs = 0;            /* the kernel thinks otherwise */
-    e->pdr.frameoffset = 32;
-    e->pdr.framereg = SP_REGNUM;
-    /* Note that setting pcreg is no longer strictly necessary as
-       mips_frame_saved_pc is now aware of signal handler frames.  */
-    e->pdr.pcreg = PC_REGNUM;
-    e->pdr.regmask = -2;
-    /* Offset to saved r31, in the sigtramp case the saved registers
-       are above the frame in the sigcontext.
-       We have 4 alignment bytes, 12 bytes for onstack, mask and pc,
-       32 * 4 bytes for the general registers, 12 bytes for mdhi, mdlo, ownedfp
-       and 32 * 4 bytes for the floating point registers.  */
-    e->pdr.regoffset = 4 + 12 + 31 * 4;
-    e->pdr.fregmask = -1;
-    /* Offset to saved f30 (first saved *double* register).  */
-    e->pdr.fregoffset = 4 + 12 + 32 * 4 + 12 + 30 * 4;
-    e->pdr.isym = (long) s;
-    e->pdr.adr = sigtramp_address;
-
-    current_objfile = st->objfile;     /* Keep new_symbol happy */
-    s = new_symbol (MIPS_EFI_SYMBOL_NAME);
-    SYMBOL_VALUE (s) = (long) e;
-    SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
-    SYMBOL_CLASS (s) = LOC_CONST;
-    SYMBOL_TYPE (s) = mdebug_type_void;
-    current_objfile = NULL;
-  }
-
-  BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s;
+  install_minimal_symbols (objfile);
+  do_cleanups (back_to);
 }
 
 }
 
-#endif /* TM_MIPS_H */
-
 void
 _initialize_mdebugread (void)
 {
 void
 _initialize_mdebugread (void)
 {
@@ -4965,22 +4815,22 @@ _initialize_mdebugread (void)
               "adr_64", (struct objfile *) NULL);
   TYPE_TARGET_TYPE (mdebug_type_adr_64) = mdebug_type_void;
   mdebug_type_float =
               "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);
+    init_type (TYPE_CODE_FLT,
+              gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
+              0, "float", (struct objfile *) NULL);
   mdebug_type_double =
   mdebug_type_double =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
-              0,
-              "double", (struct objfile *) NULL);
+    init_type (TYPE_CODE_FLT,
+              gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
+              0, "double", (struct objfile *) NULL);
   mdebug_type_complex =
   mdebug_type_complex =
-    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
-              0,
-              "complex", (struct objfile *) NULL);
+    init_type (TYPE_CODE_COMPLEX,
+              2 * gdbarch_float_bit (current_gdbarch) / TARGET_CHAR_BIT,
+              0, "complex", (struct objfile *) NULL);
   TYPE_TARGET_TYPE (mdebug_type_complex) = mdebug_type_float;
   mdebug_type_double_complex =
   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);
+    init_type (TYPE_CODE_COMPLEX,
+              2 * gdbarch_double_bit (current_gdbarch) / 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?
   TYPE_TARGET_TYPE (mdebug_type_double_complex) = mdebug_type_double;
 
   /* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
@@ -4996,20 +4846,13 @@ _initialize_mdebugread (void)
      TYPE_CODE_ERROR print things in hex if it knows the size?  */
   mdebug_type_fixed_dec =
     init_type (TYPE_CODE_INT,
      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,
+              gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
               0, "fixed decimal",
               (struct objfile *) NULL);
 
   mdebug_type_float_dec =
     init_type (TYPE_CODE_ERROR,
               0, "fixed decimal",
               (struct objfile *) NULL);
 
   mdebug_type_float_dec =
     init_type (TYPE_CODE_ERROR,
-              TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+              gdbarch_double_bit (current_gdbarch) / TARGET_CHAR_BIT,
               0, "floating decimal",
               (struct objfile *) NULL);
               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);
 }
 }
This page took 0.063113 seconds and 4 git commands to generate.