projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
gdb: add target_ops::supports_displaced_step
[deliverable/binutils-gdb.git] / gdb / stabsread.c
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 27414a9812aa2414cc35b7f9d85fa709a55053c9..179a0fb610bc8f9b2d1330ec924db8b5875f1999 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-2019 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -42,6 +42,7 @@
 #include "gdb-demangle.h"
 #include "language.h"
 #include "target-float.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>
@@ -368,7 +369,7 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
 static struct type *
 dbx_init_float_type (struct objfile *objfile, int bits)
 {
 static struct type *
 dbx_init_float_type (struct objfile *objfile, int bits)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = objfile->arch ();
   const struct floatformat **format;
   struct type *type;
 
   const struct floatformat **format;
   struct type *type;
 
@@ -422,12 +423,11 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
              /* On xcoff, if a global is defined and never referenced,
                 ld will remove it from the executable.  There is then
                 a N_GSYM stab for it, but no regular (C_EXT) symbol.  */
              /* On xcoff, if a global is defined and never referenced,
                 ld will remove it from the executable.  There is then
                 a N_GSYM stab for it, but no regular (C_EXT) symbol.  */
-             sym = allocate_symbol (objfile);
+             sym = new (&objfile->objfile_obstack) symbol;
              SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
              SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
              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')
                {
@@ -628,7 +628,7 @@ stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
   if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
     {
       reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
   if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
     {
       reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
-                          SYMBOL_PRINT_NAME (sym));
+                          sym->print_name ());
 
       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
     }
 
       regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless.  */
     }
@@ -649,7 +649,7 @@ struct symbol *
 define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
               struct objfile *objfile)
 {
 define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
               struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = objfile->arch ();
   struct symbol *sym;
   const char *p = find_name_end (string);
   int deftype;
   struct symbol *sym;
   const char *p = find_name_end (string);
   int deftype;
@@ -687,7 +687,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
      e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
   nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
 
      e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
   nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
 
-  current_symbol = sym = allocate_symbol (objfile);
+  current_symbol = sym = new (&objfile->objfile_obstack) symbol;
 
   if (processing_gcc_compilation)
     {
 
   if (processing_gcc_compilation)
     {
@@ -700,8 +700,8 @@ 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, get_current_subfile ()->language,
-                      &objfile->objfile_obstack);
+  sym->set_language (get_current_subfile ()->language,
+                    &objfile->objfile_obstack);
 
   if (is_cplus_marker (string[0]))
     {
 
   if (is_cplus_marker (string[0]))
     {
@@ -709,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 '_':
@@ -738,9 +738,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
   else
     {
     normal:
   else
     {
     normal:
-      std::string new_name;
+      gdb::unique_xmalloc_ptr<char> new_name;
 
 
-      if (SYMBOL_LANGUAGE (sym) == language_cplus)
+      if (sym->language () == language_cplus)
        {
          char *name = (char *) alloca (p - string + 1);
 
        {
          char *name = (char *) alloca (p - string + 1);
 
@@ -748,16 +748,13 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
          name[p - string] = '\0';
          new_name = cp_canonicalize_string (name);
        }
          name[p - string] = '\0';
          new_name = cp_canonicalize_string (name);
        }
-      if (!new_name.empty ())
-       {
-         SYMBOL_SET_NAMES (sym,
-                           new_name.c_str (), new_name.length (),
-                           1, objfile);
-       }
+      if (new_name != nullptr)
+       sym->compute_and_set_names (new_name.get (), true, objfile->per_bfd);
       else
       else
-       SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile);
+       sym->compute_and_set_names (gdb::string_view (string, p - string), true,
+                                   objfile->per_bfd);
 
 
-      if (SYMBOL_LANGUAGE (sym) == language_cplus)
+      if (sym->language () == language_cplus)
        cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
                                          objfile);
 
        cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
                                          objfile);
 
@@ -942,7 +939,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_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;
+      SET_SYMBOL_VALUE_ADDRESS (sym, valu);
       add_symbol_to_list (sym, get_local_symbols ());
       break;
 
       add_symbol_to_list (sym, get_local_symbols ());
       break;
 
@@ -958,7 +955,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       /* Function result types are described as the result type in stabs.
          We need to convert this to the function-returning-type-X type
          in GDB.  E.g. "int" is converted to "function returning int".  */
       /* Function result types are described as the result type in stabs.
          We need to convert this to the function-returning-type-X type
          in GDB.  E.g. "int" is converted to "function returning int".  */
-      if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
+      if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_FUNC)
        SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
 
       /* All functions in C++ have prototypes.  Stabs does not offer an
        SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
 
       /* All functions in C++ have prototypes.  Stabs does not offer an
@@ -989,8 +986,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
            }
 
          /* Allocate parameter information fields and fill them in.  */
            }
 
          /* Allocate parameter information fields and fill them in.  */
-         TYPE_FIELDS (ftype) = (struct field *)
-           TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
+         ftype->set_fields
+           ((struct field *)
+            TYPE_ALLOC (ftype, nsemi * sizeof (struct field)));
          while (*p++ == ';')
            {
              struct type *ptype;
          while (*p++ == ';')
            {
              struct type *ptype;
@@ -1007,12 +1005,12 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
                 a TYPE_CODE_VOID type by read_type, and we have to turn
                 it back into builtin_int here.
                 FIXME: Do we need a new builtin_promoted_int_arg ?  */
                 a TYPE_CODE_VOID type by read_type, and we have to turn
                 it back into builtin_int here.
                 FIXME: Do we need a new builtin_promoted_int_arg ?  */
-             if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
+             if (ptype->code () == TYPE_CODE_VOID)
                ptype = objfile_type (objfile)->builtin_int;
              TYPE_FIELD_TYPE (ftype, nparams) = ptype;
              TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
            }
                ptype = objfile_type (objfile)->builtin_int;
              TYPE_FIELD_TYPE (ftype, nparams) = ptype;
              TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
            }
-         TYPE_NFIELDS (ftype) = nparams;
+         ftype->set_num_fields (nparams);
          TYPE_PROTOTYPED (ftype) = 1;
        }
       break;
          TYPE_PROTOTYPED (ftype) = 1;
        }
       break;
@@ -1037,9 +1035,9 @@ 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;
        }
@@ -1096,7 +1094,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
             really an int.  */
          if (TYPE_LENGTH (SYMBOL_TYPE (sym))
              < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
             really an int.  */
          if (TYPE_LENGTH (SYMBOL_TYPE (sym))
              < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
-             && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
+             && SYMBOL_TYPE (sym)->code () == TYPE_CODE_INT)
            {
              SYMBOL_TYPE (sym) =
                TYPE_UNSIGNED (SYMBOL_TYPE (sym))
            {
              SYMBOL_TYPE (sym) =
                TYPE_UNSIGNED (SYMBOL_TYPE (sym))
@@ -1140,8 +1138,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.
 
@@ -1166,8 +1163,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
@@ -1188,23 +1185,22 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       /* Static symbol at top level of file.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
       /* 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;
@@ -1226,7 +1222,7 @@ define_symbol (CORE_ADDR valu, const 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);
@@ -1243,9 +1239,9 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
          a base type which did not have its name defined when the
          derived class was output.  We fill in the derived class's
          base part member's name here in that case.  */
          a base type which did not have its name defined when the
          derived class was output.  We fill in the derived class's
          base part member's name here in that case.  */
-      if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
-       if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
-            || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
+      if (SYMBOL_TYPE (sym)->name () != NULL)
+       if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT
+            || SYMBOL_TYPE (sym)->code () == TYPE_CODE_UNION)
            && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
          {
            int j;
            && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
          {
            int j;
@@ -1253,19 +1249,14 @@ 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 (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
+                 TYPE_BASECLASS (SYMBOL_TYPE (sym), j)->name ();
          }
 
          }
 
-      if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
+      if (SYMBOL_TYPE (sym)->name () == 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
-              && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
-             || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+         if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
+              && strcmp (sym->linkage_name (), vtbl_ptr_name))
+             || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC)
            {
              /* If we are giving a name to a type such as "pointer to
                 foo" or "function returning foo", we better not set
            {
              /* If we are giving a name to a type such as "pointer to
                 foo" or "function returning foo", we better not set
@@ -1304,12 +1295,10 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
              /* Pascal accepts names for pointer types.  */
              if (get_current_subfile ()->language == language_pascal)
 
              /* Pascal accepts names for pointer types.  */
              if (get_current_subfile ()->language == language_pascal)
-               {
-                 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
-               }
+               SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
            }
          else
            }
          else
-           TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
+           SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
        }
 
       add_symbol_to_list (sym, get_file_symbols ());
        }
 
       add_symbol_to_list (sym, get_file_symbols ());
@@ -1317,20 +1306,19 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
       if (synonym)
         {
           /* Create the STRUCT_DOMAIN clone.  */
       if (synonym)
         {
           /* Create the STRUCT_DOMAIN clone.  */
-          struct symbol *struct_sym = allocate_symbol (objfile);
+          struct symbol *struct_sym = new (&objfile->objfile_obstack) symbol;
 
           *struct_sym = *sym;
           SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
           SYMBOL_VALUE (struct_sym) = valu;
           SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
 
           *struct_sym = *sym;
           SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
           SYMBOL_VALUE (struct_sym) = valu;
           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),
-                         (char *) NULL);
+          if (SYMBOL_TYPE (sym)->name () == 0)
+           SYMBOL_TYPE (sym)->set_name
+             (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+                        (char *) NULL));
           add_symbol_to_list (struct_sym, get_file_symbols ());
         }
           add_symbol_to_list (struct_sym, get_file_symbols ());
         }
-      
+
       break;
 
     case 'T':
       break;
 
     case 'T':
@@ -1351,27 +1339,25 @@ define_symbol (CORE_ADDR valu, const 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_NAME (SYMBOL_TYPE (sym)) == 0)
-       TYPE_NAME (SYMBOL_TYPE (sym))
-         = obconcat (&objfile->objfile_obstack,
-                     SYMBOL_LINKAGE_NAME (sym),
-                     (char *) NULL);
+      if (SYMBOL_TYPE (sym)->name () == 0)
+       SYMBOL_TYPE (sym)->set_name
+         (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+                    (char *) NULL));
       add_symbol_to_list (sym, get_file_symbols ());
 
       if (synonym)
        {
          /* Clone the sym and then modify it.  */
       add_symbol_to_list (sym, get_file_symbols ());
 
       if (synonym)
        {
          /* Clone the sym and then modify it.  */
-         struct symbol *typedef_sym = allocate_symbol (objfile);
+         struct symbol *typedef_sym = new (&objfile->objfile_obstack) symbol;
 
          *typedef_sym = *sym;
          SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
          SYMBOL_VALUE (typedef_sym) = valu;
          SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
 
          *typedef_sym = *sym;
          SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
          SYMBOL_VALUE (typedef_sym) = valu;
          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),
-                         (char *) NULL);
+         if (SYMBOL_TYPE (sym)->name () == 0)
+           SYMBOL_TYPE (sym)->set_name
+             (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+                        (char *) NULL));
          add_symbol_to_list (typedef_sym, get_file_symbols ());
        }
       break;
          add_symbol_to_list (typedef_sym, get_file_symbols ());
        }
       break;
@@ -1380,23 +1366,21 @@ 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;
@@ -1563,7 +1547,7 @@ read_type (const char **pp, struct objfile *objfile)
           /* If this is a forward reference, arrange to complain if it
              doesn't get patched up by the time we're done
              reading.  */
           /* If this is a forward reference, arrange to complain if it
              doesn't get patched up by the time we're done
              reading.  */
-          if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
+          if (type->code () == TYPE_CODE_UNDEF)
             add_undefined_type (type, typenums);
 
           return type;
             add_undefined_type (type, typenums);
 
           return type;
@@ -1652,14 +1636,10 @@ again:
              memcpy (name, *pp, p - *pp);
              name[p - *pp] = '\0';
 
              memcpy (name, *pp, p - *pp);
              name[p - *pp] = '\0';
 
-             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 ());
-               }
+             gdb::unique_xmalloc_ptr<char> new_name = cp_canonicalize_string (name);
+             if (new_name != nullptr)
+               type_name = obstack_strdup (&objfile->objfile_obstack,
+                                           new_name.get ());
            }
          if (type_name == NULL)
            {
            }
          if (type_name == NULL)
            {
@@ -1689,8 +1669,8 @@ again:
 
              if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                  && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
 
              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)
+                 && (SYMBOL_TYPE (sym)->code () == code)
+                 && 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);
@@ -1706,8 +1686,8 @@ again:
           fill in the rest of the fields when we get the full
           type.  */
        type = dbx_alloc_type (typenums, objfile);
           fill in the rest of the fields when we get the full
           type.  */
        type = dbx_alloc_type (typenums, objfile);
-       TYPE_CODE (type) = code;
-       TYPE_NAME (type) = type_name;
+       type->set_code (code);
+       type->set_name (type_name);
        INIT_CPLUS_SPECIFIC (type);
        TYPE_STUB (type) = 1;
 
        INIT_CPLUS_SPECIFIC (type);
        TYPE_STUB (type) = 1;
 
@@ -1735,14 +1715,14 @@ again:
       /* Allocate and enter the typedef type first.
          This handles recursive types.  */
       type = dbx_alloc_type (typenums, objfile);
       /* Allocate and enter the typedef type first.
          This handles recursive types.  */
       type = dbx_alloc_type (typenums, objfile);
-      TYPE_CODE (type) = TYPE_CODE_TYPEDEF;
+      type->set_code (TYPE_CODE_TYPEDEF);
       {
        struct type *xtype = read_type (pp, objfile);
 
        if (type == xtype)
          {
            /* It's being defined as itself.  That means it is "void".  */
       {
        struct type *xtype = read_type (pp, objfile);
 
        if (type == xtype)
          {
            /* It's being defined as itself.  That means it is "void".  */
-           TYPE_CODE (type) = TYPE_CODE_VOID;
+           type->set_code (TYPE_CODE_VOID);
            TYPE_LENGTH (type) = 1;
          }
        else if (type_size >= 0 || is_string)
            TYPE_LENGTH (type) = 1;
          }
        else if (type_size >= 0 || is_string)
@@ -1771,7 +1751,7 @@ again:
                "complete_this_type" function, but never create unnecessary
                copies of a type otherwise.  */
            replace_type (type, xtype);
                "complete_this_type" function, but never create unnecessary
                copies of a type otherwise.  */
            replace_type (type, xtype);
-           TYPE_NAME (type) = NULL;
+           type->set_name (NULL);
          }
        else
          {
          }
        else
          {
@@ -1854,13 +1834,13 @@ again:
            that's just an empty argument list.  */
         if (arg_types
             && ! arg_types->next
            that's just an empty argument list.  */
         if (arg_types
             && ! arg_types->next
-            && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
+            && arg_types->type->code () == TYPE_CODE_VOID)
           num_args = 0;
 
           num_args = 0;
 
-        TYPE_FIELDS (func_type)
-          = (struct field *) TYPE_ALLOC (func_type,
-                                         num_args * sizeof (struct field));
-        memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field));
+       func_type->set_fields
+         ((struct field *) TYPE_ALLOC (func_type,
+                                       num_args * sizeof (struct field)));
+        memset (func_type->fields (), 0, num_args * sizeof (struct field));
         {
           int i;
           struct type_list *t;
         {
           int i;
           struct type_list *t;
@@ -1871,7 +1851,7 @@ again:
           for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
             TYPE_FIELD_TYPE (func_type, i) = t->type;
         }
           for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
             TYPE_FIELD_TYPE (func_type, i) = t->type;
         }
-        TYPE_NFIELDS (func_type) = num_args;
+        func_type->set_num_fields (num_args);
         TYPE_PROTOTYPED (func_type) = 1;
 
         type = func_type;
         TYPE_PROTOTYPED (func_type) = 1;
 
         type = func_type;
@@ -2041,14 +2021,14 @@ again:
       type = dbx_alloc_type (typenums, objfile);
       type = read_array_type (pp, type, objfile);
       if (is_string)
       type = dbx_alloc_type (typenums, objfile);
       type = read_array_type (pp, type, objfile);
       if (is_string)
-       TYPE_CODE (type) = TYPE_CODE_STRING;
+       type->set_code (TYPE_CODE_STRING);
       if (is_vector)
        make_vector_type (type);
       break;
 
     case 'S':                  /* Set type */
       type1 = read_type (pp, objfile);
       if (is_vector)
        make_vector_type (type);
       break;
 
     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;
@@ -2205,12 +2185,12 @@ rs6000_builtin_type (int typenum, struct objfile *objfile)
       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_complex_type (objfile, "complex",
+      rettype = init_complex_type ("complex",
                                   rs6000_builtin_type (12, objfile));
       break;
     case 26:
       /* Complex type consisting of two IEEE double precision values.  */
                                   rs6000_builtin_type (12, objfile));
       break;
     case 26:
       /* Complex type consisting of two IEEE double precision values.  */
-      rettype = init_complex_type (objfile, "double complex",
+      rettype = init_complex_type ("double complex",
                                   rs6000_builtin_type (13, objfile));
       break;
     case 27:
                                   rs6000_builtin_type (13, objfile));
       break;
     case 27:
@@ -2388,10 +2368,10 @@ read_member_functions (struct stab_field_info *fip, const char **pp,
            }
 
          /* These are methods, not functions.  */
            }
 
          /* 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;
+         if (new_sublist->fn_field.type->code () == TYPE_CODE_FUNC)
+           new_sublist->fn_field.type->set_code (TYPE_CODE_METHOD);
          else
          else
-           gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
+           gdb_assert (new_sublist->fn_field.type->code ()
                        == TYPE_CODE_METHOD);
 
          /* If this is just a stub, then we don't have the real name here.  */
                        == TYPE_CODE_METHOD);
 
          /* If this is just a stub, then we don't have the real name here.  */
@@ -2769,7 +2749,7 @@ read_cpp_abbrev (struct stab_field_info *fip, const char **pp,
       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 (context);
+         name = context->name ();
          if (name == NULL)
            {
              name = "";
          if (name == NULL)
            {
              name = "";
@@ -2779,7 +2759,7 @@ read_cpp_abbrev (struct stab_field_info *fip, const char **pp,
          break;
 
        case 'b':               /* $vb -- a virtual bsomethingorother */
          break;
 
        case 'b':               /* $vb -- a virtual bsomethingorother */
-         name = TYPE_NAME (context);
+         name = context->name ();
          if (name == NULL)
            {
              complaint (_("C++ abbreviated type name "
          if (name == NULL)
            {
              complaint (_("C++ abbreviated type name "
@@ -2842,10 +2822,10 @@ read_one_struct_field (struct stab_field_info *fip, const char **pp,
                       const char *p, struct type *type,
                       struct objfile *objfile)
 {
                       const char *p, struct type *type,
                       struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = objfile->arch ();
 
   fip->list->field.name
 
   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.  */
@@ -2939,16 +2919,16 @@ read_one_struct_field (struct stab_field_info *fip, const char **pp,
 
       struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
 
 
       struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
 
-      if (TYPE_CODE (field_type) != TYPE_CODE_INT
-         && TYPE_CODE (field_type) != TYPE_CODE_RANGE
-         && TYPE_CODE (field_type) != TYPE_CODE_BOOL
-         && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
+      if (field_type->code () != TYPE_CODE_INT
+         && field_type->code () != TYPE_CODE_RANGE
+         && field_type->code () != TYPE_CODE_BOOL
+         && field_type->code () != TYPE_CODE_ENUM)
        {
          FIELD_BITSIZE (fip->list->field) = 0;
        }
       if ((FIELD_BITSIZE (fip->list->field)
           == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
        {
          FIELD_BITSIZE (fip->list->field) = 0;
        }
       if ((FIELD_BITSIZE (fip->list->field)
           == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
-          || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
+          || (field_type->code () == TYPE_CODE_ENUM
               && FIELD_BITSIZE (fip->list->field)
                  == gdbarch_int_bit (gdbarch))
          )
               && FIELD_BITSIZE (fip->list->field)
                  == gdbarch_int_bit (gdbarch))
          )
@@ -3182,7 +3162,7 @@ read_baseclasses (struct stab_field_info *fip, const char **pp,
          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 (newobj->field.type);
+      newobj->field.name = newobj->field.type->name ();
 
       /* Skip trailing ';' and bump count of number of fields seen.  */
       if (**pp == ';')
 
       /* Skip trailing ';' and bump count of number of fields seen.  */
       if (**pp == ';')
@@ -3253,7 +3233,7 @@ read_tilde_fields (struct stab_field_info *fip, const char **pp,
          set_type_vptr_basetype (type, t);
          if (type == t)        /* Our own class provides vtbl ptr.  */
            {
          set_type_vptr_basetype (type, t);
          if (type == t)        /* Our own class provides vtbl ptr.  */
            {
-             for (i = TYPE_NFIELDS (t) - 1;
+             for (i = t->num_fields () - 1;
                   i >= TYPE_N_BASECLASSES (t);
                   --i)
                {
                   i >= TYPE_N_BASECLASSES (t);
                   --i)
                {
@@ -3269,7 +3249,7 @@ read_tilde_fields (struct stab_field_info *fip, const char **pp,
              /* Virtual function table field not found.  */
              complaint (_("virtual function table pointer "
                           "not found when defining class `%s'"),
              /* Virtual function table field not found.  */
              complaint (_("virtual function table pointer "
                           "not found when defining class `%s'"),
-                        TYPE_NAME (type));
+                        type->name ());
              return 0;
            }
          else
              return 0;
            }
          else
@@ -3329,10 +3309,11 @@ attach_fields_to_type (struct stab_field_info *fip, struct type *type,
      non-public fields.  Record the field count, allocate space for the
      array of fields, and create blank visibility bitfields if necessary.  */
 
      non-public fields.  Record the field count, allocate space for the
      array of fields, and create blank visibility bitfields if necessary.  */
 
-  TYPE_NFIELDS (type) = nfields;
-  TYPE_FIELDS (type) = (struct field *)
-    TYPE_ALLOC (type, sizeof (struct field) * nfields);
-  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
+  type->set_num_fields (nfields);
+  type->set_fields
+    ((struct field *)
+     TYPE_ALLOC (type, sizeof (struct field) * nfields));
+  memset (type->fields (), 0, sizeof (struct field) * nfields);
 
   if (non_public_fields)
     {
 
   if (non_public_fields)
     {
@@ -3358,7 +3339,7 @@ attach_fields_to_type (struct stab_field_info *fip, struct type *type,
 
   while (nfields-- > 0)
     {
 
   while (nfields-- > 0)
     {
-      TYPE_FIELD (type, nfields) = fip->list->field;
+      type->field (nfields) = fip->list->field;
       switch (fip->list->visibility)
        {
        case VISIBILITY_PRIVATE:
       switch (fip->list->visibility)
        {
        case VISIBILITY_PRIVATE:
@@ -3398,10 +3379,10 @@ complain_about_struct_wipeout (struct type *type)
   const char *name = "";
   const char *kind = "";
 
   const char *name = "";
   const char *kind = "";
 
-  if (TYPE_NAME (type))
+  if (type->name ())
     {
     {
-      name = TYPE_NAME (type);
-      switch (TYPE_CODE (type))
+      name = type->name ();
+      switch (type->code ())
         {
         case TYPE_CODE_STRUCT: kind = "struct "; break;
         case TYPE_CODE_UNION:  kind = "union ";  break;
         {
         case TYPE_CODE_STRUCT: kind = "struct "; break;
         case TYPE_CODE_UNION:  kind = "union ";  break;
@@ -3486,7 +3467,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code,
      Obviously, GDB can't fix this by itself, but it can at least avoid
      scribbling on existing structure type objects when new definitions
      appear.  */
      Obviously, GDB can't fix this by itself, but it can at least avoid
      scribbling on existing structure type objects when new definitions
      appear.  */
-  if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
+  if (! (type->code () == TYPE_CODE_UNDEF
          || TYPE_STUB (type)))
     {
       complain_about_struct_wipeout (type);
          || TYPE_STUB (type)))
     {
       complain_about_struct_wipeout (type);
@@ -3496,7 +3477,7 @@ read_struct_type (const char **pp, struct type *type, enum type_code type_code,
     }
 
   INIT_CPLUS_SPECIFIC (type);
     }
 
   INIT_CPLUS_SPECIFIC (type);
-  TYPE_CODE (type) = type_code;
+  type->set_code (type_code);
   TYPE_STUB (type) = 0;
 
   /* First comes the total size in bytes.  */
   TYPE_STUB (type) = 0;
 
   /* First comes the total size in bytes.  */
@@ -3585,7 +3566,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;
@@ -3600,7 +3581,7 @@ static struct type *
 read_enum_type (const char **pp, struct type *type,
                struct objfile *objfile)
 {
 read_enum_type (const char **pp, struct type *type,
                struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = objfile->arch ();
   const char *p;
   char *name;
   long n;
   const char *p;
   char *name;
   long n;
@@ -3645,16 +3626,16 @@ 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);
 
       *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, get_current_subfile ()->language,
-                          &objfile->objfile_obstack);
+      sym = new (&objfile->objfile_obstack) symbol;
+      sym->set_linkage_name (name);
+      sym->set_language (get_current_subfile ()->language,
+                        &objfile->objfile_obstack);
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_VALUE (sym) = n;
       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_VALUE (sym) = n;
@@ -3671,14 +3652,15 @@ read_enum_type (const char **pp, struct type *type,
 
   TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
   set_length_in_type_chain (type);
 
   TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
   set_length_in_type_chain (type);
-  TYPE_CODE (type) = TYPE_CODE_ENUM;
+  type->set_code (TYPE_CODE_ENUM);
   TYPE_STUB (type) = 0;
   if (unsigned_enum)
     TYPE_UNSIGNED (type) = 1;
   TYPE_STUB (type) = 0;
   if (unsigned_enum)
     TYPE_UNSIGNED (type) = 1;
-  TYPE_NFIELDS (type) = nsyms;
-  TYPE_FIELDS (type) = (struct field *)
-    TYPE_ALLOC (type, sizeof (struct field) * nsyms);
-  memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
+  type->set_num_fields (nsyms);
+  type->set_fields
+    ((struct field *)
+     TYPE_ALLOC (type, sizeof (struct field) * nsyms));
+  memset (type->fields (), 0, sizeof (struct field) * nsyms);
 
   /* Find the symbols for the values and put them into the type.
      The symbols can be found in the symlist that we put them on
 
   /* Find the symbols for the values and put them into the type.
      The symbols can be found in the symlist that we put them on
@@ -3698,8 +3680,8 @@ 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);
-         SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
+         TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
+         SET_FIELD_ENUMVAL (type->field (n), SYMBOL_VALUE (xsym));
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
       if (syms == osyms)
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
       if (syms == osyms)
@@ -3824,7 +3806,7 @@ read_sun_floating_type (const char **pp, int typenums[2],
       || details == NF_COMPLEX32)
     {
       rettype = dbx_init_float_type (objfile, nbits / 2);
       || details == NF_COMPLEX32)
     {
       rettype = dbx_init_float_type (objfile, nbits / 2);
-      return init_complex_type (objfile, NULL, rettype);
+      return init_complex_type (NULL, rettype);
     }
 
   return dbx_init_float_type (objfile, nbits);
     }
 
   return dbx_init_float_type (objfile, nbits);
@@ -3897,7 +3879,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))
@@ -4016,7 +3998,7 @@ static struct type *
 read_range_type (const char **pp, int typenums[2], int type_size,
                  struct objfile *objfile)
 {
 read_range_type (const char **pp, int typenums[2], int type_size,
                  struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+  struct gdbarch *gdbarch = objfile->arch ();
   const char *orig_pp = *pp;
   int rangenums[2];
   long n2, n3;
   const char *orig_pp = *pp;
   int rangenums[2];
   long n2, n3;
@@ -4118,7 +4100,7 @@ read_range_type (const char **pp, int typenums[2], int type_size,
        = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT);
 
       if (self_subrange)
        = dbx_init_float_type (objfile, n2 * TARGET_CHAR_BIT);
 
       if (self_subrange)
-       return init_complex_type (objfile, NULL, float_type);
+       return init_complex_type (NULL, float_type);
       else
        return float_type;
     }
       else
        return float_type;
     }
@@ -4212,7 +4194,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);
 }
 
@@ -4250,7 +4232,7 @@ read_args (const char **pp, int end, struct objfile *objfile, int *nargsp,
       complaint (_("Invalid (empty) method arguments"));
       *varargsp = 0;
     }
       complaint (_("Invalid (empty) method arguments"));
       *varargsp = 0;
     }
-  else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
+  else if (types[n - 1]->code () != TYPE_CODE_VOID)
     *varargsp = 1;
   else
     {
     *varargsp = 1;
   else
     {
@@ -4293,8 +4275,7 @@ common_block_start (const char *name, struct objfile *objfile)
     }
   common_block = *get_local_symbols ();
   common_block_i = common_block ? common_block->nsyms : 0;
     }
   common_block = *get_local_symbols ();
   common_block_i = common_block ? common_block->nsyms : 0;
-  common_block_name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
-                                             strlen (name));
+  common_block_name = obstack_strdup (&objfile->objfile_obstack, name);
 }
 
 /* Process a N_ECOMM symbol.  */
 }
 
 /* Process a N_ECOMM symbol.  */
@@ -4319,9 +4300,9 @@ common_block_end (struct objfile *objfile)
       return;
     }
 
       return;
     }
 
-  sym = allocate_symbol (objfile);
+  sym = new (&objfile->objfile_obstack) symbol;
   /* Note: common_block_name already saved on objfile_obstack.  */
   /* 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.  */
   SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
 
   /* Now we copy all the symbols which have been defined since the BCOMM.  */
@@ -4348,7 +4329,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;
@@ -4368,7 +4349,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
@@ -4428,7 +4411,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_NAME (type) == NULL)
+  if (type->name () == 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);
@@ -4447,7 +4430,7 @@ cleanup_undefined_types_noname (struct objfile *objfile)
       struct type **type;
 
       type = dbx_lookup_type (nat.typenums, objfile);
       struct type **type;
 
       type = dbx_lookup_type (nat.typenums, objfile);
-      if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
+      if (nat.type != *type && (*type)->code () != TYPE_CODE_UNDEF)
         {
           /* The instance flags of the undefined type are still unset,
              and needs to be copied over from the reference type.
         {
           /* The instance flags of the undefined type are still unset,
              and needs to be copied over from the reference type.
@@ -4497,7 +4480,7 @@ cleanup_undefined_types_1 (void)
 
   for (type = undef_types; type < undef_types + undef_types_length; type++)
     {
 
   for (type = undef_types; type < undef_types + undef_types_length; type++)
     {
-      switch (TYPE_CODE (*type))
+      switch ((*type)->code ())
        {
 
        case TYPE_CODE_STRUCT:
        {
 
        case TYPE_CODE_STRUCT:
@@ -4513,7 +4496,7 @@ 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 *type_name = TYPE_NAME (*type);
+               const char *type_name = (*type)->name ();
 
                if (type_name == NULL)
                  {
 
                if (type_name == NULL)
                  {
@@ -4528,12 +4511,11 @@ cleanup_undefined_types_1 (void)
 
                        if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                            && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
 
                        if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                            && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
-                           && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
-                               TYPE_CODE (*type))
+                           && (SYMBOL_TYPE (sym)->code () ==
+                               (*type)->code ())
                            && (TYPE_INSTANCE_FLAGS (*type) ==
                                TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
                            && (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));
                      }
                  }
@@ -4545,7 +4527,7 @@ cleanup_undefined_types_1 (void)
          {
            complaint (_("forward-referenced types left unresolved, "
                        "type code %d."),
          {
            complaint (_("forward-referenced types left unresolved, "
                        "type code %d."),
-                      TYPE_CODE (*type));
+                      (*type)->code ());
          }
          break;
        }
          }
          break;
        }
@@ -4554,7 +4536,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
@@ -4615,12 +4597,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.  */
@@ -4646,8 +4627,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);
                    }
@@ -4685,7 +4667,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)
@@ -4693,7 +4675,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));
@@ -4793,13 +4775,14 @@ find_name_end (const char *name)
 int
 hashname (const char *name)
 {
 int
 hashname (const char *name)
 {
-  return hash (name, strlen (name)) % HASHSIZE;
+  return fast_hash (name, strlen (name)) % HASHSIZE;
 }
 
 /* Initializer for this module.  */
 
 }
 
 /* Initializer for this module.  */
 
+void _initialize_stabsread ();
 void
 void
-_initialize_stabsread (void)
+_initialize_stabsread ()
 {
   undef_types_allocated = 20;
   undef_types_length = 0;
 {
   undef_types_allocated = 20;
   undef_types_length = 0;
GDB Binutils - Deliverables
This page took 0.046867 seconds and 4 git commands to generate.