projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Remove ATTRIBUTE_UNUSED check from ARI
[deliverable/binutils-gdb.git] / gdb / stabsread.c
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 68feabdebc4c77130a0e3fb82157d1ea1262b6ed..91a73dd10db94bcbc46d36f544619ed235d0a432 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-2018 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -36,21 +36,30 @@
 #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 "target-float.h"
 #include "complaints.h"
 #include "demangle.h"
 #include "gdb-demangle.h"
 #include "language.h"
 #include "target-float.h"
+#include "c-lang.h"
 #include "cp-abi.h"
 #include "cp-support.h"
 #include <ctype.h>
 
 #include "cp-abi.h"
 #include "cp-support.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
 {
@@ -76,14 +85,16 @@ struct next_fnfieldlist
    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 *list;
-    struct next_fnfieldlist *fnlist;
+    struct nextfield *list = nullptr;
+    struct next_fnfieldlist *fnlist = nullptr;
+
+    auto_obstack obstack;
   };
 
 static void
   };
 
 static void
-read_one_struct_field (struct field_info *, const char **, const 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 *);
@@ -116,24 +127,24 @@ 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 *, const 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 *, const 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 *, const 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 *, const 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 *);
 
 static struct type *read_struct_type (const char **, struct type *,
                                  struct objfile *);
 
 static struct type *read_struct_type (const char **, struct type *,
@@ -149,7 +160,7 @@ static struct field *read_args (const char **, int, struct objfile *,
 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 *, const char **, struct type *,
+read_cpp_abbrev (struct stab_field_info *, const char **, struct type *,
                 struct objfile *);
 
 static const char *find_name_end (const char *name);
                 struct objfile *);
 
 static const char *find_name_end (const char *name);
@@ -415,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, (char *) 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')
                {
@@ -431,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
            {
@@ -615,14 +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 < 0
-      || 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.  */
     }
@@ -694,7 +700,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       SYMBOL_LINE (sym) = 0;   /* unknown */
     }
 
       SYMBOL_LINE (sym) = 0;   /* unknown */
     }
 
-  SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
+  SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
                       &objfile->objfile_obstack);
 
   if (is_cplus_marker (string[0]))
                       &objfile->objfile_obstack);
 
   if (is_cplus_marker (string[0]))
@@ -703,14 +709,14 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       switch (string[1])
        {
        case 't':
       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 '_':
@@ -745,14 +751,16 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       if (!new_name.empty ())
        {
          SYMBOL_SET_NAMES (sym,
       if (!new_name.empty ())
        {
          SYMBOL_SET_NAMES (sym,
-                           new_name.c_str (), new_name.length (),
+                           new_name,
                            1, objfile);
        }
       else
                            1, objfile);
        }
       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)
 
       if (SYMBOL_LANGUAGE (sym) == language_cplus)
-       cp_scan_for_anonymous_namespaces (sym, objfile);
+       cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
+                                         objfile);
 
     }
   p++;
 
     }
   p++;
@@ -788,7 +796,7 @@ define_symbol (CORE_ADDR valu, const 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;
@@ -847,7 +855,7 @@ define_symbol (CORE_ADDR valu, const 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;
              }
 
@@ -872,7 +880,7 @@ define_symbol (CORE_ADDR valu, const 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;
              }
 
@@ -927,7 +935,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -935,8 +943,8 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -944,7 +952,7 @@ define_symbol (CORE_ADDR valu, const 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:
@@ -1015,7 +1023,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -1030,13 +1038,13 @@ define_symbol (CORE_ADDR valu, const 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,
@@ -1048,7 +1056,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -1069,7 +1077,7 @@ define_symbol (CORE_ADDR valu, const 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)
        {
@@ -1118,7 +1126,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -1133,8 +1141,7 @@ define_symbol (CORE_ADDR valu, const 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.
 
@@ -1149,6 +1156,7 @@ define_symbol (CORE_ADDR valu, const 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)))
@@ -1158,8 +1166,8 @@ define_symbol (CORE_ADDR valu, const 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
@@ -1170,37 +1178,36 @@ define_symbol (CORE_ADDR valu, const 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 bound_minimal_symbol msym;
 
        {
          struct bound_minimal_symbol msym;
 
-         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
-                                       NULL, objfile);
+         msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
          if (msym.minsym != NULL)
            {
              const char *new_name = gdbarch_static_transform_name
          if (msym.minsym != NULL)
            {
              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) = BMSYMBOL_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':
@@ -1245,18 +1252,13 @@ define_symbol (CORE_ADDR valu, const 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
@@ -1295,16 +1297,16 @@ define_symbol (CORE_ADDR valu, const 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)
         {
@@ -1317,10 +1319,9 @@ define_symbol (CORE_ADDR valu, const 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;
@@ -1345,10 +1346,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
       if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
        TYPE_NAME (SYMBOL_TYPE (sym))
       SYMBOL_DOMAIN (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 (sym, &file_symbols);
+      add_symbol_to_list (sym, get_file_symbols ());
 
       if (synonym)
        {
 
       if (synonym)
        {
@@ -1361,10 +1361,9 @@ define_symbol (CORE_ADDR valu, const 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;
 
@@ -1372,27 +1371,25 @@ define_symbol (CORE_ADDR valu, const 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 bound_minimal_symbol msym;
 
        {
          struct bound_minimal_symbol msym;
 
-         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), 
-                                       NULL, objfile);
+         msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
          if (msym.minsym != NULL)
            {
              const char *new_name = gdbarch_static_transform_name
          if (msym.minsym != NULL)
            {
              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) = BMSYMBOL_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':
@@ -1402,7 +1399,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -1412,7 +1409,7 @@ define_symbol (CORE_ADDR valu, const 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':
@@ -1424,7 +1421,7 @@ define_symbol (CORE_ADDR valu, const 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:
@@ -1432,7 +1429,7 @@ define_symbol (CORE_ADDR valu, const 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;
     }
 
@@ -1637,7 +1634,7 @@ 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 *name = (char *) alloca (p - *pp + 1);
 
            {
              char *name = (char *) alloca (p - *pp + 1);
 
@@ -1646,12 +1643,8 @@ again:
 
              std::string new_name = cp_canonicalize_string (name);
              if (!new_name.empty ())
 
              std::string new_name = cp_canonicalize_string (name);
              if (!new_name.empty ())
-               {
-                 type_name
-                   = (char *) obstack_copy0 (&objfile->objfile_obstack,
-                                             new_name.c_str (),
-                                             new_name.length ());
-               }
+               type_name = obstack_strdup (&objfile->objfile_obstack,
+                                           new_name);
            }
          if (type_name == NULL)
            {
            }
          if (type_name == NULL)
            {
@@ -1674,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];
@@ -1682,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);
@@ -2040,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;
@@ -2067,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
-    = (struct type **) 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
@@ -2090,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)
@@ -2270,7 +2264,7 @@ 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, const char **pp,
+read_member_functions (struct stab_field_info *fip, const char **pp,
                       struct type *type, struct objfile *objfile)
 {
   int nfn_fields = 0;
                       struct type *type, struct objfile *objfile)
 {
   int nfn_fields = 0;
@@ -2310,8 +2304,7 @@ read_member_functions (struct field_info *fip, const char **pp,
       look_ahead_type = NULL;
       length = 0;
 
       look_ahead_type = NULL;
       length = 0;
 
-      new_fnlist = XCNEW (struct next_fnfieldlist);
-      make_cleanup (xfree, new_fnlist);
+      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]))
        {
@@ -2350,8 +2343,7 @@ read_member_functions (struct field_info *fip, const char **pp,
 
       do
        {
 
       do
        {
-         new_sublist = XCNEW (struct next_fnfield);
-         make_cleanup (xfree, new_sublist);
+         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)
@@ -2553,7 +2545,6 @@ read_member_functions (struct field_info *fip, const char **pp,
        }
       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;
@@ -2617,8 +2608,6 @@ read_member_functions (struct field_info *fip, const char **pp,
          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;
@@ -2638,8 +2627,8 @@ read_member_functions (struct field_info *fip, const char **pp,
 
              /* Create a new fn_fieldlist for the destructors.  */
 
 
              /* Create a new fn_fieldlist for the destructors.  */
 
-             destr_fnlist = XCNEW (struct next_fnfieldlist);
-             make_cleanup (xfree, destr_fnlist);
+             destr_fnlist = OBSTACK_ZALLOC (&fip->obstack,
+                                            struct next_fnfieldlist);
 
              destr_fnlist->fn_fieldlist.name
                = obconcat (&objfile->objfile_obstack, "~",
 
              destr_fnlist->fn_fieldlist.name
                = obconcat (&objfile->objfile_obstack, "~",
@@ -2705,23 +2694,6 @@ read_member_functions (struct field_info *fip, const char **pp,
                          "~", 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
-                 = ((const char *)
-                    obstack_copy0 (&objfile->objfile_obstack, dem_opname,
-                                   strlen (dem_opname)));
-             xfree (main_fn_name);
-           }
 
          new_fnlist->fn_fieldlist.fn_fields
            = OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
 
          new_fnlist->fn_fieldlist.fn_fields
            = OBSTACK_CALLOC (&objfile->objfile_obstack, length, fn_field);
@@ -2756,8 +2728,8 @@ read_member_functions (struct field_info *fip, const char **pp,
    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, const 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)
 {
   const char *p;
   const char *name;
 {
   const char *p;
   const char *name;
@@ -2782,7 +2754,7 @@ read_cpp_abbrev (struct field_info *fip, const 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 = "";
@@ -2792,7 +2764,7 @@ read_cpp_abbrev (struct field_info *fip, const 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)
            {
              complaint (_("C++ abbreviated type name "
          if (name == NULL)
            {
              complaint (_("C++ abbreviated type name "
@@ -2851,13 +2823,14 @@ read_cpp_abbrev (struct field_info *fip, const char **pp, struct type *type,
 }
 
 static void
 }
 
 static void
-read_one_struct_field (struct field_info *fip, const char **pp, const 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);
 
   fip->list->field.name
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 
   fip->list->field.name
-    = (const char *) obstack_copy0 (&objfile->objfile_obstack, *pp, p - *pp);
+    = 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.  */
@@ -2994,8 +2967,8 @@ read_one_struct_field (struct field_info *fip, const char **pp, const 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, const 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)
 {
   const char *p;
   struct nextfield *newobj;
 {
   const char *p;
   struct nextfield *newobj;
@@ -3014,8 +2987,7 @@ read_struct_fields (struct field_info *fip, const 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.  */
-      newobj = XCNEW (struct nextfield);
-      make_cleanup (xfree, newobj);
+      newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
 
       newobj->next = fip->list;
       fip->list = newobj;
 
       newobj->next = fip->list;
       fip->list = newobj;
@@ -3092,8 +3064,8 @@ read_struct_fields (struct field_info *fip, const char **pp, struct type *type,
 
 
 static int
 
 
 static int
-read_baseclasses (struct field_info *fip, const 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;
   struct nextfield *newobj;
 {
   int i;
   struct nextfield *newobj;
@@ -3136,8 +3108,7 @@ read_baseclasses (struct field_info *fip, const char **pp, struct type *type,
 
   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
     {
 
   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
     {
-      newobj = XCNEW (struct nextfield);
-      make_cleanup (xfree, newobj);
+      newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
 
       newobj->next = fip->list;
       fip->list = newobj;
 
       newobj->next = fip->list;
       fip->list = newobj;
@@ -3196,7 +3167,7 @@ read_baseclasses (struct field_info *fip, const char **pp, struct type *type,
          field's name.  */
 
       newobj->field.type = read_type (pp, objfile);
          field's name.  */
 
       newobj->field.type = read_type (pp, objfile);
-      newobj->field.name = type_name_no_tag (newobj->field.type);
+      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 == ';')
@@ -3216,8 +3187,8 @@ read_baseclasses (struct field_info *fip, const 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, const 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)
 {
   const char *p;
 
 {
   const char *p;
 
@@ -3299,7 +3270,7 @@ read_tilde_fields (struct field_info *fip, const 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;
 
@@ -3318,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;
@@ -3487,11 +3458,7 @@ static struct type *
 read_struct_type (const char **pp, struct type *type, enum type_code type_code,
                   struct objfile *objfile)
 {
 read_struct_type (const char **pp, struct type *type, enum type_code type_code,
                   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:
@@ -3513,8 +3480,6 @@ read_struct_type (const 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;
@@ -3526,10 +3491,7 @@ read_struct_type (const 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);
   }
 
@@ -3548,7 +3510,6 @@ read_struct_type (const 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);
 }
 
@@ -3609,7 +3570,7 @@ read_array_type (const char **pp, struct type *type,
     }
 
   range_type =
     }
 
   range_type =
-    create_static_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;
@@ -3641,10 +3602,10 @@ read_enum_type (const 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;
 
@@ -3669,15 +3630,15 @@ read_enum_type (const char **pp, struct type *type,
       p = *pp;
       while (*p != ':')
        p++;
       p = *pp;
       while (*p != ':')
        p++;
-      name = (char *) 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;
@@ -3722,7 +3683,7 @@ read_enum_type (const 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;
        }
@@ -3921,7 +3882,7 @@ read_huge_number (const char **pp, int end, int *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))
@@ -4236,7 +4197,7 @@ handle_true_range:
     }
 
   result_type
     }
 
   result_type
-    = create_static_range_type ((struct type *) NULL, index_type, n2, n3);
+    = create_static_range_type (NULL, index_type, n2, n3);
   return (result_type);
 }
 
   return (result_type);
 }
 
@@ -4315,10 +4276,9 @@ common_block_start (const char *name, struct objfile *objfile)
     {
       complaint (_("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 = (char *) 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.  */
@@ -4345,13 +4305,13 @@ common_block_end (struct objfile *objfile)
 
   sym = allocate_symbol (objfile);
   /* Note: common_block_name already saved on objfile_obstack.  */
 
   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)
     {
        next != NULL && next != common_block;
        next = next->next)
     {
@@ -4372,7 +4332,7 @@ common_block_end (struct objfile *objfile)
   /* 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;
@@ -4392,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
@@ -4544,7 +4506,7 @@ cleanup_undefined_types_1 (void)
                    complaint (_("need a type name"));
                    break;
                  }
                    complaint (_("need a type name"));
                    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++)
                      {
@@ -4556,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),
-                                      type_name) == 0)
+                           && strcmp (sym->linkage_name (), type_name) == 0)
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
@@ -4578,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
@@ -4588,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;
 
@@ -4622,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;
 
@@ -4642,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 (MSYMBOL_LINKAGE_NAME (msymbol));
+         hash = hashname (msymbol->linkage_name ());
 
          for (sym = global_sym_chain[hash]; sym;)
            {
 
          for (sym = global_sym_chain[hash]; sym;)
            {
-             if (strcmp (MSYMBOL_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.  */
@@ -4673,8 +4630,9 @@ scan_file_globals (struct objfile *objfile)
                        }
                      else
                        {
                        }
                      else
                        {
-                         SYMBOL_VALUE_ADDRESS (sym)
-                           = MSYMBOL_VALUE_ADDRESS (resolve_objfile, msymbol);
+                         SET_SYMBOL_VALUE_ADDRESS
+                           (sym, MSYMBOL_VALUE_ADDRESS (resolve_objfile,
+                                                        msymbol));
                        }
                      SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
                    }
                        }
                      SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
                    }
@@ -4712,7 +4670,7 @@ 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)
 
          /* Complain about unresolved common block symbols.  */
          if (SYMBOL_CLASS (prev) == LOC_STATIC)
@@ -4720,7 +4678,7 @@ scan_file_globals (struct objfile *objfile)
          else
            complaint (_("%s: common block `%s' from "
                         "global_sym_chain unresolved"),
          else
            complaint (_("%s: common block `%s' from "
                         "global_sym_chain unresolved"),
-                      objfile_name (objfile), 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));
@@ -4757,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;
@@ -4781,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;
     }
@@ -4814,13 +4773,19 @@ find_name_end (const 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 = XNEWVEC (struct type *, undef_types_allocated);
   undef_types_allocated = 20;
   undef_types_length = 0;
   undef_types = XNEWVEC (struct type *, undef_types_allocated);
GDB Binutils - Deliverables
This page took 0.042785 seconds and 4 git commands to generate.