gdb: add type::num_fields / type::set_num_fields

[deliverable/binutils-gdb.git] / gdb / coffread.c

diff --git a/gdb/coffread.c b/gdb/coffread.c
index 7fbdcc4f68fb6742634d328bfd5e73ef26a87cb3..2732421a35cd5d2ccb59e2c7ff18b98c85198750 100644 (file)
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1455,7 +1455,7 @@ patch_type (struct type *type, struct type *real_type)
   int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
 
   TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
-  TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
+  target->set_num_fields (TYPE_NFIELDS (real_target));
   TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target,
                                                      field_size);
 
@@ -1463,13 +1463,12 @@ patch_type (struct type *type, struct type *real_type)
          TYPE_FIELDS (real_target), 
          field_size);
 
-  if (TYPE_NAME (real_target))
+  if (real_target->name ())
     {
       /* The previous copy of TYPE_NAME is allocated by
         process_coff_symbol.  */
-      if (TYPE_NAME (target))
-       xfree ((char*) TYPE_NAME (target));
-      TYPE_NAME (target) = xstrdup (TYPE_NAME (real_target));
+      xfree ((char *) target->name ());
+      target->set_name (xstrdup (real_target->name ()));
     }
 }
 
@@ -1494,7 +1493,7 @@ patch_opaque_types (struct symtab *s)
          from different files with the same name.  */
       if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF
          && SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN
-         && TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR
+         && SYMBOL_TYPE (real_sym)->code () == TYPE_CODE_PTR
          && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
        {
          const char *name = real_sym->linkage_name ();
@@ -1556,7 +1555,7 @@ process_coff_symbol (struct coff_symbol *cs,
                     union internal_auxent *aux,
                     struct objfile *objfile)
 {
-  struct symbol *sym = allocate_symbol (objfile);
+  struct symbol *sym = new (&objfile->objfile_obstack) symbol;
   char *name;
 
   name = cs->c_name;
@@ -1658,10 +1657,10 @@ process_coff_symbol (struct coff_symbol *cs,
          SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 
          /* If type has no name, give it one.  */
-         if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+         if (SYMBOL_TYPE (sym)->name () == 0)
            {
-             if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
-                 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+             if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
+                 || 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
@@ -1684,8 +1683,7 @@ process_coff_symbol (struct coff_symbol *cs,
                  ;
                }
              else
-               TYPE_NAME (SYMBOL_TYPE (sym)) =
-                 xstrdup (sym->linkage_name ());
+               SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
            }
 
          /* Keep track of any type which points to empty structured
@@ -1694,10 +1692,10 @@ process_coff_symbol (struct coff_symbol *cs,
             not an empty structured type, though; the forward
             references work themselves out via the magic of
             coff_lookup_type.  */
-         if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
+         if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
              && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0
-             && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym)))
-                != TYPE_CODE_UNDEF)
+             && TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))->code ()
+             != TYPE_CODE_UNDEF)
            {
              int i = hashname (sym->linkage_name ());
 
@@ -1716,11 +1714,11 @@ process_coff_symbol (struct coff_symbol *cs,
          /* Some compilers try to be helpful by inventing "fake"
             names for anonymous enums, structures, and unions, like
             "~0fake" or ".0fake".  Thanks, but no thanks...  */
-         if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+         if (SYMBOL_TYPE (sym)->name () == 0)
            if (sym->linkage_name () != NULL
                && *sym->linkage_name () != '~'
                && *sym->linkage_name () != '.')
-             TYPE_NAME (SYMBOL_TYPE (sym)) = xstrdup (sym->linkage_name ());
+             SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
 
          add_symbol_to_list (sym, get_file_symbols ());
          break;
@@ -1880,12 +1878,12 @@ decode_base_type (struct coff_symbol *cs,
        {
          /* Anonymous structure type.  */
          type = coff_alloc_type (cs->c_symnum);
-         TYPE_CODE (type) = TYPE_CODE_STRUCT;
-         TYPE_NAME (type) = NULL;
+         type->set_code (TYPE_CODE_STRUCT);
+         type->set_name (NULL);
          INIT_CPLUS_SPECIFIC (type);
          TYPE_LENGTH (type) = 0;
          TYPE_FIELDS (type) = 0;
-         TYPE_NFIELDS (type) = 0;
+         type->set_num_fields (0);
        }
       else
        {
@@ -1901,11 +1899,11 @@ decode_base_type (struct coff_symbol *cs,
        {
          /* Anonymous union type.  */
          type = coff_alloc_type (cs->c_symnum);
-         TYPE_NAME (type) = NULL;
+         type->set_name (NULL);
          INIT_CPLUS_SPECIFIC (type);
          TYPE_LENGTH (type) = 0;
          TYPE_FIELDS (type) = 0;
-         TYPE_NFIELDS (type) = 0;
+         type->set_num_fields (0);
        }
       else
        {
@@ -1914,7 +1912,7 @@ decode_base_type (struct coff_symbol *cs,
                                        aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
                                        objfile);
        }
-      TYPE_CODE (type) = TYPE_CODE_UNION;
+      type->set_code (TYPE_CODE_UNION);
       return type;
 
     case T_ENUM:
@@ -1922,11 +1920,11 @@ decode_base_type (struct coff_symbol *cs,
        {
          /* Anonymous enum type.  */
          type = coff_alloc_type (cs->c_symnum);
-         TYPE_CODE (type) = TYPE_CODE_ENUM;
-         TYPE_NAME (type) = NULL;
+         type->set_code (TYPE_CODE_ENUM);
+         type->set_name (NULL);
          TYPE_LENGTH (type) = 0;
          TYPE_FIELDS (type) = 0;
-         TYPE_NFIELDS (type) = 0;
+         type->set_num_fields (0);
        }
       else
        {
@@ -1990,7 +1988,7 @@ coff_read_struct_type (int index, int length, int lastsym,
   int done = 0;
 
   type = coff_alloc_type (index);
-  TYPE_CODE (type) = TYPE_CODE_STRUCT;
+  type->set_code (TYPE_CODE_STRUCT);
   INIT_CPLUS_SPECIFIC (type);
   TYPE_LENGTH (type) = length;
 
@@ -2042,7 +2040,7 @@ coff_read_struct_type (int index, int length, int lastsym,
     }
   /* Now create the vector of fields, and record how big it is.  */
 
-  TYPE_NFIELDS (type) = nfields;
+  type->set_num_fields (nfields);
   TYPE_FIELDS (type) = (struct field *)
     TYPE_ALLOC (type, sizeof (struct field) * nfields);
 
@@ -2095,7 +2093,7 @@ coff_read_enum_type (int index, int length, int lastsym,
       switch (ms->c_sclass)
        {
        case C_MOE:
-         sym = allocate_symbol (objfile);
+         sym = new (&objfile->objfile_obstack) symbol;
 
          name = obstack_strdup (&objfile->objfile_obstack, name);
          sym->set_linkage_name (name);
@@ -2121,8 +2119,8 @@ coff_read_enum_type (int index, int length, int lastsym,
     TYPE_LENGTH (type) = length;
   else /* Assume ints.  */
     TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
-  TYPE_CODE (type) = TYPE_CODE_ENUM;
-  TYPE_NFIELDS (type) = nsyms;
+  type->set_code (TYPE_CODE_ENUM);
+  type->set_num_fields (nsyms);
   TYPE_FIELDS (type) = (struct field *)
     TYPE_ALLOC (type, sizeof (struct field) * nsyms);