projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Use an accessor function for general_symbol_info::language
[deliverable/binutils-gdb.git] / gdb / stabsread.c
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index f16e54743f645928d4313f116617e0067c260467..1b5426e28426bb6074fd849c45adf48d291b5e91 100644 (file)
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1,6 +1,6 @@
 /* Support routines for decoding "stabs" debugging information format.
 
 /* Support routines for decoding "stabs" debugging information format.
 
-   Copyright (C) 1986-2013 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -18,13 +18,13 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Support routines for reading and decoding debugging information in
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Support routines for reading and decoding debugging information in
-   the "stabs" format.  This format is used with many systems that use
-   the a.out object file format, as well as some systems that use
-   COFF or ELF where the stabs data is placed in a special section.
-   Avoid placing any object file format specific code in this file.  */
+   the "stabs" format.  This format is used by some systems that use
+   COFF or ELF where the stabs data is placed in a special section (as
+   well as with many old systems that used the a.out object file
+   format).  Avoid placing any object file format specific code in
+   this file.  */
 
 #include "defs.h"
 
 #include "defs.h"
-#include "gdb_string.h"
 #include "bfd.h"
 #include "gdb_obstack.h"
 #include "symtab.h"
 #include "bfd.h"
 #include "gdb_obstack.h"
 #include "symtab.h"
@@ -36,25 +36,48 @@
 #include "libaout.h"
 #include "aout/aout64.h"
 #include "gdb-stabs.h"
 #include "libaout.h"
 #include "aout/aout64.h"
 #include "gdb-stabs.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
 #include "complaints.h"
 #include "demangle.h"
 #include "gdb-demangle.h"
 #include "language.h"
 #include "complaints.h"
 #include "demangle.h"
 #include "gdb-demangle.h"
 #include "language.h"
-#include "doublest.h"
+#include "target-float.h"
+#include "c-lang.h"
 #include "cp-abi.h"
 #include "cp-support.h"
 #include "cp-abi.h"
 #include "cp-support.h"
-#include "gdb_assert.h"
-
 #include <ctype.h>
 
 #include <ctype.h>
 
-/* Ask stabsread.h to define the vars it normally declares `extern'.  */
-#define        EXTERN
-/**/
-#include "stabsread.h"         /* Our own declarations */
-#undef EXTERN
+#include "stabsread.h"
+
+/* See stabsread.h for these globals.  */
+unsigned int symnum;
+const char *(*next_symbol_text_func) (struct objfile *);
+unsigned char processing_gcc_compilation;
+int within_function;
+struct symbol *global_sym_chain[HASHSIZE];
+struct pending_stabs *global_stabs;
+int previous_stab_code;
+int *this_object_header_files;
+int n_this_object_header_files;
+int n_allocated_this_object_header_files;
+
+struct nextfield
+{
+  struct nextfield *next;
+
+  /* This is the raw visibility from the stab.  It is not checked
+     for being one of the visibilities we recognize, so code which
+     examines this field better be able to deal.  */
+  int visibility;
+
+  struct field field;
+};
 
 
-extern void _initialize_stabsread (void);
+struct next_fnfieldlist
+{
+  struct next_fnfieldlist *next;
+  struct fn_fieldlist fn_fieldlist;
+};
 
 /* The routines that read and process a complete stabs for a C struct or 
    C++ class pass lists of data member fields and lists of member function
 
 /* The routines that read and process a complete stabs for a C struct or 
    C++ class pass lists of data member fields and lists of member function
@@ -62,37 +85,23 @@ extern void _initialize_stabsread (void);
    This is part of some reorganization of low level C++ support and is
    expected to eventually go away...  (FIXME) */
 
    This is part of some reorganization of low level C++ support and is
    expected to eventually go away...  (FIXME) */
 
-struct field_info
+struct stab_field_info
   {
   {
-    struct nextfield
-      {
-       struct nextfield *next;
+    struct nextfield *list = nullptr;
+    struct next_fnfieldlist *fnlist = nullptr;
 
 
-       /* This is the raw visibility from the stab.  It is not checked
-          for being one of the visibilities we recognize, so code which
-          examines this field better be able to deal.  */
-       int visibility;
-
-       struct field field;
-      }
-     *list;
-    struct next_fnfieldlist
-      {
-       struct next_fnfieldlist *next;
-       struct fn_fieldlist fn_fieldlist;
-      }
-     *fnlist;
+    auto_obstack obstack;
   };
 
 static void
   };
 
 static void
-read_one_struct_field (struct field_info *, char **, char *,
+read_one_struct_field (struct stab_field_info *, const char **, const char *,
                       struct type *, struct objfile *);
 
 static struct type *dbx_alloc_type (int[2], struct objfile *);
 
                       struct type *, struct objfile *);
 
 static struct type *dbx_alloc_type (int[2], struct objfile *);
 
-static long read_huge_number (char **, int, int *, int);
+static long read_huge_number (const char **, int, int *, int);
 
 
-static struct type *error_type (char **, struct objfile *);
+static struct type *error_type (const char **, struct objfile *);
 
 static void
 patch_block_stabs (struct pending *, struct pending_stabs *,
 
 static void
 patch_block_stabs (struct pending *, struct pending_stabs *,
@@ -100,60 +109,63 @@ patch_block_stabs (struct pending *, struct pending_stabs *,
 
 static void fix_common_block (struct symbol *, CORE_ADDR);
 
 
 static void fix_common_block (struct symbol *, CORE_ADDR);
 
-static int read_type_number (char **, int *);
+static int read_type_number (const char **, int *);
 
 
-static struct type *read_type (char **, struct objfile *);
+static struct type *read_type (const char **, struct objfile *);
 
 
-static struct type *read_range_type (char **, int[2], int, struct objfile *);
+static struct type *read_range_type (const char **, int[2],
+                                    int, struct objfile *);
 
 
-static struct type *read_sun_builtin_type (char **, int[2], struct objfile *);
+static struct type *read_sun_builtin_type (const char **,
+                                          int[2], struct objfile *);
 
 
-static struct type *read_sun_floating_type (char **, int[2],
+static struct type *read_sun_floating_type (const char **, int[2],
                                            struct objfile *);
 
                                            struct objfile *);
 
-static struct type *read_enum_type (char **, struct type *, struct objfile *);
+static struct type *read_enum_type (const char **, struct type *, struct objfile *);
 
 static struct type *rs6000_builtin_type (int, struct objfile *);
 
 static int
 
 static struct type *rs6000_builtin_type (int, struct objfile *);
 
 static int
-read_member_functions (struct field_info *, char **, struct type *,
+read_member_functions (struct stab_field_info *, const char **, struct type *,
                       struct objfile *);
 
 static int
                       struct objfile *);
 
 static int
-read_struct_fields (struct field_info *, char **, struct type *,
+read_struct_fields (struct stab_field_info *, const char **, struct type *,
                    struct objfile *);
 
 static int
                    struct objfile *);
 
 static int
-read_baseclasses (struct field_info *, char **, struct type *,
+read_baseclasses (struct stab_field_info *, const char **, struct type *,
                  struct objfile *);
 
 static int
                  struct objfile *);
 
 static int
-read_tilde_fields (struct field_info *, char **, struct type *,
+read_tilde_fields (struct stab_field_info *, const char **, struct type *,
                   struct objfile *);
 
                   struct objfile *);
 
-static int attach_fn_fields_to_type (struct field_info *, struct type *);
+static int attach_fn_fields_to_type (struct stab_field_info *, struct type *);
 
 
-static int attach_fields_to_type (struct field_info *, struct type *,
+static int attach_fields_to_type (struct stab_field_info *, struct type *,
                                  struct objfile *);
 
                                  struct objfile *);
 
-static struct type *read_struct_type (char **, struct type *,
+static struct type *read_struct_type (const char **, struct type *,
                                       enum type_code,
                                      struct objfile *);
 
                                       enum type_code,
                                      struct objfile *);
 
-static struct type *read_array_type (char **, struct type *,
+static struct type *read_array_type (const char **, struct type *,
                                     struct objfile *);
 
                                     struct objfile *);
 
-static struct field *read_args (char **, int, struct objfile *, int *, int *);
+static struct field *read_args (const char **, int, struct objfile *,
+                               int *, int *);
 
 static void add_undefined_type (struct type *, int[2]);
 
 static int
 
 static void add_undefined_type (struct type *, int[2]);
 
 static int
-read_cpp_abbrev (struct field_info *, char **, struct type *,
+read_cpp_abbrev (struct stab_field_info *, const char **, struct type *,
                 struct objfile *);
 
                 struct objfile *);
 
-static char *find_name_end (char *name);
+static const char *find_name_end (const char *name);
 
 
-static int process_reference (char **string);
+static int process_reference (const char **string);
 
 void stabsread_clear_cache (void);
 
 
 void stabsread_clear_cache (void);
 
@@ -163,21 +175,20 @@ static const char vb_name[] = "_vb$";
 static void
 invalid_cpp_abbrev_complaint (const char *arg1)
 {
 static void
 invalid_cpp_abbrev_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1);
+  complaint (_("invalid C++ abbreviation `%s'"), arg1);
 }
 
 static void
 reg_value_complaint (int regnum, int num_regs, const char *sym)
 {
 }
 
 static void
 reg_value_complaint (int regnum, int num_regs, const char *sym)
 {
-  complaint (&symfile_complaints,
-            _("register number %d too large (max %d) in symbol %s"),
+  complaint (_("bad register number %d (max %d) in symbol %s"),
              regnum, num_regs - 1, sym);
 }
 
 static void
 stabs_general_complaint (const char *arg1)
 {
              regnum, num_regs - 1, sym);
 }
 
 static void
 stabs_general_complaint (const char *arg1)
 {
-  complaint (&symfile_complaints, "%s", arg1);
+  complaint ("%s", arg1);
 }
 
 /* Make a list of forward references which haven't been defined.  */
 }
 
 /* Make a list of forward references which haven't been defined.  */
@@ -248,8 +259,7 @@ dbx_lookup_type (int typenums[2], struct objfile *objfile)
 
   if (filenum < 0 || filenum >= n_this_object_header_files)
     {
 
   if (filenum < 0 || filenum >= n_this_object_header_files)
     {
-      complaint (&symfile_complaints,
-                _("Invalid symbol data: type number "
+      complaint (_("Invalid symbol data: type number "
                   "(%d,%d) out of range at symtab pos %d."),
                 filenum, index, symnum);
       goto error_return;
                   "(%d,%d) out of range at symtab pos %d."),
                 filenum, index, symnum);
       goto error_return;
@@ -278,8 +288,7 @@ dbx_lookup_type (int typenums[2], struct objfile *objfile)
          if (old_len == 0)
            {
              type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
          if (old_len == 0)
            {
              type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
-             type_vector = (struct type **)
-               xmalloc (type_vector_length * sizeof (struct type *));
+             type_vector = XNEWVEC (struct type *, type_vector_length);
            }
          while (index >= type_vector_length)
            {
            }
          while (index >= type_vector_length)
            {
@@ -355,6 +364,24 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
   return (*type_addr);
 }
 
   return (*type_addr);
 }
 
+/* Allocate a floating-point type of size BITS.  */
+
+static struct type *
+dbx_init_float_type (struct objfile *objfile, int bits)
+{
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  const struct floatformat **format;
+  struct type *type;
+
+  format = gdbarch_floatformat_for_type (gdbarch, NULL, bits);
+  if (format)
+    type = init_float_type (objfile, bits, NULL, format);
+  else
+    type = init_type (objfile, TYPE_CODE_ERROR, bits, NULL);
+
+  return type;
+}
+
 /* for all the stabs in a given stab vector, build appropriate types 
    and fix their symbols in given symbol vector.  */
 
 /* for all the stabs in a given stab vector, build appropriate types 
    and fix their symbols in given symbol vector.  */
 
@@ -364,7 +391,7 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
 {
   int ii;
   char *name;
 {
   int ii;
   char *name;
-  char *pp;
+  const char *pp;
   struct symbol *sym;
 
   if (stabs)
   struct symbol *sym;
 
   if (stabs)
@@ -399,9 +426,8 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
              sym = allocate_symbol (objfile);
              SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
              SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
              sym = allocate_symbol (objfile);
              SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
              SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
-             SYMBOL_SET_LINKAGE_NAME
-               (sym, obstack_copy0 (&objfile->objfile_obstack,
-                                    name, pp - name));
+             sym->set_linkage_name
+               (obstack_strndup (&objfile->objfile_obstack, name, pp - name));
              pp += 2;
              if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
                {
              pp += 2;
              if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
                {
@@ -415,7 +441,7 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
                {
                  SYMBOL_TYPE (sym) = read_type (&pp, objfile);
                }
                {
                  SYMBOL_TYPE (sym) = read_type (&pp, objfile);
                }
-             add_symbol_to_list (sym, &global_symbols);
+             add_symbol_to_list (sym, get_global_symbols ());
            }
          else
            {
            }
          else
            {
@@ -444,7 +470,7 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
    Returns 0 for success, -1 for error.  */
 
 static int
    Returns 0 for success, -1 for error.  */
 
 static int
-read_type_number (char **pp, int *typenums)
+read_type_number (const char **pp, int *typenums)
 {
   int nbits;
 
 {
   int nbits;
 
@@ -479,7 +505,7 @@ read_type_number (char **pp, int *typenums)
 
 struct ref_map
 {
 
 struct ref_map
 {
-  char *stabs;
+  const char *stabs;
   CORE_ADDR value;
   struct symbol *sym;
 };
   CORE_ADDR value;
   struct symbol *sym;
 };
@@ -511,7 +537,7 @@ stabsread_clear_cache (void)
    find them, using their reference numbers as our index.
    These will be used later when we resolve references.  */
 void
    find them, using their reference numbers as our index.
    These will be used later when we resolve references.  */
 void
-ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value)
+ref_add (int refnum, struct symbol *sym, const char *stabs, CORE_ADDR value)
 {
   if (ref_count == 0)
     ref_chunk = 0;
 {
   if (ref_count == 0)
     ref_chunk = 0;
@@ -546,9 +572,9 @@ ref_search (int refnum)
    reference number.  Move STRING beyond the reference id.  */
 
 static int
    reference number.  Move STRING beyond the reference id.  */
 
 static int
-process_reference (char **string)
+process_reference (const char **string)
 {
 {
-  char *p;
+  const char *p;
   int refnum = 0;
 
   if (**string != '#')
   int refnum = 0;
 
   if (**string != '#')
@@ -571,9 +597,9 @@ process_reference (char **string)
    definition for later use.  Return the reference number.  */
 
 int
    definition for later use.  Return the reference number.  */
 
 int
-symbol_reference_defined (char **string)
+symbol_reference_defined (const char **string)
 {
 {
-  char *p = *string;
+  const char *p = *string;
   int refnum = 0;
 
   refnum = process_reference (&p);
   int refnum = 0;
 
   refnum = process_reference (&p);
@@ -599,13 +625,10 @@ stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
 {
   int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
 
 {
   int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
 
-  if (regno >= gdbarch_num_regs (gdbarch)
-               + gdbarch_num_pseudo_regs (gdbarch))
+  if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
     {
     {
-      reg_value_complaint (regno,
-                          gdbarch_num_regs (gdbarch)
-                            + gdbarch_num_pseudo_regs (gdbarch),
-                          SYMBOL_PRINT_NAME (sym));
+      reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
+                          sym->print_name ());
 
       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
     }
 
       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
     }
@@ -623,16 +646,15 @@ static int stab_register_index;
 static int stab_regparm_index;
 
 struct symbol *
 static int stab_regparm_index;
 
 struct symbol *
-define_symbol (CORE_ADDR valu, char *string, int desc, int type,
+define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
               struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct symbol *sym;
               struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct symbol *sym;
-  char *p = (char *) find_name_end (string);
+  const char *p = find_name_end (string);
   int deftype;
   int synonym = 0;
   int i;
   int deftype;
   int synonym = 0;
   int i;
-  char *new_name = NULL;
 
   /* We would like to eliminate nameless symbols, but keep their types.
      E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
 
   /* We would like to eliminate nameless symbols, but keep their types.
      E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
@@ -655,7 +677,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       p = strchr (p, ':');
       if (p == NULL)
        {
       p = strchr (p, ':');
       if (p == NULL)
        {
-         complaint (&symfile_complaints, 
+         complaint (
                     _("Bad stabs string '%s'"), string);
          return NULL;
        }
                     _("Bad stabs string '%s'"), string);
          return NULL;
        }
@@ -678,20 +700,23 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_LINE (sym) = 0;   /* unknown */
     }
 
       SYMBOL_LINE (sym) = 0;   /* unknown */
     }
 
+  SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
+                      &objfile->objfile_obstack);
+
   if (is_cplus_marker (string[0]))
     {
       /* Special GNU C++ names.  */
       switch (string[1])
        {
        case 't':
   if (is_cplus_marker (string[0]))
     {
       /* Special GNU C++ names.  */
       switch (string[1])
        {
        case 't':
-         SYMBOL_SET_LINKAGE_NAME (sym, "this");
+         sym->set_linkage_name ("this");
          break;
 
        case 'v':               /* $vtbl_ptr_type */
          goto normal;
 
        case 'e':
          break;
 
        case 'v':               /* $vtbl_ptr_type */
          goto normal;
 
        case 'e':
-         SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
+         sym->set_linkage_name ("eh_throw");
          break;
 
        case '_':
          break;
 
        case '_':
@@ -702,10 +727,10 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          /* SunPRO (3.0 at least) static variable encoding.  */
          if (gdbarch_static_transform_name_p (gdbarch))
            goto normal;
          /* SunPRO (3.0 at least) static variable encoding.  */
          if (gdbarch_static_transform_name_p (gdbarch))
            goto normal;
-         /* ... fall through ...  */
+         /* fall through */
 
        default:
 
        default:
-         complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
+         complaint (_("Unknown C++ symbol name `%s'"),
                     string);
          goto normal;          /* Do *something* with it.  */
        }
                     string);
          goto normal;          /* Do *something* with it.  */
        }
@@ -713,26 +738,29 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
   else
     {
     normal:
   else
     {
     normal:
-      SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
-                          &objfile->objfile_obstack);
-      if (SYMBOL_LANGUAGE (sym) == language_cplus)
+      std::string new_name;
+
+      if (sym->language () == language_cplus)
        {
        {
-         char *name = alloca (p - string + 1);
+         char *name = (char *) alloca (p - string + 1);
 
          memcpy (name, string, p - string);
          name[p - string] = '\0';
          new_name = cp_canonicalize_string (name);
        }
 
          memcpy (name, string, p - string);
          name[p - string] = '\0';
          new_name = cp_canonicalize_string (name);
        }
-      if (new_name != NULL)
+      if (!new_name.empty ())
        {
        {
-         SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile);
-         xfree (new_name);
+         SYMBOL_SET_NAMES (sym,
+                           new_name,
+                           1, objfile);
        }
       else
        }
       else
-       SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
+       SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true,
+                         objfile);
 
 
-      if (SYMBOL_LANGUAGE (sym) == language_cplus)
-       cp_scan_for_anonymous_namespaces (sym, objfile);
+      if (sym->language () == language_cplus)
+       cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
+                                         objfile);
 
     }
   p++;
 
     }
   p++;
@@ -768,7 +796,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
          SYMBOL_TYPE (sym) = error_type (&p, objfile);
          SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
          SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
          SYMBOL_TYPE (sym) = error_type (&p, objfile);
          SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-         add_symbol_to_list (sym, &file_symbols);
+         add_symbol_to_list (sym, get_file_symbols ());
          return sym;
        }
       ++p;
          return sym;
        }
       ++p;
@@ -776,19 +804,15 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
        {
        case 'r':
          {
        {
        case 'r':
          {
-           double d = atof (p);
            gdb_byte *dbl_valu;
            struct type *dbl_type;
 
            gdb_byte *dbl_valu;
            struct type *dbl_type;
 
-           /* FIXME-if-picky-about-floating-accuracy: Should be using
-              target arithmetic to get the value.  real.c in GCC
-              probably has the necessary code.  */
-
            dbl_type = objfile_type (objfile)->builtin_double;
            dbl_type = objfile_type (objfile)->builtin_double;
-           dbl_valu =
-             obstack_alloc (&objfile->objfile_obstack,
-                            TYPE_LENGTH (dbl_type));
-           store_typed_floating (dbl_valu, dbl_type, d);
+           dbl_valu
+             = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
+                                           TYPE_LENGTH (dbl_type));
+
+           target_float_from_string (dbl_valu, dbl_type, std::string (p));
 
            SYMBOL_TYPE (sym) = dbl_type;
            SYMBOL_VALUE_BYTES (sym) = dbl_valu;
 
            SYMBOL_TYPE (sym) = dbl_type;
            SYMBOL_VALUE_BYTES (sym) = dbl_valu;
@@ -831,7 +855,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
                SYMBOL_TYPE (sym) = error_type (&p, objfile);
                SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
                SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
                SYMBOL_TYPE (sym) = error_type (&p, objfile);
                SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-               add_symbol_to_list (sym, &file_symbols);
+               add_symbol_to_list (sym, get_file_symbols ());
                return sym;
              }
 
                return sym;
              }
 
@@ -856,20 +880,21 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
                SYMBOL_TYPE (sym) = error_type (&p, objfile);
                SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
                SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
                SYMBOL_TYPE (sym) = error_type (&p, objfile);
                SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-               add_symbol_to_list (sym, &file_symbols);
+               add_symbol_to_list (sym, get_file_symbols ());
                return sym;
              }
 
            /* NULL terminate the string.  */
            string_local[ind] = 0;
            range_type
                return sym;
              }
 
            /* NULL terminate the string.  */
            string_local[ind] = 0;
            range_type
-             = create_range_type (NULL,
-                                  objfile_type (objfile)->builtin_int,
-                                  0, ind);
+             = create_static_range_type (NULL,
+                                         objfile_type (objfile)->builtin_int,
+                                         0, ind);
            SYMBOL_TYPE (sym) = create_array_type (NULL,
                                  objfile_type (objfile)->builtin_char,
                                  range_type);
            SYMBOL_TYPE (sym) = create_array_type (NULL,
                                  objfile_type (objfile)->builtin_char,
                                  range_type);
-           string_value = obstack_alloc (&objfile->objfile_obstack, ind + 1);
+           string_value
+             = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
            memcpy (string_value, string_local, ind + 1);
            p++;
 
            memcpy (string_value, string_local, ind + 1);
            p++;
 
@@ -910,7 +935,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
          }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
       return sym;
 
     case 'C':
       return sym;
 
     case 'C':
@@ -918,8 +943,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      SYMBOL_VALUE_ADDRESS (sym) = valu;
-      add_symbol_to_list (sym, &local_symbols);
+      SET_SYMBOL_VALUE_ADDRESS (sym, valu);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'f':
       break;
 
     case 'f':
@@ -927,7 +952,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
       /* fall into process_function_types.  */
 
     process_function_types:
       /* fall into process_function_types.  */
 
     process_function_types:
@@ -954,7 +979,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          struct type *ftype = SYMBOL_TYPE (sym);
          int nsemi = 0;
          int nparams = 0;
          struct type *ftype = SYMBOL_TYPE (sym);
          int nsemi = 0;
          int nparams = 0;
-         char *p1 = p;
+         const char *p1 = p;
 
          /* Obtain a worst case guess for the number of arguments
             by counting the semicolons.  */
 
          /* Obtain a worst case guess for the number of arguments
             by counting the semicolons.  */
@@ -998,7 +1023,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &global_symbols);
+      add_symbol_to_list (sym, get_global_symbols ());
       goto process_function_types;
 
     case 'G':
       goto process_function_types;
 
     case 'G':
@@ -1013,13 +1038,13 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          Symbol references don't have valid names and wont't match up with
          minimal symbols when the global_sym_chain is relocated.
          We'll fixup symbol references when we fixup the defining symbol.  */
          Symbol references don't have valid names and wont't match up with
          minimal symbols when the global_sym_chain is relocated.
          We'll fixup symbol references when we fixup the defining symbol.  */
-      if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
+      if (sym->linkage_name () && sym->linkage_name ()[0] != '#')
        {
        {
-         i = hashname (SYMBOL_LINKAGE_NAME (sym));
+         i = hashname (sym->linkage_name ());
          SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
          global_sym_chain[i] = sym;
        }
          SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
          global_sym_chain[i] = sym;
        }
-      add_symbol_to_list (sym, &global_symbols);
+      add_symbol_to_list (sym, get_global_symbols ());
       break;
 
       /* This case is faked by a conditional above,
       break;
 
       /* This case is faked by a conditional above,
@@ -1031,7 +1056,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'p':
       break;
 
     case 'p':
@@ -1052,7 +1077,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_IS_ARGUMENT (sym) = 1;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
 
       if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
        {
 
       if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
        {
@@ -1081,6 +1106,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
            }
          break;
        }
            }
          break;
        }
+      /* Fall through.  */
 
     case 'P':
       /* acc seems to use P to declare the prototypes of functions that
 
     case 'P':
       /* acc seems to use P to declare the prototypes of functions that
@@ -1100,7 +1126,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'r':
       break;
 
     case 'r':
@@ -1115,8 +1141,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
             the same name to represent an argument passed in a
             register.  GCC uses 'P' for the same case.  So if we find
             such a symbol pair we combine it into one 'P' symbol.
             the same name to represent an argument passed in a
             register.  GCC uses 'P' for the same case.  So if we find
             such a symbol pair we combine it into one 'P' symbol.
-            For Sun cc we need to do this regardless of
-            stabs_argument_has_addr, because the compiler puts out
+            For Sun cc we need to do this regardless of stabs_argument_has_addr, because the compiler puts out
             the 'p' symbol even if it never saves the argument onto
             the stack.
 
             the 'p' symbol even if it never saves the argument onto
             the stack.
 
@@ -1131,6 +1156,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
             but this case is considered pathological and causes a warning
             from a decent compiler.  */
 
             but this case is considered pathological and causes a warning
             from a decent compiler.  */
 
+         struct pending *local_symbols = *get_local_symbols ();
          if (local_symbols
              && local_symbols->nsyms > 0
              && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
          if (local_symbols
              && local_symbols->nsyms > 0
              && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
@@ -1140,8 +1166,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
              prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
              if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
                   || SYMBOL_CLASS (prev_sym) == LOC_ARG)
              prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
              if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
                   || SYMBOL_CLASS (prev_sym) == LOC_ARG)
-                 && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
-                            SYMBOL_LINKAGE_NAME (sym)) == 0)
+                 && strcmp (prev_sym->linkage_name (),
+                            sym->linkage_name ()) == 0)
                {
                  SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
                  /* Use the type from the LOC_REGISTER; that is the type
                {
                  SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
                  /* Use the type from the LOC_REGISTER; that is the type
@@ -1152,37 +1178,36 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                  break;
                }
            }
                  break;
                }
            }
-         add_symbol_to_list (sym, &local_symbols);
+         add_symbol_to_list (sym, get_local_symbols ());
        }
       else
        }
       else
-       add_symbol_to_list (sym, &file_symbols);
+       add_symbol_to_list (sym, get_file_symbols ());
       break;
 
     case 'S':
       /* Static symbol at top level of file.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
       break;
 
     case 'S':
       /* Static symbol at top level of file.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
-      SYMBOL_VALUE_ADDRESS (sym) = valu;
+      SET_SYMBOL_VALUE_ADDRESS (sym, valu);
       if (gdbarch_static_transform_name_p (gdbarch)
       if (gdbarch_static_transform_name_p (gdbarch)
-         && gdbarch_static_transform_name (gdbarch,
-                                           SYMBOL_LINKAGE_NAME (sym))
-            != SYMBOL_LINKAGE_NAME (sym))
+         && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+            != sym->linkage_name ())
        {
        {
-         struct minimal_symbol *msym;
+         struct bound_minimal_symbol msym;
 
 
-         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
-                                       NULL, objfile);
-         if (msym != NULL)
+         msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
+         if (msym.minsym != NULL)
            {
              const char *new_name = gdbarch_static_transform_name
            {
              const char *new_name = gdbarch_static_transform_name
-               (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+               (gdbarch, sym->linkage_name ());
 
 
-             SYMBOL_SET_LINKAGE_NAME (sym, new_name);
-             SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+             sym->set_linkage_name (new_name);
+             SET_SYMBOL_VALUE_ADDRESS (sym,
+                                       BMSYMBOL_VALUE_ADDRESS (msym));
            }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
            }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
       break;
 
     case 't':
       break;
 
     case 't':
@@ -1200,7 +1225,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          This is important to do, because of forward references:
          The cleanup of undefined types stored in undef_types only uses
          STRUCT_DOMAIN symbols to perform the replacement.  */
          This is important to do, because of forward references:
          The cleanup of undefined types stored in undef_types only uses
          STRUCT_DOMAIN symbols to perform the replacement.  */
-      synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
+      synonym = (sym->language () == language_ada && p[-2] != 'T');
 
       /* Typedef */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
 
       /* Typedef */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
@@ -1227,18 +1252,13 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
            for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
              if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
                TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
            for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
              if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
                TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
-                 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
+                 TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
          }
 
       if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
        {
          }
 
       if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
        {
-         /* gcc-2.6 or later (when using -fvtable-thunks)
-            emits a unique named type for a vtable entry.
-            Some gdb code depends on that specific name.  */
-         extern const char vtbl_ptr_name[];
-
          if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
          if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
-              && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
+              && strcmp (sym->linkage_name (), vtbl_ptr_name))
              || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
            {
              /* If we are giving a name to a type such as "pointer to
              || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
            {
              /* If we are giving a name to a type such as "pointer to
@@ -1277,16 +1297,16 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                 */
 
              /* Pascal accepts names for pointer types.  */
                 */
 
              /* Pascal accepts names for pointer types.  */
-             if (current_subfile->language == language_pascal)
+             if (get_current_subfile ()->language == language_pascal)
                {
                {
-                 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
+                 TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
                }
            }
          else
                }
            }
          else
-           TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
+           TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
        }
 
        }
 
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
 
       if (synonym)
         {
 
       if (synonym)
         {
@@ -1299,10 +1319,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
           SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
             TYPE_NAME (SYMBOL_TYPE (sym))
           SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
             TYPE_NAME (SYMBOL_TYPE (sym))
-             = obconcat (&objfile->objfile_obstack,
-                         SYMBOL_LINKAGE_NAME (sym),
+             = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                          (char *) NULL);
                          (char *) NULL);
-          add_symbol_to_list (struct_sym, &file_symbols);
+          add_symbol_to_list (struct_sym, get_file_symbols ());
         }
       
       break;
         }
       
       break;
@@ -1325,12 +1344,11 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
       SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
-      if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
-       TYPE_TAG_NAME (SYMBOL_TYPE (sym))
-         = obconcat (&objfile->objfile_obstack,
-                     SYMBOL_LINKAGE_NAME (sym),
+      if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+       TYPE_NAME (SYMBOL_TYPE (sym))
+         = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                      (char *) NULL);
                      (char *) NULL);
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
 
       if (synonym)
        {
 
       if (synonym)
        {
@@ -1343,10 +1361,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
          if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
            TYPE_NAME (SYMBOL_TYPE (sym))
          SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
          if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
            TYPE_NAME (SYMBOL_TYPE (sym))
-             = obconcat (&objfile->objfile_obstack,
-                         SYMBOL_LINKAGE_NAME (sym),
+             = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
                          (char *) NULL);
                          (char *) NULL);
-         add_symbol_to_list (typedef_sym, &file_symbols);
+         add_symbol_to_list (typedef_sym, get_file_symbols ());
        }
       break;
 
        }
       break;
 
@@ -1354,27 +1371,25 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       /* Static symbol of local scope.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
       /* Static symbol of local scope.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
-      SYMBOL_VALUE_ADDRESS (sym) = valu;
+      SET_SYMBOL_VALUE_ADDRESS (sym, valu);
       if (gdbarch_static_transform_name_p (gdbarch)
       if (gdbarch_static_transform_name_p (gdbarch)
-         && gdbarch_static_transform_name (gdbarch,
-                                           SYMBOL_LINKAGE_NAME (sym))
-            != SYMBOL_LINKAGE_NAME (sym))
+         && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+            != sym->linkage_name ())
        {
        {
-         struct minimal_symbol *msym;
+         struct bound_minimal_symbol msym;
 
 
-         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), 
-                                       NULL, objfile);
-         if (msym != NULL)
+         msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
+         if (msym.minsym != NULL)
            {
              const char *new_name = gdbarch_static_transform_name
            {
              const char *new_name = gdbarch_static_transform_name
-               (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+               (gdbarch, sym->linkage_name ());
 
 
-             SYMBOL_SET_LINKAGE_NAME (sym, new_name);
-             SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
+             sym->set_linkage_name (new_name);
+             SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
            }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
            }
        }
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-       add_symbol_to_list (sym, &local_symbols);
+       add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'v':
       break;
 
     case 'v':
@@ -1384,7 +1399,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'a':
       break;
 
     case 'a':
@@ -1394,7 +1409,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     case 'X':
       break;
 
     case 'X':
@@ -1406,7 +1421,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &local_symbols);
+      add_symbol_to_list (sym, get_local_symbols ());
       break;
 
     default:
       break;
 
     default:
@@ -1414,7 +1429,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_VALUE (sym) = 0;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_VALUE (sym) = 0;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-      add_symbol_to_list (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
       break;
     }
 
       break;
     }
 
@@ -1468,10 +1483,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
    debugger will be able to read the new symbol tables.  */
 
 static struct type *
    debugger will be able to read the new symbol tables.  */
 
 static struct type *
-error_type (char **pp, struct objfile *objfile)
+error_type (const char **pp, struct objfile *objfile)
 {
 {
-  complaint (&symfile_complaints,
-            _("couldn't parse type; debugger out of date?"));
+  complaint (_("couldn't parse type; debugger out of date?"));
   while (1)
     {
       /* Skip to end of symbol.  */
   while (1)
     {
       /* Skip to end of symbol.  */
@@ -1501,7 +1515,7 @@ error_type (char **pp, struct objfile *objfile)
    deciding whether to call read_type.  */
 
 static struct type *
    deciding whether to call read_type.  */
 
 static struct type *
-read_type (char **pp, struct objfile *objfile)
+read_type (const char **pp, struct objfile *objfile)
 {
   struct type *type = 0;
   struct type *type1;
 {
   struct type *type = 0;
   struct type *type1;
@@ -1573,7 +1587,7 @@ again:
        char *type_name;
 
        {
        char *type_name;
 
        {
-         char *from, *to, *p, *q1, *q2;
+         const char *from, *p, *q1, *q2;
 
          /* Set the type code according to the following letter.  */
          switch ((*pp)[0])
 
          /* Set the type code according to the following letter.  */
          switch ((*pp)[0])
@@ -1591,8 +1605,7 @@ again:
              {
                /* Complain and keep going, so compilers can invent new
                   cross-reference types.  */
              {
                /* Complain and keep going, so compilers can invent new
                   cross-reference types.  */
-               complaint (&symfile_complaints,
-                          _("Unrecognized cross-reference type `%c'"),
+               complaint (_("Unrecognized cross-reference type `%c'"),
                           (*pp)[0]);
                code = TYPE_CODE_STRUCT;
                break;
                           (*pp)[0]);
                code = TYPE_CODE_STRUCT;
                break;
@@ -1621,23 +1634,21 @@ again:
                return error_type (pp, objfile);
            }
          type_name = NULL;
                return error_type (pp, objfile);
            }
          type_name = NULL;
-         if (current_subfile->language == language_cplus)
+         if (get_current_subfile ()->language == language_cplus)
            {
            {
-             char *new_name, *name = alloca (p - *pp + 1);
+             char *name = (char *) alloca (p - *pp + 1);
 
              memcpy (name, *pp, p - *pp);
              name[p - *pp] = '\0';
 
              memcpy (name, *pp, p - *pp);
              name[p - *pp] = '\0';
-             new_name = cp_canonicalize_string (name);
-             if (new_name != NULL)
-               {
-                 type_name = obstack_copy0 (&objfile->objfile_obstack,
-                                            new_name, strlen (new_name));
-                 xfree (new_name);
-               }
+
+             std::string new_name = cp_canonicalize_string (name);
+             if (!new_name.empty ())
+               type_name = obstack_strdup (&objfile->objfile_obstack,
+                                           new_name);
            }
          if (type_name == NULL)
            {
            }
          if (type_name == NULL)
            {
-             to = type_name = (char *)
+             char *to = type_name = (char *)
                obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
 
              /* Copy the name.  */
                obstack_alloc (&objfile->objfile_obstack, p - *pp + 1);
 
              /* Copy the name.  */
@@ -1656,7 +1667,7 @@ again:
            type, rather than allocating a new one.  This saves some
            memory.  */
 
            type, rather than allocating a new one.  This saves some
            memory.  */
 
-       for (ppt = file_symbols; ppt; ppt = ppt->next)
+       for (ppt = *get_file_symbols (); ppt; ppt = ppt->next)
          for (i = 0; i < ppt->nsyms; i++)
            {
              struct symbol *sym = ppt->symbol[i];
          for (i = 0; i < ppt->nsyms; i++)
            {
              struct symbol *sym = ppt->symbol[i];
@@ -1664,7 +1675,7 @@ again:
              if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                  && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
                  && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
              if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                  && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
                  && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
-                 && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
+                 && strcmp (sym->linkage_name (), type_name) == 0)
                {
                  obstack_free (&objfile->objfile_obstack, type_name);
                  type = SYMBOL_TYPE (sym);
                {
                  obstack_free (&objfile->objfile_obstack, type_name);
                  type = SYMBOL_TYPE (sym);
@@ -1681,7 +1692,7 @@ again:
           type.  */
        type = dbx_alloc_type (typenums, objfile);
        TYPE_CODE (type) = code;
           type.  */
        type = dbx_alloc_type (typenums, objfile);
        TYPE_CODE (type) = code;
-       TYPE_TAG_NAME (type) = type_name;
+       TYPE_NAME (type) = type_name;
        INIT_CPLUS_SPECIFIC (type);
        TYPE_STUB (type) = 1;
 
        INIT_CPLUS_SPECIFIC (type);
        TYPE_STUB (type) = 1;
 
@@ -1746,7 +1757,6 @@ again:
                copies of a type otherwise.  */
            replace_type (type, xtype);
            TYPE_NAME (type) = NULL;
                copies of a type otherwise.  */
            replace_type (type, xtype);
            TYPE_NAME (type) = NULL;
-           TYPE_TAG_NAME (type) = NULL;
          }
        else
          {
          }
        else
          {
@@ -1770,7 +1780,8 @@ again:
 
     case '&':                  /* Reference to another type */
       type1 = read_type (pp, objfile);
 
     case '&':                  /* Reference to another type */
       type1 = read_type (pp, objfile);
-      type = make_reference_type (type1, dbx_lookup_type (typenums, objfile));
+      type = make_reference_type (type1, dbx_lookup_type (typenums, objfile),
+                                  TYPE_CODE_REF);
       break;
 
     case 'f':                  /* Function returning another type */
       break;
 
     case 'f':                  /* Function returning another type */
@@ -1809,18 +1820,17 @@ again:
         while (**pp && **pp != '#')
           {
             struct type *arg_type = read_type (pp, objfile);
         while (**pp && **pp != '#')
           {
             struct type *arg_type = read_type (pp, objfile);
-            struct type_list *new = alloca (sizeof (*new));
-            new->type = arg_type;
-            new->next = arg_types;
-            arg_types = new;
+            struct type_list *newobj = XALLOCA (struct type_list);
+            newobj->type = arg_type;
+            newobj->next = arg_types;
+            arg_types = newobj;
             num_args++;
           }
         if (**pp == '#')
           ++*pp;
         else
           {
             num_args++;
           }
         if (**pp == '#')
           ++*pp;
         else
           {
-           complaint (&symfile_complaints,
-                      _("Prototyped function type didn't "
+           complaint (_("Prototyped function type didn't "
                         "end arguments with `#':\n%s"),
                       type_start);
           }
                         "end arguments with `#':\n%s"),
                       type_start);
           }
@@ -1885,7 +1895,7 @@ again:
       else
        /* type attribute */
        {
       else
        /* type attribute */
        {
-         char *attr = *pp;
+         const char *attr = *pp;
 
          /* Skip to the semicolon.  */
          while (**pp != ';' && **pp != '\0')
 
          /* Skip to the semicolon.  */
          while (**pp != ';' && **pp != '\0')
@@ -1932,8 +1942,7 @@ again:
          (*pp)++;
          return_type = read_type (pp, objfile);
          if (*(*pp)++ != ';')
          (*pp)++;
          return_type = read_type (pp, objfile);
          if (*(*pp)++ != ';')
-           complaint (&symfile_complaints,
-                      _("invalid (minimal) member type "
+           complaint (_("invalid (minimal) member type "
                         "data format at symtab pos %d."),
                       symnum);
          type = allocate_stub_method (return_type);
                         "data format at symtab pos %d."),
                       symnum);
          type = allocate_stub_method (return_type);
@@ -2024,7 +2033,7 @@ again:
 
     case 'S':                  /* Set type */
       type1 = read_type (pp, objfile);
 
     case 'S':                  /* Set type */
       type1 = read_type (pp, objfile);
-      type = create_set_type ((struct type *) NULL, type1);
+      type = create_set_type (NULL, type1);
       if (typenums[0] != -1)
        *dbx_lookup_type (typenums, objfile) = type;
       break;
       if (typenums[0] != -1)
        *dbx_lookup_type (typenums, objfile) = type;
       break;
@@ -2051,13 +2060,14 @@ again:
 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
    Return the proper type node for a given builtin type number.  */
 
 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
    Return the proper type node for a given builtin type number.  */
 
-static const struct objfile_data *rs6000_builtin_type_data;
+static const struct objfile_key<struct type *,
+                               gdb::noop_deleter<struct type *>>
+  rs6000_builtin_type_data;
 
 static struct type *
 rs6000_builtin_type (int typenum, struct objfile *objfile)
 {
 
 static struct type *
 rs6000_builtin_type (int typenum, struct objfile *objfile)
 {
-  struct type **negative_types = objfile_data (objfile,
-                                              rs6000_builtin_type_data);
+  struct type **negative_types = rs6000_builtin_type_data.get (objfile);
 
   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
 #define NUMBER_RECOGNIZED 34
 
   /* We recognize types numbered from -NUMBER_RECOGNIZED to -1.  */
 #define NUMBER_RECOGNIZED 34
@@ -2065,7 +2075,7 @@ rs6000_builtin_type (int typenum, struct objfile *objfile)
 
   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
     {
 
   if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
     {
-      complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum);
+      complaint (_("Unknown builtin type %d"), typenum);
       return objfile_type (objfile)->builtin_error;
     }
 
       return objfile_type (objfile)->builtin_error;
     }
 
@@ -2074,7 +2084,7 @@ rs6000_builtin_type (int typenum, struct objfile *objfile)
       /* This includes an empty slot for type number -0.  */
       negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
                                       NUMBER_RECOGNIZED + 1, struct type *);
       /* This includes an empty slot for type number -0.  */
       negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack,
                                       NUMBER_RECOGNIZED + 1, struct type *);
-      set_objfile_data (objfile, rs6000_builtin_type_data, negative_types);
+      rs6000_builtin_type_data.set (objfile, negative_types);
     }
 
   if (negative_types[-typenum] != NULL)
     }
 
   if (negative_types[-typenum] != NULL)
@@ -2096,130 +2106,121 @@ rs6000_builtin_type (int typenum, struct objfile *objfile)
          is other than 32 bits, then it should use a new negative type
          number (or avoid negative type numbers for that case).
          See stabs.texinfo.  */
          is other than 32 bits, then it should use a new negative type
          number (or avoid negative type numbers for that case).
          See stabs.texinfo.  */
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile);
+      rettype = init_integer_type (objfile, 32, 0, "int");
       break;
     case 2:
       break;
     case 2:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile);
+      rettype = init_integer_type (objfile, 8, 0, "char");
+      TYPE_NOSIGN (rettype) = 1;
       break;
     case 3:
       break;
     case 3:
-      rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile);
+      rettype = init_integer_type (objfile, 16, 0, "short");
       break;
     case 4:
       break;
     case 4:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile);
+      rettype = init_integer_type (objfile, 32, 0, "long");
       break;
     case 5:
       break;
     case 5:
-      rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED,
-                          "unsigned char", objfile);
+      rettype = init_integer_type (objfile, 8, 1, "unsigned char");
       break;
     case 6:
       break;
     case 6:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile);
+      rettype = init_integer_type (objfile, 8, 0, "signed char");
       break;
     case 7:
       break;
     case 7:
-      rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED,
-                          "unsigned short", objfile);
+      rettype = init_integer_type (objfile, 16, 1, "unsigned short");
       break;
     case 8:
       break;
     case 8:
-      rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned int", objfile);
+      rettype = init_integer_type (objfile, 32, 1, "unsigned int");
       break;
     case 9:
       break;
     case 9:
-      rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned", objfile);
+      rettype = init_integer_type (objfile, 32, 1, "unsigned");
       break;
     case 10:
       break;
     case 10:
-      rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED,
-                          "unsigned long", objfile);
+      rettype = init_integer_type (objfile, 32, 1, "unsigned long");
       break;
     case 11:
       break;
     case 11:
-      rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile);
+      rettype = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
       break;
     case 12:
       /* IEEE single precision (32 bit).  */
       break;
     case 12:
       /* IEEE single precision (32 bit).  */
-      rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile);
+      rettype = init_float_type (objfile, 32, "float",
+                                floatformats_ieee_single);
       break;
     case 13:
       /* IEEE double precision (64 bit).  */
       break;
     case 13:
       /* IEEE double precision (64 bit).  */
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile);
+      rettype = init_float_type (objfile, 64, "double",
+                                floatformats_ieee_double);
       break;
     case 14:
       /* This is an IEEE double on the RS/6000, and different machines with
          different sizes for "long double" should use different negative
          type numbers.  See stabs.texinfo.  */
       break;
     case 14:
       /* This is an IEEE double on the RS/6000, and different machines with
          different sizes for "long double" should use different negative
          type numbers.  See stabs.texinfo.  */
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile);
+      rettype = init_float_type (objfile, 64, "long double",
+                                floatformats_ieee_double);
       break;
     case 15:
       break;
     case 15:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile);
+      rettype = init_integer_type (objfile, 32, 0, "integer");
       break;
     case 16:
       break;
     case 16:
-      rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "boolean", objfile);
+      rettype = init_boolean_type (objfile, 32, 1, "boolean");
       break;
     case 17:
       break;
     case 17:
-      rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile);
+      rettype = init_float_type (objfile, 32, "short real",
+                                floatformats_ieee_single);
       break;
     case 18:
       break;
     case 18:
-      rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile);
+      rettype = init_float_type (objfile, 64, "real",
+                                floatformats_ieee_double);
       break;
     case 19:
       break;
     case 19:
-      rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile);
+      rettype = init_type (objfile, TYPE_CODE_ERROR, 0, "stringptr");
       break;
     case 20:
       break;
     case 20:
-      rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED,
-                          "character", objfile);
+      rettype = init_character_type (objfile, 8, 1, "character");
       break;
     case 21:
       break;
     case 21:
-      rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED,
-                          "logical*1", objfile);
+      rettype = init_boolean_type (objfile, 8, 1, "logical*1");
       break;
     case 22:
       break;
     case 22:
-      rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED,
-                          "logical*2", objfile);
+      rettype = init_boolean_type (objfile, 16, 1, "logical*2");
       break;
     case 23:
       break;
     case 23:
-      rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "logical*4", objfile);
+      rettype = init_boolean_type (objfile, 32, 1, "logical*4");
       break;
     case 24:
       break;
     case 24:
-      rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED,
-                          "logical", objfile);
+      rettype = init_boolean_type (objfile, 32, 1, "logical");
       break;
     case 25:
       /* Complex type consisting of two IEEE single precision values.  */
       break;
     case 25:
       /* Complex type consisting of two IEEE single precision values.  */
-      rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile);
-      TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float",
-                                             objfile);
+      rettype = init_complex_type (objfile, "complex",
+                                  rs6000_builtin_type (12, objfile));
       break;
     case 26:
       /* Complex type consisting of two IEEE double precision values.  */
       break;
     case 26:
       /* Complex type consisting of two IEEE double precision values.  */
-      rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL);
-      TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double",
-                                             objfile);
+      rettype = init_complex_type (objfile, "double complex",
+                                  rs6000_builtin_type (13, objfile));
       break;
     case 27:
       break;
     case 27:
-      rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile);
+      rettype = init_integer_type (objfile, 8, 0, "integer*1");
       break;
     case 28:
       break;
     case 28:
-      rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile);
+      rettype = init_integer_type (objfile, 16, 0, "integer*2");
       break;
     case 29:
       break;
     case 29:
-      rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile);
+      rettype = init_integer_type (objfile, 32, 0, "integer*4");
       break;
     case 30:
       break;
     case 30:
-      rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile);
+      rettype = init_character_type (objfile, 16, 0, "wchar");
       break;
     case 31:
       break;
     case 31:
-      rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile);
+      rettype = init_integer_type (objfile, 64, 0, "long long");
       break;
     case 32:
       break;
     case 32:
-      rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
-                          "unsigned long long", objfile);
+      rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
       break;
     case 33:
       break;
     case 33:
-      rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED,
-                          "logical*8", objfile);
+      rettype = init_integer_type (objfile, 64, 1, "logical*8");
       break;
     case 34:
       break;
     case 34:
-      rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile);
+      rettype = init_integer_type (objfile, 64, 0, "integer*8");
       break;
     }
   negative_types[-typenum] = rettype;
       break;
     }
   negative_types[-typenum] = rettype;
@@ -2240,8 +2241,7 @@ stabs_method_name_from_physname (const char *physname)
 
   if (method_name == NULL)
     {
 
   if (method_name == NULL)
     {
-      complaint (&symfile_complaints,
-                _("Method has bad physname %s\n"), physname);
+      complaint (_("Method has bad physname %s\n"), physname);
       return NULL;
     }
 
       return NULL;
     }
 
@@ -2264,8 +2264,8 @@ stabs_method_name_from_physname (const char *physname)
    Returns 1 for success, 0 for failure.  */
 
 static int
    Returns 1 for success, 0 for failure.  */
 
 static int
-read_member_functions (struct field_info *fip, char **pp, struct type *type,
-                      struct objfile *objfile)
+read_member_functions (struct stab_field_info *fip, const char **pp,
+                      struct type *type, struct objfile *objfile)
 {
   int nfn_fields = 0;
   int length = 0;
 {
   int nfn_fields = 0;
   int length = 0;
@@ -2280,7 +2280,7 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
   struct next_fnfieldlist *new_fnlist;
   struct next_fnfield *new_sublist;
   char *main_fn_name;
   struct next_fnfieldlist *new_fnlist;
   struct next_fnfield *new_sublist;
   char *main_fn_name;
-  char *p;
+  const char *p;
 
   /* Process each list until we find something that is not a member function
      or find the end of the functions.  */
 
   /* Process each list until we find something that is not a member function
      or find the end of the functions.  */
@@ -2304,10 +2304,7 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
       look_ahead_type = NULL;
       length = 0;
 
       look_ahead_type = NULL;
       length = 0;
 
-      new_fnlist = (struct next_fnfieldlist *)
-       xmalloc (sizeof (struct next_fnfieldlist));
-      make_cleanup (xfree, new_fnlist);
-      memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
+      new_fnlist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfieldlist);
 
       if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
        {
 
       if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
        {
@@ -2346,10 +2343,7 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
 
       do
        {
 
       do
        {
-         new_sublist =
-           (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
-         make_cleanup (xfree, new_sublist);
-         memset (new_sublist, 0, sizeof (struct next_fnfield));
+         new_sublist = OBSTACK_ZALLOC (&fip->obstack, struct next_fnfield);
 
          /* Check for and handle cretinous dbx symbol name continuation!  */
          if (look_ahead_type == NULL)
 
          /* Check for and handle cretinous dbx symbol name continuation!  */
          if (look_ahead_type == NULL)
@@ -2378,14 +2372,21 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
              p++;
            }
 
              p++;
            }
 
-         /* If this is just a stub, then we don't have the real name here.  */
+         /* These are methods, not functions.  */
+         if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
+           TYPE_CODE (new_sublist->fn_field.type) = TYPE_CODE_METHOD;
+         else
+           gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
+                       == TYPE_CODE_METHOD);
 
 
+         /* If this is just a stub, then we don't have the real name here.  */
          if (TYPE_STUB (new_sublist->fn_field.type))
            {
          if (TYPE_STUB (new_sublist->fn_field.type))
            {
-             if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type))
-               TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type;
+             if (!TYPE_SELF_TYPE (new_sublist->fn_field.type))
+               set_type_self_type (new_sublist->fn_field.type, type);
              new_sublist->fn_field.is_stub = 1;
            }
              new_sublist->fn_field.is_stub = 1;
            }
+
          new_sublist->fn_field.physname = savestring (*pp, p - *pp);
          *pp = p + 1;
 
          new_sublist->fn_field.physname = savestring (*pp, p - *pp);
          *pp = p + 1;
 
@@ -2429,8 +2430,7 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
            case '.':
              break;
            default:
            case '.':
              break;
            default:
-             complaint (&symfile_complaints,
-                        _("const/volatile indicator missing, got '%c'"),
+             complaint (_("const/volatile indicator missing, got '%c'"),
                         **pp);
              break;
            }
                         **pp);
              break;
            }
@@ -2513,10 +2513,10 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
 
            default:
              /* error */
 
            default:
              /* error */
-             complaint (&symfile_complaints,
-                        _("member function type missing, got '%c'"),
+             complaint (_("member function type missing, got '%c'"),
                         (*pp)[-1]);
                         (*pp)[-1]);
-             /* Fall through into normal member function.  */
+             /* Normal member function.  */
+             /* Fall through.  */
 
            case '.':
              /* normal member function.  */
 
            case '.':
              /* normal member function.  */
@@ -2545,7 +2545,6 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
        }
       else
        {
        }
       else
        {
-         int has_stub = 0;
          int has_destructor = 0, has_other = 0;
          int is_v3 = 0;
          struct next_fnfield *tmp_sublist;
          int has_destructor = 0, has_other = 0;
          int is_v3 = 0;
          struct next_fnfield *tmp_sublist;
@@ -2609,8 +2608,6 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
          tmp_sublist = sublist;
          while (tmp_sublist != NULL)
            {
          tmp_sublist = sublist;
          while (tmp_sublist != NULL)
            {
-             if (tmp_sublist->fn_field.is_stub)
-               has_stub = 1;
              if (tmp_sublist->fn_field.physname[0] == '_'
                  && tmp_sublist->fn_field.physname[1] == 'Z')
                is_v3 = 1;
              if (tmp_sublist->fn_field.physname[0] == '_'
                  && tmp_sublist->fn_field.physname[1] == 'Z')
                is_v3 = 1;
@@ -2630,17 +2627,16 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
 
              /* Create a new fn_fieldlist for the destructors.  */
 
 
              /* Create a new fn_fieldlist for the destructors.  */
 
-             destr_fnlist = (struct next_fnfieldlist *)
-               xmalloc (sizeof (struct next_fnfieldlist));
-             make_cleanup (xfree, destr_fnlist);
-             memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
+             destr_fnlist = OBSTACK_ZALLOC (&fip->obstack,
+                                            struct next_fnfieldlist);
+
              destr_fnlist->fn_fieldlist.name
                = obconcat (&objfile->objfile_obstack, "~",
                            new_fnlist->fn_fieldlist.name, (char *) NULL);
 
              destr_fnlist->fn_fieldlist.name
                = obconcat (&objfile->objfile_obstack, "~",
                            new_fnlist->fn_fieldlist.name, (char *) NULL);
 
-             destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
-               obstack_alloc (&objfile->objfile_obstack,
-                              sizeof (struct fn_field) * has_destructor);
+             destr_fnlist->fn_fieldlist.fn_fields =
+               XOBNEWVEC (&objfile->objfile_obstack,
+                          struct fn_field, has_destructor);
              memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
                  sizeof (struct fn_field) * has_destructor);
              tmp_sublist = sublist;
              memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
                  sizeof (struct fn_field) * has_destructor);
              tmp_sublist = sublist;
@@ -2698,28 +2694,9 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
                          "~", main_fn_name, (char *)NULL);
              xfree (main_fn_name);
            }
                          "~", main_fn_name, (char *)NULL);
              xfree (main_fn_name);
            }
-         else if (!has_stub)
-           {
-             char dem_opname[256];
-             int ret;
-
-             ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
-                                             dem_opname, DMGL_ANSI);
-             if (!ret)
-               ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name,
-                                            dem_opname, 0);
-             if (ret)
-               new_fnlist->fn_fieldlist.name
-                 = obstack_copy0 (&objfile->objfile_obstack,
-                                  dem_opname, strlen (dem_opname));
-             xfree (main_fn_name);
-           }
 
 
-         new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
-           obstack_alloc (&objfile->objfile_obstack,
-                          sizeof (struct fn_field) * length);
-         memset (new_fnlist->fn_fieldlist.fn_fields, 0,
-                 sizeof (struct fn_field) * length);
+         new_fnlist->fn_fieldlist.fn_fields
+           = OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
          for (i = length; (i--, sublist); sublist = sublist->next)
            {
              new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
          for (i = length; (i--, sublist); sublist = sublist->next)
            {
              new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field;
@@ -2751,10 +2728,10 @@ read_member_functions (struct field_info *fip, char **pp, struct type *type,
    keep parsing and it's time for error_type().  */
 
 static int
    keep parsing and it's time for error_type().  */
 
 static int
-read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
-                struct objfile *objfile)
+read_cpp_abbrev (struct stab_field_info *fip, const char **pp,
+                struct type *type, struct objfile *objfile)
 {
 {
-  char *p;
+  const char *p;
   const char *name;
   char cpp_abbrev;
   struct type *context;
   const char *name;
   char cpp_abbrev;
   struct type *context;
@@ -2777,7 +2754,7 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
       switch (cpp_abbrev)
        {
        case 'f':               /* $vf -- a virtual function table pointer */
       switch (cpp_abbrev)
        {
        case 'f':               /* $vf -- a virtual function table pointer */
-         name = type_name_no_tag (context);
+         name = TYPE_NAME (context);
          if (name == NULL)
            {
              name = "";
          if (name == NULL)
            {
              name = "";
@@ -2787,11 +2764,10 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
          break;
 
        case 'b':               /* $vb -- a virtual bsomethingorother */
          break;
 
        case 'b':               /* $vb -- a virtual bsomethingorother */
-         name = type_name_no_tag (context);
+         name = TYPE_NAME (context);
          if (name == NULL)
            {
          if (name == NULL)
            {
-             complaint (&symfile_complaints,
-                        _("C++ abbreviated type name "
+             complaint (_("C++ abbreviated type name "
                           "unknown at symtab pos %d"),
                         symnum);
              name = "FOO";
                           "unknown at symtab pos %d"),
                         symnum);
              name = "FOO";
@@ -2847,13 +2823,14 @@ read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type,
 }
 
 static void
 }
 
 static void
-read_one_struct_field (struct field_info *fip, char **pp, char *p,
-                      struct type *type, struct objfile *objfile)
+read_one_struct_field (struct stab_field_info *fip, const char **pp,
+                      const char *p, struct type *type,
+                      struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
-  fip->list->field.name =
-    obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
+  fip->list->field.name
+    = obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp);
   *pp = p + 1;
 
   /* This means we have a visibility for a field coming.  */
   *pp = p + 1;
 
   /* This means we have a visibility for a field coming.  */
@@ -2990,11 +2967,11 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
    Returns 1 for success, 0 for failure.  */
 
 static int
    Returns 1 for success, 0 for failure.  */
 
 static int
-read_struct_fields (struct field_info *fip, char **pp, struct type *type,
-                   struct objfile *objfile)
+read_struct_fields (struct stab_field_info *fip, const char **pp,
+                   struct type *type, struct objfile *objfile)
 {
 {
-  char *p;
-  struct nextfield *new;
+  const char *p;
+  struct nextfield *newobj;
 
   /* We better set p right now, in case there are no fields at all...    */
 
 
   /* We better set p right now, in case there are no fields at all...    */
 
@@ -3010,11 +2987,10 @@ read_struct_fields (struct field_info *fip, char **pp, struct type *type,
     {
       STABS_CONTINUE (pp, objfile);
       /* Get space to record the next field's data.  */
     {
       STABS_CONTINUE (pp, objfile);
       /* Get space to record the next field's data.  */
-      new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
-      make_cleanup (xfree, new);
-      memset (new, 0, sizeof (struct nextfield));
-      new->next = fip->list;
-      fip->list = new;
+      newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
+
+      newobj->next = fip->list;
+      fip->list = newobj;
 
       /* Get the field name.  */
       p = *pp;
 
       /* Get the field name.  */
       p = *pp;
@@ -3088,11 +3064,11 @@ read_struct_fields (struct field_info *fip, char **pp, struct type *type,
 
 
 static int
 
 
 static int
-read_baseclasses (struct field_info *fip, char **pp, struct type *type,
-                 struct objfile *objfile)
+read_baseclasses (struct stab_field_info *fip, const char **pp,
+                 struct type *type, struct objfile *objfile)
 {
   int i;
 {
   int i;
-  struct nextfield *new;
+  struct nextfield *newobj;
 
   if (**pp != '!')
     {
 
   if (**pp != '!')
     {
@@ -3132,12 +3108,11 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
 
   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
     {
 
   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
     {
-      new = (struct nextfield *) xmalloc (sizeof (struct nextfield));
-      make_cleanup (xfree, new);
-      memset (new, 0, sizeof (struct nextfield));
-      new->next = fip->list;
-      fip->list = new;
-      FIELD_BITSIZE (new->field) = 0;  /* This should be an unpacked
+      newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
+
+      newobj->next = fip->list;
+      fip->list = newobj;
+      FIELD_BITSIZE (newobj->field) = 0;       /* This should be an unpacked
                                           field!  */
 
       STABS_CONTINUE (pp, objfile);
                                           field!  */
 
       STABS_CONTINUE (pp, objfile);
@@ -3152,15 +3127,14 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
        default:
          /* Unknown character.  Complain and treat it as non-virtual.  */
          {
        default:
          /* Unknown character.  Complain and treat it as non-virtual.  */
          {
-           complaint (&symfile_complaints,
-                      _("Unknown virtual character `%c' for baseclass"),
+           complaint (_("Unknown virtual character `%c' for baseclass"),
                       **pp);
          }
        }
       ++(*pp);
 
                       **pp);
          }
        }
       ++(*pp);
 
-      new->visibility = *(*pp)++;
-      switch (new->visibility)
+      newobj->visibility = *(*pp)++;
+      switch (newobj->visibility)
        {
        case VISIBILITY_PRIVATE:
        case VISIBILITY_PROTECTED:
        {
        case VISIBILITY_PRIVATE:
        case VISIBILITY_PROTECTED:
@@ -3170,10 +3144,9 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
          /* Bad visibility format.  Complain and treat it as
             public.  */
          {
          /* Bad visibility format.  Complain and treat it as
             public.  */
          {
-           complaint (&symfile_complaints,
-                      _("Unknown visibility `%c' for baseclass"),
-                      new->visibility);
-           new->visibility = VISIBILITY_PUBLIC;
+           complaint (_("Unknown visibility `%c' for baseclass"),
+                      newobj->visibility);
+           newobj->visibility = VISIBILITY_PUBLIC;
          }
        }
 
          }
        }
 
@@ -3184,7 +3157,7 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
           corresponding to this baseclass.  Always zero in the absence of
           multiple inheritance.  */
 
           corresponding to this baseclass.  Always zero in the absence of
           multiple inheritance.  */
 
-       SET_FIELD_BITPOS (new->field, read_huge_number (pp, ',', &nbits, 0));
+       SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
        if (nbits != 0)
          return 0;
       }
        if (nbits != 0)
          return 0;
       }
@@ -3193,8 +3166,8 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
          base class.  Read it, and remember it's type name as this
          field's name.  */
 
          base class.  Read it, and remember it's type name as this
          field's name.  */
 
-      new->field.type = read_type (pp, objfile);
-      new->field.name = type_name_no_tag (new->field.type);
+      newobj->field.type = read_type (pp, objfile);
+      newobj->field.name = TYPE_NAME (newobj->field.type);
 
       /* Skip trailing ';' and bump count of number of fields seen.  */
       if (**pp == ';')
 
       /* Skip trailing ';' and bump count of number of fields seen.  */
       if (**pp == ';')
@@ -3214,10 +3187,10 @@ read_baseclasses (struct field_info *fip, char **pp, struct type *type,
    so we can look for the vptr base class info.  */
 
 static int
    so we can look for the vptr base class info.  */
 
 static int
-read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
-                  struct objfile *objfile)
+read_tilde_fields (struct stab_field_info *fip, const char **pp,
+                  struct type *type, struct objfile *objfile)
 {
 {
-  char *p;
+  const char *p;
 
   STABS_CONTINUE (pp, objfile);
 
 
   STABS_CONTINUE (pp, objfile);
 
@@ -3262,7 +3235,7 @@ read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
              return 0;
            }
 
              return 0;
            }
 
-         TYPE_VPTR_BASETYPE (type) = t;
+         set_type_vptr_basetype (type, t);
          if (type == t)        /* Our own class provides vtbl ptr.  */
            {
              for (i = TYPE_NFIELDS (t) - 1;
          if (type == t)        /* Our own class provides vtbl ptr.  */
            {
              for (i = TYPE_NFIELDS (t) - 1;
@@ -3274,20 +3247,19 @@ read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
                  if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
                      && is_cplus_marker (name[sizeof (vptr_name) - 2]))
                    {
                  if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
                      && is_cplus_marker (name[sizeof (vptr_name) - 2]))
                    {
-                     TYPE_VPTR_FIELDNO (type) = i;
+                     set_type_vptr_fieldno (type, i);
                      goto gotit;
                    }
                }
              /* Virtual function table field not found.  */
                      goto gotit;
                    }
                }
              /* Virtual function table field not found.  */
-             complaint (&symfile_complaints,
-                        _("virtual function table pointer "
+             complaint (_("virtual function table pointer "
                           "not found when defining class `%s'"),
                         TYPE_NAME (type));
              return 0;
            }
          else
            {
                           "not found when defining class `%s'"),
                         TYPE_NAME (type));
              return 0;
            }
          else
            {
-             TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t);
+             set_type_vptr_fieldno (type, TYPE_VPTR_FIELDNO (t));
            }
 
        gotit:
            }
 
        gotit:
@@ -3298,7 +3270,7 @@ read_tilde_fields (struct field_info *fip, char **pp, struct type *type,
 }
 
 static int
 }
 
 static int
-attach_fn_fields_to_type (struct field_info *fip, struct type *type)
+attach_fn_fields_to_type (struct stab_field_info *fip, struct type *type)
 {
   int n;
 
 {
   int n;
 
@@ -3317,7 +3289,7 @@ attach_fn_fields_to_type (struct field_info *fip, struct type *type)
    for this class's virtual functions.  */
 
 static int
    for this class's virtual functions.  */
 
 static int
-attach_fields_to_type (struct field_info *fip, struct type *type,
+attach_fields_to_type (struct stab_field_info *fip, struct type *type,
                       struct objfile *objfile)
 {
   int nfields = 0;
                       struct objfile *objfile)
 {
   int nfields = 0;
@@ -3392,8 +3364,7 @@ attach_fields_to_type (struct field_info *fip, struct type *type,
        default:
          /* Unknown visibility.  Complain and treat it as public.  */
          {
        default:
          /* Unknown visibility.  Complain and treat it as public.  */
          {
-           complaint (&symfile_complaints,
-                      _("Unknown visibility `%c' for field"),
+           complaint (_("Unknown visibility `%c' for field"),
                       fip->list->visibility);
          }
          break;
                       fip->list->visibility);
          }
          break;
@@ -3412,9 +3383,9 @@ complain_about_struct_wipeout (struct type *type)
   const char *name = "";
   const char *kind = "";
 
   const char *name = "";
   const char *kind = "";
 
-  if (TYPE_TAG_NAME (type))
+  if (TYPE_NAME (type))
     {
     {
-      name = TYPE_TAG_NAME (type);
+      name = TYPE_NAME (type);
       switch (TYPE_CODE (type))
         {
         case TYPE_CODE_STRUCT: kind = "struct "; break;
       switch (TYPE_CODE (type))
         {
         case TYPE_CODE_STRUCT: kind = "struct "; break;
@@ -3423,19 +3394,13 @@ complain_about_struct_wipeout (struct type *type)
         default: kind = "";
         }
     }
         default: kind = "";
         }
     }
-  else if (TYPE_NAME (type))
-    {
-      name = TYPE_NAME (type);
-      kind = "";
-    }
   else
     {
       name = "<unknown>";
       kind = "";
     }
 
   else
     {
       name = "<unknown>";
       kind = "";
     }
 
-  complaint (&symfile_complaints,
-            _("struct/union type gets multiply defined: %s%s"), kind, name);
+  complaint (_("struct/union type gets multiply defined: %s%s"), kind, name);
 }
 
 /* Set the length for all variants of a same main_type, which are
 }
 
 /* Set the length for all variants of a same main_type, which are
@@ -3490,14 +3455,10 @@ set_length_in_type_chain (struct type *type)
  */
 
 static struct type *
  */
 
 static struct type *
-read_struct_type (char **pp, struct type *type, enum type_code type_code,
+read_struct_type (const char **pp, struct type *type, enum type_code type_code,
                   struct objfile *objfile)
 {
                   struct objfile *objfile)
 {
-  struct cleanup *back_to;
-  struct field_info fi;
-
-  fi.list = NULL;
-  fi.fnlist = NULL;
+  struct stab_field_info fi;
 
   /* When describing struct/union/class types in stabs, G++ always drops
      all qualifications from the name.  So if you've got:
 
   /* When describing struct/union/class types in stabs, G++ always drops
      all qualifications from the name.  So if you've got:
@@ -3519,8 +3480,6 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
       return type;
     }
 
       return type;
     }
 
-  back_to = make_cleanup (null_cleanup, 0);
-
   INIT_CPLUS_SPECIFIC (type);
   TYPE_CODE (type) = type_code;
   TYPE_STUB (type) = 0;
   INIT_CPLUS_SPECIFIC (type);
   TYPE_CODE (type) = type_code;
   TYPE_STUB (type) = 0;
@@ -3532,10 +3491,7 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
 
     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
     if (nbits != 0)
 
     TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
     if (nbits != 0)
-      {
-       do_cleanups (back_to);
-       return error_type (pp, objfile);
-      }
+      return error_type (pp, objfile);
     set_length_in_type_chain (type);
   }
 
     set_length_in_type_chain (type);
   }
 
@@ -3554,7 +3510,6 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
       type = error_type (pp, objfile);
     }
 
       type = error_type (pp, objfile);
     }
 
-  do_cleanups (back_to);
   return (type);
 }
 
   return (type);
 }
 
@@ -3564,7 +3519,7 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
    array.  */
 
 static struct type *
    array.  */
 
 static struct type *
-read_array_type (char **pp, struct type *type,
+read_array_type (const char **pp, struct type *type,
                 struct objfile *objfile)
 {
   struct type *index_type, *element_type, *range_type;
                 struct objfile *objfile)
 {
   struct type *index_type, *element_type, *range_type;
@@ -3615,7 +3570,7 @@ read_array_type (char **pp, struct type *type,
     }
 
   range_type =
     }
 
   range_type =
-    create_range_type ((struct type *) NULL, index_type, lower, upper);
+    create_static_range_type (NULL, index_type, lower, upper);
   type = create_array_type (type, element_type, range_type);
 
   return type;
   type = create_array_type (type, element_type, range_type);
 
   return type;
@@ -3627,11 +3582,11 @@ read_array_type (char **pp, struct type *type,
    Also defines the symbols that represent the values of the type.  */
 
 static struct type *
    Also defines the symbols that represent the values of the type.  */
 
 static struct type *
-read_enum_type (char **pp, struct type *type,
+read_enum_type (const char **pp, struct type *type,
                struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
                struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
-  char *p;
+  const char *p;
   char *name;
   long n;
   struct symbol *sym;
   char *name;
   long n;
   struct symbol *sym;
@@ -3647,10 +3602,10 @@ read_enum_type (char **pp, struct type *type,
      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
      to do?  For now, force all enum values to file scope.  */
   if (within_function)
      to be file-scope, between N_FN entries, using N_LSYM.  What's a mother
      to do?  For now, force all enum values to file scope.  */
   if (within_function)
-    symlist = &local_symbols;
+    symlist = get_local_symbols ();
   else
 #endif
   else
 #endif
-    symlist = &file_symbols;
+    symlist = get_file_symbols ();
   osyms = *symlist;
   o_nsyms = osyms ? osyms->nsyms : 0;
 
   osyms = *symlist;
   o_nsyms = osyms ? osyms->nsyms : 0;
 
@@ -3675,15 +3630,15 @@ read_enum_type (char **pp, struct type *type,
       p = *pp;
       while (*p != ':')
        p++;
       p = *pp;
       while (*p != ':')
        p++;
-      name = obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
+      name = obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp);
       *pp = p + 1;
       n = read_huge_number (pp, ',', &nbits, 0);
       if (nbits != 0)
        return error_type (pp, objfile);
 
       sym = allocate_symbol (objfile);
       *pp = p + 1;
       n = read_huge_number (pp, ',', &nbits, 0);
       if (nbits != 0)
        return error_type (pp, objfile);
 
       sym = allocate_symbol (objfile);
-      SYMBOL_SET_LINKAGE_NAME (sym, name);
-      SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+      sym->set_linkage_name (name);
+      SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
                           &objfile->objfile_obstack);
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
                           &objfile->objfile_obstack);
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
@@ -3728,7 +3683,7 @@ read_enum_type (char **pp, struct type *type,
          struct symbol *xsym = syms->symbol[j];
 
          SYMBOL_TYPE (xsym) = type;
          struct symbol *xsym = syms->symbol[j];
 
          SYMBOL_TYPE (xsym) = type;
-         TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
+         TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
          SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
          SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
@@ -3753,20 +3708,20 @@ read_enum_type (char **pp, struct type *type,
    FIXME.  */
 
 static struct type *
    FIXME.  */
 
 static struct type *
-read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
+read_sun_builtin_type (const char **pp, int typenums[2], struct objfile *objfile)
 {
   int type_bits;
   int nbits;
 {
   int type_bits;
   int nbits;
-  int signed_type;
-  enum type_code code = TYPE_CODE_INT;
+  int unsigned_type;
+  int boolean_type = 0;
 
   switch (**pp)
     {
     case 's':
 
   switch (**pp)
     {
     case 's':
-      signed_type = 1;
+      unsigned_type = 0;
       break;
     case 'u':
       break;
     case 'u':
-      signed_type = 0;
+      unsigned_type = 1;
       break;
     default:
       return error_type (pp, objfile);
       break;
     default:
       return error_type (pp, objfile);
@@ -3783,7 +3738,7 @@ read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
     (*pp)++;
   else if (**pp == 'b')
     {
     (*pp)++;
   else if (**pp == 'b')
     {
-      code = TYPE_CODE_BOOL;
+      boolean_type = 1;
       (*pp)++;
     }
 
       (*pp)++;
     }
 
@@ -3814,18 +3769,23 @@ read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile)
     ++(*pp);
 
   if (type_bits == 0)
     ++(*pp);
 
   if (type_bits == 0)
-    return init_type (TYPE_CODE_VOID, 1,
-                     signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
-                     objfile);
+    {
+      struct type *type = init_type (objfile, TYPE_CODE_VOID,
+                                    TARGET_CHAR_BIT, NULL);
+      if (unsigned_type)
+        TYPE_UNSIGNED (type) = 1;
+      return type;
+    }
+
+  if (boolean_type)
+    return init_boolean_type (objfile, type_bits, unsigned_type, NULL);
   else
   else
-    return init_type (code,
-                     type_bits / TARGET_CHAR_BIT,
-                     signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL,
-                     objfile);
+    return init_integer_type (objfile, type_bits, unsigned_type, NULL);
 }
 
 static struct type *
 }
 
 static struct type *
-read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
+read_sun_floating_type (const char **pp, int typenums[2],
+                       struct objfile *objfile)
 {
   int nbits;
   int details;
 {
   int nbits;
   int details;
@@ -3843,16 +3803,16 @@ read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
   if (nbits != 0)
     return error_type (pp, objfile);
 
   if (nbits != 0)
     return error_type (pp, objfile);
 
+  nbits = nbytes * TARGET_CHAR_BIT;
+
   if (details == NF_COMPLEX || details == NF_COMPLEX16
       || details == NF_COMPLEX32)
     {
   if (details == NF_COMPLEX || details == NF_COMPLEX16
       || details == NF_COMPLEX32)
     {
-      rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile);
-      TYPE_TARGET_TYPE (rettype)
-       = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile);
-      return rettype;
+      rettype = dbx_init_float_type (objfile, nbits / 2);
+      return init_complex_type (objfile, NULL, rettype);
     }
 
     }
 
-  return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile);
+  return dbx_init_float_type (objfile, nbits);
 }
 
 /* Read a number from the string pointed to by *PP.
 }
 
 /* Read a number from the string pointed to by *PP.
@@ -3873,9 +3833,10 @@ read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile)
    If encounter garbage, set *BITS to -1 and return 0.  */
 
 static long
    If encounter garbage, set *BITS to -1 and return 0.  */
 
 static long
-read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
+read_huge_number (const char **pp, int end, int *bits,
+                 int twos_complement_bits)
 {
 {
-  char *p = *pp;
+  const char *p = *pp;
   int sign = 1;
   int sign_bit = 0;
   long n = 0;
   int sign = 1;
   int sign_bit = 0;
   long n = 0;
@@ -3910,7 +3871,7 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
         negative number.  */
 
       size_t len;
         negative number.  */
 
       size_t len;
-      char *p1 = p;
+      const char *p1 = p;
 
       while ((c = *p1) >= '0' && c < '8')
        p1++;
 
       while ((c = *p1) >= '0' && c < '8')
        p1++;
@@ -3921,7 +3882,7 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
              && len == twos_complement_bits / 3))
        {
          /* Ok, we have enough characters for a signed value, check
              && len == twos_complement_bits / 3))
        {
          /* Ok, we have enough characters for a signed value, check
-            for signness by testing if the sign bit is set.  */
+            for signedness by testing if the sign bit is set.  */
          sign_bit = (twos_complement_bits % 3 + 2) % 3;
          c = *p - '0';
          if (c & (1 << sign_bit))
          sign_bit = (twos_complement_bits % 3 + 2) % 3;
          c = *p - '0';
          if (c & (1 << sign_bit))
@@ -4037,11 +3998,11 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
 }
 
 static struct type *
 }
 
 static struct type *
-read_range_type (char **pp, int typenums[2], int type_size,
+read_range_type (const char **pp, int typenums[2], int type_size,
                  struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
                  struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
-  char *orig_pp = *pp;
+  const char *orig_pp = *pp;
   int rangenums[2];
   long n2, n3;
   int n2bits, n3bits;
   int rangenums[2];
   long n2, n3;
   int n2bits, n3bits;
@@ -4115,18 +4076,14 @@ read_range_type (char **pp, int typenums[2], int type_size,
        }
 
       if (got_signed || got_unsigned)
        }
 
       if (got_signed || got_unsigned)
-       {
-         return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT,
-                           got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL,
-                           objfile);
-       }
+       return init_integer_type (objfile, nbits, got_unsigned, NULL);
       else
        return error_type (pp, objfile);
     }
 
   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
   if (self_subrange && n2 == 0 && n3 == 0)
       else
        return error_type (pp, objfile);
     }
 
   /* A type defined as a subrange of itself, with bounds both 0, is void.  */
   if (self_subrange && n2 == 0 && n3 == 0)
-    return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
+    return init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
 
   /* If n3 is zero and n2 is positive, we want a floating type, and n2
      is the width in bytes.
 
   /* If n3 is zero and n2 is positive, we want a floating type, and n2
      is the width in bytes.
@@ -4143,16 +4100,10 @@ read_range_type (char **pp, int typenums[2], int type_size,
   if (n3 == 0 && n2 > 0)
     {
       struct type *float_type
   if (n3 == 0 && n2 > 0)
     {
       struct type *float_type
-       = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile);
+       = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT);
 
       if (self_subrange)
 
       if (self_subrange)
-       {
-         struct type *complex_type = 
-           init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile);
-
-         TYPE_TARGET_TYPE (complex_type) = float_type;
-         return complex_type;
-       }
+       return init_complex_type (objfile, NULL, float_type);
       else
        return float_type;
     }
       else
        return float_type;
     }
@@ -4171,15 +4122,18 @@ read_range_type (char **pp, int typenums[2], int type_size,
          bits = gdbarch_int_bit (gdbarch);
        }
 
          bits = gdbarch_int_bit (gdbarch);
        }
 
-      return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
-                       TYPE_FLAG_UNSIGNED, NULL, objfile);
+      return init_integer_type (objfile, bits, 1, NULL);
     }
 
   /* Special case: char is defined (Who knows why) as a subrange of
      itself with range 0-127.  */
   else if (self_subrange && n2 == 0 && n3 == 127)
     }
 
   /* Special case: char is defined (Who knows why) as a subrange of
      itself with range 0-127.  */
   else if (self_subrange && n2 == 0 && n3 == 127)
-    return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile);
-
+    {
+      struct type *type = init_integer_type (objfile, TARGET_CHAR_BIT,
+                                            0, NULL);
+      TYPE_NOSIGN (type) = 1;
+      return type;
+    }
   /* We used to do this only for subrange of self or subrange of int.  */
   else if (n2 == 0)
     {
   /* We used to do this only for subrange of self or subrange of int.  */
   else if (n2 == 0)
     {
@@ -4189,8 +4143,7 @@ read_range_type (char **pp, int typenums[2], int type_size,
 
       if (n3 < 0)
        /* n3 actually gives the size.  */
 
       if (n3 < 0)
        /* n3 actually gives the size.  */
-       return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED,
-                         NULL, objfile);
+       return init_integer_type (objfile, -n3 * TARGET_CHAR_BIT, 1, NULL);
 
       /* Is n3 == 2**(8n)-1 for some integer n?  Then it's an
          unsigned n-byte integer.  But do require n to be a power of
 
       /* Is n3 == 2**(8n)-1 for some integer n?  Then it's an
          unsigned n-byte integer.  But do require n to be a power of
@@ -4204,8 +4157,7 @@ read_range_type (char **pp, int typenums[2], int type_size,
          bits >>= 8;
        if (bits == 0
            && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
          bits >>= 8;
        if (bits == 0
            && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
-         return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL,
-                           objfile);
+         return init_integer_type (objfile, bytes * TARGET_CHAR_BIT, 1, NULL);
       }
     }
   /* I think this is for Convex "long long".  Since I don't know whether
       }
     }
   /* I think this is for Convex "long long".  Since I don't know whether
@@ -4215,15 +4167,15 @@ read_range_type (char **pp, int typenums[2], int type_size,
           && (self_subrange
               || n2 == -gdbarch_long_long_bit
                          (gdbarch) / TARGET_CHAR_BIT))
           && (self_subrange
               || n2 == -gdbarch_long_long_bit
                          (gdbarch) / TARGET_CHAR_BIT))
-    return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
+    return init_integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL);
   else if (n2 == -n3 - 1)
     {
       if (n3 == 0x7f)
   else if (n2 == -n3 - 1)
     {
       if (n3 == 0x7f)
-       return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile);
+       return init_integer_type (objfile, 8, 0, NULL);
       if (n3 == 0x7fff)
       if (n3 == 0x7fff)
-       return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile);
+       return init_integer_type (objfile, 16, 0, NULL);
       if (n3 == 0x7fffffff)
       if (n3 == 0x7fffffff)
-       return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile);
+       return init_integer_type (objfile, 32, 0, NULL);
     }
 
   /* We have a real range type on our hands.  Allocate space and
     }
 
   /* We have a real range type on our hands.  Allocate space and
@@ -4239,13 +4191,13 @@ handle_true_range:
       /* Does this actually ever happen?  Is that why we are worrying
          about dealing with it rather than just calling error_type?  */
 
       /* Does this actually ever happen?  Is that why we are worrying
          about dealing with it rather than just calling error_type?  */
 
-      complaint (&symfile_complaints,
-                _("base type %d of range type is not defined"), rangenums[1]);
+      complaint (_("base type %d of range type is not defined"), rangenums[1]);
 
       index_type = objfile_type (objfile)->builtin_int;
     }
 
 
       index_type = objfile_type (objfile)->builtin_int;
     }
 
-  result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
+  result_type
+    = create_static_range_type (NULL, index_type, n2, n3);
   return (result_type);
 }
 
   return (result_type);
 }
 
@@ -4254,7 +4206,7 @@ handle_true_range:
    if there is an error.  */
 
 static struct field *
    if there is an error.  */
 
 static struct field *
-read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
+read_args (const char **pp, int end, struct objfile *objfile, int *nargsp,
           int *varargsp)
 {
   /* FIXME!  Remove this arbitrary limit!  */
           int *varargsp)
 {
   /* FIXME!  Remove this arbitrary limit!  */
@@ -4280,7 +4232,7 @@ read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
         have been present ";-16,(0,43)" reference instead.  This way the
         excessive ";" marker prematurely stops the parameters parsing.  */
 
         have been present ";-16,(0,43)" reference instead.  This way the
         excessive ";" marker prematurely stops the parameters parsing.  */
 
-      complaint (&symfile_complaints, _("Invalid (empty) method arguments"));
+      complaint (_("Invalid (empty) method arguments"));
       *varargsp = 0;
     }
   else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
       *varargsp = 0;
     }
   else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
@@ -4291,8 +4243,7 @@ read_args (char **pp, int end, struct objfile *objfile, int *nargsp,
       *varargsp = 0;
     }
 
       *varargsp = 0;
     }
 
-  rval = (struct field *) xmalloc (n * sizeof (struct field));
-  memset (rval, 0, n * sizeof (struct field));
+  rval = XCNEWVEC (struct field, n);
   for (i = 0; i < n; i++)
     rval[i].type = types[i];
   *nargsp = n;
   for (i = 0; i < n; i++)
     rval[i].type = types[i];
   *nargsp = n;
@@ -4319,17 +4270,15 @@ static char *common_block_name;
    to remain after this function returns.  */
 
 void
    to remain after this function returns.  */
 
 void
-common_block_start (char *name, struct objfile *objfile)
+common_block_start (const char *name, struct objfile *objfile)
 {
   if (common_block_name != NULL)
     {
 {
   if (common_block_name != NULL)
     {
-      complaint (&symfile_complaints,
-                _("Invalid symbol data: common block within common block"));
+      complaint (_("Invalid symbol data: common block within common block"));
     }
     }
-  common_block = local_symbols;
-  common_block_i = local_symbols ? local_symbols->nsyms : 0;
-  common_block_name = obstack_copy0 (&objfile->objfile_obstack,
-                                    name, strlen (name));
+  common_block = *get_local_symbols ();
+  common_block_i = common_block ? common_block->nsyms : 0;
+  common_block_name = obstack_strdup (&objfile->objfile_obstack, name);
 }
 
 /* Process a N_ECOMM symbol.  */
 }
 
 /* Process a N_ECOMM symbol.  */
@@ -4344,30 +4293,30 @@ common_block_end (struct objfile *objfile)
      symbol for the common block name for later fixup.  */
   int i;
   struct symbol *sym;
      symbol for the common block name for later fixup.  */
   int i;
   struct symbol *sym;
-  struct pending *new = 0;
+  struct pending *newobj = 0;
   struct pending *next;
   int j;
 
   if (common_block_name == NULL)
     {
   struct pending *next;
   int j;
 
   if (common_block_name == NULL)
     {
-      complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM"));
+      complaint (_("ECOMM symbol unmatched by BCOMM"));
       return;
     }
 
   sym = allocate_symbol (objfile);
   /* Note: common_block_name already saved on objfile_obstack.  */
       return;
     }
 
   sym = allocate_symbol (objfile);
   /* Note: common_block_name already saved on objfile_obstack.  */
-  SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
+  sym->set_linkage_name (common_block_name);
   SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
 
   /* Now we copy all the symbols which have been defined since the BCOMM.  */
 
   /* Copy all the struct pendings before common_block.  */
   SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
 
   /* Now we copy all the symbols which have been defined since the BCOMM.  */
 
   /* Copy all the struct pendings before common_block.  */
-  for (next = local_symbols;
+  for (next = *get_local_symbols ();
        next != NULL && next != common_block;
        next = next->next)
     {
       for (j = 0; j < next->nsyms; j++)
        next != NULL && next != common_block;
        next = next->next)
     {
       for (j = 0; j < next->nsyms; j++)
-       add_symbol_to_list (next->symbol[j], &new);
+       add_symbol_to_list (next->symbol[j], &newobj);
     }
 
   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
     }
 
   /* Copy however much of COMMON_BLOCK we need.  If COMMON_BLOCK is
@@ -4376,14 +4325,14 @@ common_block_end (struct objfile *objfile)
 
   if (common_block != NULL)
     for (j = common_block_i; j < common_block->nsyms; j++)
 
   if (common_block != NULL)
     for (j = common_block_i; j < common_block->nsyms; j++)
-      add_symbol_to_list (common_block->symbol[j], &new);
+      add_symbol_to_list (common_block->symbol[j], &newobj);
 
 
-  SYMBOL_TYPE (sym) = (struct type *) new;
+  SYMBOL_TYPE (sym) = (struct type *) newobj;
 
   /* Should we be putting local_symbols back to what it was?
      Does it matter?  */
 
 
   /* Should we be putting local_symbols back to what it was?
      Does it matter?  */
 
-  i = hashname (SYMBOL_LINKAGE_NAME (sym));
+  i = hashname (sym->linkage_name ());
   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
   global_sym_chain[i] = sym;
   common_block_name = NULL;
   SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
   global_sym_chain[i] = sym;
   common_block_name = NULL;
@@ -4403,7 +4352,9 @@ fix_common_block (struct symbol *sym, CORE_ADDR valu)
       int j;
 
       for (j = next->nsyms - 1; j >= 0; j--)
       int j;
 
       for (j = next->nsyms - 1; j >= 0; j--)
-       SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu;
+       SET_SYMBOL_VALUE_ADDRESS (next->symbol[j],
+                                 SYMBOL_VALUE_ADDRESS (next->symbol[j])
+                                 + valu);
     }
 }
 \f
     }
 }
 \f
@@ -4463,7 +4414,7 @@ add_undefined_type_1 (struct type *type)
 static void
 add_undefined_type (struct type *type, int typenums[2])
 {
 static void
 add_undefined_type (struct type *type, int typenums[2])
 {
-  if (TYPE_TAG_NAME (type) == NULL)
+  if (TYPE_NAME (type) == NULL)
     add_undefined_type_noname (type, typenums);
   else
     add_undefined_type_1 (type);
     add_undefined_type_noname (type, typenums);
   else
     add_undefined_type_1 (type);
@@ -4548,14 +4499,14 @@ cleanup_undefined_types_1 (void)
                struct pending *ppt;
                int i;
                /* Name of the type, without "struct" or "union".  */
                struct pending *ppt;
                int i;
                /* Name of the type, without "struct" or "union".  */
-               const char *typename = TYPE_TAG_NAME (*type);
+               const char *type_name = TYPE_NAME (*type);
 
 
-               if (typename == NULL)
+               if (type_name == NULL)
                  {
                  {
-                   complaint (&symfile_complaints, _("need a type name"));
+                   complaint (_("need a type name"));
                    break;
                  }
                    break;
                  }
-               for (ppt = file_symbols; ppt; ppt = ppt->next)
+               for (ppt = *get_file_symbols (); ppt; ppt = ppt->next)
                  {
                    for (i = 0; i < ppt->nsyms; i++)
                      {
                  {
                    for (i = 0; i < ppt->nsyms; i++)
                      {
@@ -4567,8 +4518,7 @@ cleanup_undefined_types_1 (void)
                                TYPE_CODE (*type))
                            && (TYPE_INSTANCE_FLAGS (*type) ==
                                TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
                                TYPE_CODE (*type))
                            && (TYPE_INSTANCE_FLAGS (*type) ==
                                TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
-                           && strcmp (SYMBOL_LINKAGE_NAME (sym),
-                                      typename) == 0)
+                           && strcmp (sym->linkage_name (), type_name) == 0)
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
@@ -4578,8 +4528,7 @@ cleanup_undefined_types_1 (void)
 
        default:
          {
 
        default:
          {
-           complaint (&symfile_complaints,
-                      _("forward-referenced types left unresolved, "
+           complaint (_("forward-referenced types left unresolved, "
                        "type code %d."),
                       TYPE_CODE (*type));
          }
                        "type code %d."),
                       TYPE_CODE (*type));
          }
@@ -4590,7 +4539,7 @@ cleanup_undefined_types_1 (void)
   undef_types_length = 0;
 }
 
   undef_types_length = 0;
 }
 
-/* Try to fix all the undefined types we ecountered while processing
+/* Try to fix all the undefined types we encountered while processing
    this unit.  */
 
 void
    this unit.  */
 
 void
@@ -4600,15 +4549,12 @@ cleanup_undefined_stabs_types (struct objfile *objfile)
   cleanup_undefined_types_noname (objfile);
 }
 
   cleanup_undefined_types_noname (objfile);
 }
 
-/* Scan through all of the global symbols defined in the object file,
-   assigning values to the debugging symbols that need to be assigned
-   to.  Get these symbols from the minimal symbol table.  */
+/* See stabsread.h.  */
 
 void
 scan_file_globals (struct objfile *objfile)
 {
   int hash;
 
 void
 scan_file_globals (struct objfile *objfile)
 {
   int hash;
-  struct minimal_symbol *msymbol;
   struct symbol *sym, *prev;
   struct objfile *resolve_objfile;
 
   struct symbol *sym, *prev;
   struct objfile *resolve_objfile;
 
@@ -4634,7 +4580,7 @@ scan_file_globals (struct objfile *objfile)
       if (hash >= HASHSIZE)
        return;
 
       if (hash >= HASHSIZE)
        return;
 
-      ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
+      for (minimal_symbol *msymbol : resolve_objfile->msymbols ())
        {
          QUIT;
 
        {
          QUIT;
 
@@ -4654,12 +4600,11 @@ scan_file_globals (struct objfile *objfile)
          /* Get the hash index and check all the symbols
             under that hash index.  */
 
          /* Get the hash index and check all the symbols
             under that hash index.  */
 
-         hash = hashname (SYMBOL_LINKAGE_NAME (msymbol));
+         hash = hashname (msymbol->linkage_name ());
 
          for (sym = global_sym_chain[hash]; sym;)
            {
 
          for (sym = global_sym_chain[hash]; sym;)
            {
-             if (strcmp (SYMBOL_LINKAGE_NAME (msymbol),
-                         SYMBOL_LINKAGE_NAME (sym)) == 0)
+             if (strcmp (msymbol->linkage_name (), sym->linkage_name ()) == 0)
                {
                  /* Splice this symbol out of the hash chain and
                     assign the value we have to it.  */
                {
                  /* Splice this symbol out of the hash chain and
                     assign the value we have to it.  */
@@ -4680,14 +4625,16 @@ scan_file_globals (struct objfile *objfile)
                      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
                        {
                          fix_common_block (sym,
                      if (SYMBOL_CLASS (sym) == LOC_BLOCK)
                        {
                          fix_common_block (sym,
-                                           SYMBOL_VALUE_ADDRESS (msymbol));
+                                           MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+                                                                  msymbol));
                        }
                      else
                        {
                        }
                      else
                        {
-                         SYMBOL_VALUE_ADDRESS (sym)
-                           = SYMBOL_VALUE_ADDRESS (msymbol);
+                         SET_SYMBOL_VALUE_ADDRESS
+                           (sym, MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+                                                        msymbol));
                        }
                        }
-                     SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol);
+                     SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
                    }
 
                  if (prev)
                    }
 
                  if (prev)
@@ -4723,16 +4670,15 @@ scan_file_globals (struct objfile *objfile)
 
          /* Change the symbol address from the misleading chain value
             to address zero.  */
 
          /* Change the symbol address from the misleading chain value
             to address zero.  */
-         SYMBOL_VALUE_ADDRESS (prev) = 0;
+         SET_SYMBOL_VALUE_ADDRESS (prev, 0);
 
          /* Complain about unresolved common block symbols.  */
          if (SYMBOL_CLASS (prev) == LOC_STATIC)
            SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
          else
 
          /* Complain about unresolved common block symbols.  */
          if (SYMBOL_CLASS (prev) == LOC_STATIC)
            SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
          else
-           complaint (&symfile_complaints,
-                      _("%s: common block `%s' from "
+           complaint (_("%s: common block `%s' from "
                         "global_sym_chain unresolved"),
                         "global_sym_chain unresolved"),
-                      objfile->name, SYMBOL_PRINT_NAME (prev));
+                      objfile_name (objfile), prev->print_name ());
        }
     }
   memset (global_sym_chain, 0, sizeof (global_sym_chain));
        }
     }
   memset (global_sym_chain, 0, sizeof (global_sym_chain));
@@ -4769,6 +4715,7 @@ start_stabs (void)
   n_this_object_header_files = 1;
   type_vector_length = 0;
   type_vector = (struct type **) 0;
   n_this_object_header_files = 1;
   type_vector_length = 0;
   type_vector = (struct type **) 0;
+  within_function = 0;
 
   /* FIXME: If common_block_name is not already NULL, we should complain().  */
   common_block_name = NULL;
 
   /* FIXME: If common_block_name is not already NULL, we should complain().  */
   common_block_name = NULL;
@@ -4793,7 +4740,7 @@ finish_global_stabs (struct objfile *objfile)
 {
   if (global_stabs)
     {
 {
   if (global_stabs)
     {
-      patch_block_stabs (global_symbols, global_stabs, objfile);
+      patch_block_stabs (*get_global_symbols (), global_stabs, objfile);
       xfree (global_stabs);
       global_stabs = NULL;
     }
       xfree (global_stabs);
       global_stabs = NULL;
     }
@@ -4801,10 +4748,10 @@ finish_global_stabs (struct objfile *objfile)
 
 /* Find the end of the name, delimited by a ':', but don't match
    ObjC symbols which look like -[Foo bar::]:bla.  */
 
 /* Find the end of the name, delimited by a ':', but don't match
    ObjC symbols which look like -[Foo bar::]:bla.  */
-static char *
-find_name_end (char *name)
+static const char *
+find_name_end (const char *name)
 {
 {
-  char *s = name;
+  const char *s = name;
 
   if (s[0] == '-' || *s == '+')
     {
 
   if (s[0] == '-' || *s == '+')
     {
@@ -4826,22 +4773,26 @@ find_name_end (char *name)
     }
 }
 
     }
 }
 
+/* See stabsread.h.  */
+
+int
+hashname (const char *name)
+{
+  return fast_hash (name, strlen (name)) % HASHSIZE;
+}
+
 /* Initializer for this module.  */
 
 void
 _initialize_stabsread (void)
 {
 /* Initializer for this module.  */
 
 void
 _initialize_stabsread (void)
 {
-  rs6000_builtin_type_data = register_objfile_data ();
-
   undef_types_allocated = 20;
   undef_types_length = 0;
   undef_types_allocated = 20;
   undef_types_length = 0;
-  undef_types = (struct type **)
-    xmalloc (undef_types_allocated * sizeof (struct type *));
+  undef_types = XNEWVEC (struct type *, undef_types_allocated);
 
   noname_undefs_allocated = 20;
   noname_undefs_length = 0;
 
   noname_undefs_allocated = 20;
   noname_undefs_length = 0;
-  noname_undefs = (struct nat *)
-    xmalloc (noname_undefs_allocated * sizeof (struct nat));
+  noname_undefs = XNEWVEC (struct nat, noname_undefs_allocated);
 
   stab_register_index = register_symbol_register_impl (LOC_REGISTER,
                                                       &stab_register_funcs);
 
   stab_register_index = register_symbol_register_impl (LOC_REGISTER,
                                                       &stab_register_funcs);
GDB Binutils - Deliverables
This page took 0.059372 seconds and 4 git commands to generate.