projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
include/elf/
[deliverable/binutils-gdb.git] / gdb / stabsread.c
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index e1550878ee137ebf53453103c3c06f121a784320..2d7eb15a96a041519f2d2513691c2296550b1cd8 100644 (file)
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -1,14 +1,14 @@
 /* Support routines for decoding "stabs" debugging information format.
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
 /* Support routines for decoding "stabs" debugging information format.
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
-   Free Software Foundation, Inc.
+   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+   2008, 2009 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -17,9 +17,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Support routines for reading and decoding debugging information in
    the "stabs" format.  This format is used with many systems that use
 
 /* Support routines for reading and decoding debugging information in
    the "stabs" format.  This format is used with many systems that use
@@ -47,6 +45,7 @@
 #include "doublest.h"
 #include "cp-abi.h"
 #include "cp-support.h"
 #include "doublest.h"
 #include "cp-abi.h"
 #include "cp-support.h"
+#include "gdb_assert.h"
 
 #include <ctype.h>
 
 
 #include <ctype.h>
 
@@ -283,15 +282,12 @@ dbx_lookup_type (int typenums[2])
 
       if (real_filenum >= N_HEADER_FILES (current_objfile))
        {
 
       if (real_filenum >= N_HEADER_FILES (current_objfile))
        {
-         struct type *temp_type;
-         struct type **temp_type_p;
+         static struct type **temp_type_p;
 
          warning (_("GDB internal error: bad real_filenum"));
 
        error_return:
 
          warning (_("GDB internal error: bad real_filenum"));
 
        error_return:
-         temp_type = init_type (TYPE_CODE_ERROR, 0, 0, NULL, NULL);
-         temp_type_p = (struct type **) xmalloc (sizeof (struct type *));
-         *temp_type_p = temp_type;
+         temp_type_p = &builtin_type_error;
          return temp_type_p;
        }
 
          return temp_type_p;
        }
 
@@ -364,6 +360,7 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
        {
          name = stabs->stab[ii];
          pp = (char *) strchr (name, ':');
        {
          name = stabs->stab[ii];
          pp = (char *) strchr (name, ':');
+         gdb_assert (pp);      /* Must find a ':' or game's over.  */
          while (pp[1] == ':')
            {
              pp += 2;
          while (pp[1] == ':')
            {
              pp += 2;
@@ -390,8 +387,9 @@ patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs,
              memset (sym, 0, sizeof (struct symbol));
              SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
              SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
              memset (sym, 0, sizeof (struct symbol));
              SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
              SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
-             DEPRECATED_SYMBOL_NAME (sym) =
-               obsavestring (name, pp - name, &objfile->objfile_obstack);
+             SYMBOL_SET_LINKAGE_NAME
+               (sym, obsavestring (name, pp - name,
+                                   &objfile->objfile_obstack));
              pp += 2;
              if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
                {
              pp += 2;
              if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
                {
@@ -585,6 +583,7 @@ struct symbol *
 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
               struct objfile *objfile)
 {
 define_symbol (CORE_ADDR valu, char *string, int desc, int type,
               struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   struct symbol *sym;
   char *p = (char *) find_name_end (string);
   int deftype;
   struct symbol *sym;
   char *p = (char *) find_name_end (string);
   int deftype;
@@ -650,28 +649,29 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       switch (string[1])
        {
        case 't':
       switch (string[1])
        {
        case 't':
-         DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("this", strlen ("this"),
-                                           &objfile->objfile_obstack);
+         SYMBOL_SET_LINKAGE_NAME
+           (sym, obsavestring ("this", strlen ("this"),
+                               &objfile->objfile_obstack));
          break;
 
        case 'v':               /* $vtbl_ptr_type */
          break;
 
        case 'v':               /* $vtbl_ptr_type */
-         /* Was: DEPRECATED_SYMBOL_NAME (sym) = "vptr"; */
          goto normal;
 
        case 'e':
          goto normal;
 
        case 'e':
-         DEPRECATED_SYMBOL_NAME (sym) = obsavestring ("eh_throw", strlen ("eh_throw"),
-                                           &objfile->objfile_obstack);
+         SYMBOL_SET_LINKAGE_NAME
+           (sym, obsavestring ("eh_throw", strlen ("eh_throw"),
+                               &objfile->objfile_obstack));
          break;
 
        case '_':
          /* This was an anonymous type that was never fixed up.  */
          goto normal;
 
          break;
 
        case '_':
          /* This was an anonymous type that was never fixed up.  */
          goto normal;
 
-#ifdef STATIC_TRANSFORM_NAME
        case 'X':
          /* SunPRO (3.0 at least) static variable encoding.  */
        case 'X':
          /* SunPRO (3.0 at least) static variable encoding.  */
-         goto normal;
-#endif
+         if (gdbarch_static_transform_name_p (gdbarch))
+           goto normal;
+         /* ... fall through ... */
 
        default:
          complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
 
        default:
          complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"),
@@ -684,6 +684,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
     normal:
       SYMBOL_LANGUAGE (sym) = current_subfile->language;
       SYMBOL_SET_NAMES (sym, string, p - string, objfile);
     normal:
       SYMBOL_LANGUAGE (sym) = current_subfile->language;
       SYMBOL_SET_NAMES (sym, string, p - string, objfile);
+      if (SYMBOL_LANGUAGE (sym) == language_cplus)
+       cp_scan_for_anonymous_namespaces (sym);
     }
   p++;
 
     }
   p++;
 
@@ -728,24 +730,19 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          {
            double d = atof (p);
            gdb_byte *dbl_valu;
          {
            double d = atof (p);
            gdb_byte *dbl_valu;
+           struct type *dbl_type;
 
            /* FIXME-if-picky-about-floating-accuracy: Should be using
               target arithmetic to get the value.  real.c in GCC
               probably has the necessary code.  */
 
 
            /* FIXME-if-picky-about-floating-accuracy: Should be using
               target arithmetic to get the value.  real.c in GCC
               probably has the necessary code.  */
 
-           /* FIXME: lookup_fundamental_type is a hack.  We should be
-              creating a type especially for the type of float constants.
-              Problem is, what type should it be?
-
-              Also, what should the name of this type be?  Should we
-              be using 'S' constants (see stabs.texinfo) instead?  */
-
-           SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile,
-                                                        FT_DBL_PREC_FLOAT);
+           dbl_type = builtin_type (gdbarch)->builtin_double;
            dbl_valu =
              obstack_alloc (&objfile->objfile_obstack,
            dbl_valu =
              obstack_alloc (&objfile->objfile_obstack,
-                            TYPE_LENGTH (SYMBOL_TYPE (sym)));
-           store_typed_floating (dbl_valu, SYMBOL_TYPE (sym), d);
+                            TYPE_LENGTH (dbl_type));
+           store_typed_floating (dbl_valu, dbl_type, d);
+
+           SYMBOL_TYPE (sym) = dbl_type;
            SYMBOL_VALUE_BYTES (sym) = dbl_valu;
            SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
          }
            SYMBOL_VALUE_BYTES (sym) = dbl_valu;
            SYMBOL_CLASS (sym) = LOC_CONST_BYTES;
          }
@@ -759,22 +756,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
               types; other languages probably should have at least
               unsigned as well as signed constants.  */
 
               types; other languages probably should have at least
               unsigned as well as signed constants.  */
 
-           /* We just need one int constant type for all objfiles.
-              It doesn't depend on languages or anything (arguably its
-              name should be a language-specific name for a type of
-              that size, but I'm inclined to say that if the compiler
-              wants a nice name for the type, it can use 'e').  */
-           static struct type *int_const_type;
-
-           /* Yes, this is as long as a *host* int.  That is because we
-              use atoi.  */
-           if (int_const_type == NULL)
-             int_const_type =
-               init_type (TYPE_CODE_INT,
-                          sizeof (int) * HOST_CHAR_BIT / TARGET_CHAR_BIT, 0,
-                          "integer constant",
-                            (struct objfile *) NULL);
-           SYMBOL_TYPE (sym) = int_const_type;
+           SYMBOL_TYPE (sym) = builtin_type (gdbarch)->builtin_long;
            SYMBOL_VALUE (sym) = atoi (p);
            SYMBOL_CLASS (sym) = LOC_CONST;
          }
            SYMBOL_VALUE (sym) = atoi (p);
            SYMBOL_CLASS (sym) = LOC_CONST;
          }
@@ -844,7 +826,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          than the "declared-as" type for unprototyped functions, so
          we treat all functions as if they were prototyped.  This is used
          primarily for promotion when calling the function from GDB.  */
          than the "declared-as" type for unprototyped functions, so
          we treat all functions as if they were prototyped.  This is used
          primarily for promotion when calling the function from GDB.  */
-      TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;
+      TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1;
 
       /* fall into process_prototype_types */
 
 
       /* fall into process_prototype_types */
 
@@ -882,15 +864,15 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
                 be promoted to the width of the calling conventions, with
                 a type which references itself. This type is turned into
                 a TYPE_CODE_VOID type by read_type, and we have to turn
                 be promoted to the width of the calling conventions, with
                 a type which references itself. This type is turned into
                 a TYPE_CODE_VOID type by read_type, and we have to turn
-                it back into builtin_type_int here.
-                FIXME: Do we need a new builtin_type_promoted_int_arg ?  */
+                it back into builtin_int here.
+                FIXME: Do we need a new builtin_promoted_int_arg ?  */
              if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
              if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
-               ptype = builtin_type_int;
+               ptype = builtin_type (gdbarch)->builtin_int;
              TYPE_FIELD_TYPE (ftype, nparams) = ptype;
              TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
            }
          TYPE_NFIELDS (ftype) = nparams;
              TYPE_FIELD_TYPE (ftype, nparams) = ptype;
              TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
            }
          TYPE_NFIELDS (ftype) = nparams;
-         TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
+         TYPE_PROTOTYPED (ftype) = 1;
        }
       break;
 
        }
       break;
 
@@ -914,9 +896,9 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          Symbol references don't have valid names and wont't match up with
          minimal symbols when the global_sym_chain is relocated.
          We'll fixup symbol references when we fixup the defining symbol.  */
          Symbol references don't have valid names and wont't match up with
          minimal symbols when the global_sym_chain is relocated.
          We'll fixup symbol references when we fixup the defining symbol.  */
-      if (DEPRECATED_SYMBOL_NAME (sym) && DEPRECATED_SYMBOL_NAME (sym)[0] != '#')
+      if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
        {
        {
-         i = hashname (DEPRECATED_SYMBOL_NAME (sym));
+         i = hashname (SYMBOL_LINKAGE_NAME (sym));
          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;
        }
@@ -952,9 +934,10 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_CLASS (sym) = LOC_ARG;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_CLASS (sym) = LOC_ARG;
       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, &local_symbols);
 
-      if (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
        {
          /* On little-endian machines, this crud is never necessary,
             and, if the extra bytes contain garbage, is harmful.  */
        {
          /* On little-endian machines, this crud is never necessary,
             and, if the extra bytes contain garbage, is harmful.  */
@@ -963,38 +946,21 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
 
       /* If it's gcc-compiled, if it says `short', believe it.  */
       if (processing_gcc_compilation
 
       /* If it's gcc-compiled, if it says `short', believe it.  */
       if (processing_gcc_compilation
-         || gdbarch_believe_pcc_promotion (current_gdbarch))
+         || gdbarch_believe_pcc_promotion (gdbarch))
        break;
 
        break;
 
-      if (!gdbarch_believe_pcc_promotion (current_gdbarch))
+      if (!gdbarch_believe_pcc_promotion (gdbarch))
        {
        {
-         /* This is the signed type which arguments get promoted to.  */
-         static struct type *pcc_promotion_type;
-         /* This is the unsigned type which arguments get promoted to.  */
-         static struct type *pcc_unsigned_promotion_type;
-
-         /* Call it "int" because this is mainly C lossage.  */
-         if (pcc_promotion_type == NULL)
-           pcc_promotion_type =
-             init_type (TYPE_CODE_INT, 
-                        gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
-                        0, "int", NULL);
-
-         if (pcc_unsigned_promotion_type == NULL)
-           pcc_unsigned_promotion_type =
-             init_type (TYPE_CODE_INT, 
-                        gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
-                        TYPE_FLAG_UNSIGNED, "unsigned int", NULL);
-
          /* If PCC says a parameter is a short or a char, it is
             really an int.  */
          /* If PCC says a parameter is a short or a char, it is
             really an int.  */
-         if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
+         if (TYPE_LENGTH (SYMBOL_TYPE (sym))
+             < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
              && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
            {
              SYMBOL_TYPE (sym) =
                TYPE_UNSIGNED (SYMBOL_TYPE (sym))
              && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
            {
              SYMBOL_TYPE (sym) =
                TYPE_UNSIGNED (SYMBOL_TYPE (sym))
-               ? pcc_unsigned_promotion_type
-               : pcc_promotion_type;
+               ? builtin_type (gdbarch)->builtin_unsigned_int
+               : builtin_type (gdbarch)->builtin_int;
            }
          break;
        }
            }
          break;
        }
@@ -1013,7 +979,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
     case 'R':
       /* Parameter which is in a register.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
     case 'R':
       /* Parameter which is in a register.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
-      SYMBOL_CLASS (sym) = LOC_REGPARM;
+      SYMBOL_CLASS (sym) = LOC_REGISTER;
+      SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
       if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
                                  + gdbarch_num_pseudo_regs (current_gdbarch))
       SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
       if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
                                  + gdbarch_num_pseudo_regs (current_gdbarch))
@@ -1069,17 +1036,16 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
 
          if (local_symbols
              && local_symbols->nsyms > 0
 
          if (local_symbols
              && local_symbols->nsyms > 0
-             && gdbarch_stabs_argument_has_addr (current_gdbarch,
-                                                 SYMBOL_TYPE (sym)))
+             && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
            {
              struct symbol *prev_sym;
              prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
              if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
                   || SYMBOL_CLASS (prev_sym) == LOC_ARG)
            {
              struct symbol *prev_sym;
              prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
              if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
                   || SYMBOL_CLASS (prev_sym) == LOC_ARG)
-                 && strcmp (DEPRECATED_SYMBOL_NAME (prev_sym),
-                            DEPRECATED_SYMBOL_NAME (sym)) == 0)
+                 && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
+                            SYMBOL_LINKAGE_NAME (sym)) == 0)
                {
                {
-                 SYMBOL_CLASS (prev_sym) = LOC_REGPARM;
+                 SYMBOL_CLASS (prev_sym) = LOC_REGISTER;
                  /* Use the type from the LOC_REGISTER; that is the type
                     that is actually in that register.  */
                  SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
                  /* Use the type from the LOC_REGISTER; that is the type
                     that is actually in that register.  */
                  SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
@@ -1099,18 +1065,21 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_VALUE_ADDRESS (sym) = valu;
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_VALUE_ADDRESS (sym) = valu;
-#ifdef STATIC_TRANSFORM_NAME
-      if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
+      if (gdbarch_static_transform_name_p (gdbarch)
+         && gdbarch_static_transform_name (gdbarch,
+                                           SYMBOL_LINKAGE_NAME (sym))
+            != SYMBOL_LINKAGE_NAME (sym))
        {
          struct minimal_symbol *msym;
        {
          struct minimal_symbol *msym;
-         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
+         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, objfile);
          if (msym != NULL)
            {
          if (msym != NULL)
            {
-             DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
+             char *new_name = gdbarch_static_transform_name
+               (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+             SYMBOL_SET_LINKAGE_NAME (sym, new_name);
              SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
            }
        }
              SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
            }
        }
-#endif
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       add_symbol_to_list (sym, &file_symbols);
       break;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       add_symbol_to_list (sym, &file_symbols);
       break;
@@ -1167,7 +1136,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          extern const char vtbl_ptr_name[];
 
          if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
          extern const char vtbl_ptr_name[];
 
          if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
-              && strcmp (DEPRECATED_SYMBOL_NAME (sym), vtbl_ptr_name))
+              && strcmp (SYMBOL_LINKAGE_NAME (sym), 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
@@ -1207,11 +1176,11 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
              /* Pascal accepts names for pointer types. */
              if (current_subfile->language == language_pascal)
                {
              /* Pascal accepts names for pointer types. */
              if (current_subfile->language == language_pascal)
                {
-                 TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
+                 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
                }
            }
          else
                }
            }
          else
-           TYPE_NAME (SYMBOL_TYPE (sym)) = DEPRECATED_SYMBOL_NAME (sym);
+           TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
        }
 
       add_symbol_to_list (sym, &file_symbols);
        }
 
       add_symbol_to_list (sym, &file_symbols);
@@ -1229,7 +1198,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
             TYPE_NAME (SYMBOL_TYPE (sym))
               = obconcat (&objfile->objfile_obstack, "", "",
           if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
             TYPE_NAME (SYMBOL_TYPE (sym))
               = obconcat (&objfile->objfile_obstack, "", "",
-                          DEPRECATED_SYMBOL_NAME (sym));
+                          SYMBOL_LINKAGE_NAME (sym));
           add_symbol_to_list (struct_sym, &file_symbols);
         }
       
           add_symbol_to_list (struct_sym, &file_symbols);
         }
       
@@ -1255,7 +1224,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
       if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
        TYPE_TAG_NAME (SYMBOL_TYPE (sym))
       SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
       if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
        TYPE_TAG_NAME (SYMBOL_TYPE (sym))
-         = obconcat (&objfile->objfile_obstack, "", "", DEPRECATED_SYMBOL_NAME (sym));
+         = obconcat (&objfile->objfile_obstack, "", "",
+                     SYMBOL_LINKAGE_NAME (sym));
       add_symbol_to_list (sym, &file_symbols);
 
       if (synonym)
       add_symbol_to_list (sym, &file_symbols);
 
       if (synonym)
@@ -1269,7 +1239,8 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
          SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
          if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
            TYPE_NAME (SYMBOL_TYPE (sym))
          SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
          if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
            TYPE_NAME (SYMBOL_TYPE (sym))
-             = obconcat (&objfile->objfile_obstack, "", "", DEPRECATED_SYMBOL_NAME (sym));
+             = obconcat (&objfile->objfile_obstack, "", "",
+                         SYMBOL_LINKAGE_NAME (sym));
          add_symbol_to_list (typedef_sym, &file_symbols);
        }
       break;
          add_symbol_to_list (typedef_sym, &file_symbols);
        }
       break;
@@ -1279,18 +1250,21 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_VALUE_ADDRESS (sym) = valu;
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_VALUE_ADDRESS (sym) = valu;
-#ifdef STATIC_TRANSFORM_NAME
-      if (IS_STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym)))
+      if (gdbarch_static_transform_name_p (gdbarch)
+         && gdbarch_static_transform_name (gdbarch,
+                                           SYMBOL_LINKAGE_NAME (sym))
+            != SYMBOL_LINKAGE_NAME (sym))
        {
          struct minimal_symbol *msym;
        {
          struct minimal_symbol *msym;
-         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, objfile);
+         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, objfile);
          if (msym != NULL)
            {
          if (msym != NULL)
            {
-             DEPRECATED_SYMBOL_NAME (sym) = STATIC_TRANSFORM_NAME (DEPRECATED_SYMBOL_NAME (sym));
+             char *new_name = gdbarch_static_transform_name
+               (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+             SYMBOL_SET_LINKAGE_NAME (sym, new_name);
              SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
            }
        }
              SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym);
            }
        }
-#endif
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
        add_symbol_to_list (sym, &local_symbols);
       break;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
        add_symbol_to_list (sym, &local_symbols);
       break;
@@ -1299,6 +1273,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       /* Reference parameter */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_REF_ARG;
       /* Reference parameter */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_REF_ARG;
+      SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       add_symbol_to_list (sym, &local_symbols);
       SYMBOL_VALUE (sym) = valu;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       add_symbol_to_list (sym, &local_symbols);
@@ -1308,6 +1283,7 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
       /* Reference parameter which is in a register.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
       /* Reference parameter which is in a register.  */
       SYMBOL_TYPE (sym) = read_type (&p, objfile);
       SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
+      SYMBOL_IS_ARGUMENT (sym) = 1;
       SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
       if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
                                + gdbarch_num_pseudo_regs (current_gdbarch))
       SYMBOL_VALUE (sym) = gdbarch_stab_reg_to_regnum (current_gdbarch, valu);
       if (SYMBOL_VALUE (sym) >= gdbarch_num_regs (current_gdbarch)
                                + gdbarch_num_pseudo_regs (current_gdbarch))
@@ -1348,12 +1324,12 @@ define_symbol (CORE_ADDR valu, char *string, int desc, int type,
      of by value, i.e. they will pass the address of a structure (in a
      register or on the stack) instead of the structure itself.  */
 
      of by value, i.e. they will pass the address of a structure (in a
      register or on the stack) instead of the structure itself.  */
 
-  if (gdbarch_stabs_argument_has_addr (current_gdbarch, SYMBOL_TYPE (sym))
-      && (SYMBOL_CLASS (sym) == LOC_REGPARM || SYMBOL_CLASS (sym) == LOC_ARG))
+  if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
+      && SYMBOL_IS_ARGUMENT (sym))
     {
     {
-      /* We have to convert LOC_REGPARM to LOC_REGPARM_ADDR (for
+      /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
          variables passed in a register).  */
          variables passed in a register).  */
-      if (SYMBOL_CLASS (sym) == LOC_REGPARM)
+      if (SYMBOL_CLASS (sym) == LOC_REGISTER)
        SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
       /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
         and subsequent arguments on SPARC, for example).  */
        SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR;
       /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
         and subsequent arguments on SPARC, for example).  */
@@ -1569,7 +1545,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 (DEPRECATED_SYMBOL_NAME (sym), type_name) == 0)
+                 && strcmp (SYMBOL_LINKAGE_NAME (sym), 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);
@@ -1588,7 +1564,7 @@ again:
        TYPE_CODE (type) = code;
        TYPE_TAG_NAME (type) = type_name;
        INIT_CPLUS_SPECIFIC (type);
        TYPE_CODE (type) = code;
        TYPE_TAG_NAME (type) = type_name;
        INIT_CPLUS_SPECIFIC (type);
-       TYPE_FLAGS (type) |= TYPE_FLAG_STUB;
+       TYPE_STUB (type) = 1;
 
        add_undefined_type (type, typenums);
        return type;
 
        add_undefined_type (type, typenums);
        return type;
@@ -1654,7 +1630,7 @@ again:
          }
        else
          {
          }
        else
          {
-           TYPE_FLAGS (type) |= TYPE_FLAG_TARGET_STUB;
+           TYPE_TARGET_STUB (type) = 1;
            TYPE_TARGET_TYPE (type) = xtype;
          }
       }
            TYPE_TARGET_TYPE (type) = xtype;
          }
       }
@@ -1749,7 +1725,7 @@ again:
             TYPE_FIELD_TYPE (func_type, i) = t->type;
         }
         TYPE_NFIELDS (func_type) = num_args;
             TYPE_FIELD_TYPE (func_type, i) = t->type;
         }
         TYPE_NFIELDS (func_type) = num_args;
-        TYPE_FLAGS (func_type) |= TYPE_FLAG_PROTOTYPED;
+        TYPE_PROTOTYPED (func_type) = 1;
 
         type = func_type;
         break;
 
         type = func_type;
         break;
@@ -1919,7 +1895,7 @@ again:
       if (is_string)
        TYPE_CODE (type) = TYPE_CODE_STRING;
       if (is_vector)
       if (is_string)
        TYPE_CODE (type) = TYPE_CODE_STRING;
       if (is_vector)
-       TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
+       make_vector_type (type);
       break;
 
     case 'S':                  /* Set or bitstring  type */
       break;
 
     case 'S':                  /* Set or bitstring  type */
@@ -2734,6 +2710,8 @@ static void
 read_one_struct_field (struct field_info *fip, char **pp, char *p,
                       struct type *type, struct objfile *objfile)
 {
 read_one_struct_field (struct field_info *fip, char **pp, char *p,
                       struct type *type, struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
+
   fip->list->field.name =
     obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
   *pp = p + 1;
   fip->list->field.name =
     obsavestring (*pp, p - *pp, &objfile->objfile_obstack);
   *pp = p + 1;
@@ -2838,7 +2816,7 @@ read_one_struct_field (struct field_info *fip, char **pp, char *p,
           == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
           || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
               && FIELD_BITSIZE (fip->list->field)
           == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
           || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
               && FIELD_BITSIZE (fip->list->field)
-                 == gdbarch_int_bit (current_gdbarch))
+                 == gdbarch_int_bit (gdbarch))
          )
          &&
          FIELD_BITPOS (fip->list->field) % 8 == 0)
          )
          &&
          FIELD_BITPOS (fip->list->field) % 8 == 0)
@@ -3360,7 +3338,7 @@ read_struct_type (char **pp, struct type *type, enum type_code type_code,
 
   INIT_CPLUS_SPECIFIC (type);
   TYPE_CODE (type) = type_code;
 
   INIT_CPLUS_SPECIFIC (type);
   TYPE_CODE (type) = type_code;
-  TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
+  TYPE_STUB (type) = 0;
 
   /* First comes the total size in bytes.  */
 
 
   /* First comes the total size in bytes.  */
 
@@ -3462,6 +3440,7 @@ static struct type *
 read_enum_type (char **pp, struct type *type,
                struct objfile *objfile)
 {
 read_enum_type (char **pp, struct type *type,
                struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   char *p;
   char *name;
   long n;
   char *p;
   char *name;
   long n;
@@ -3515,7 +3494,7 @@ read_enum_type (char **pp, struct type *type,
       sym = (struct symbol *)
        obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
       memset (sym, 0, sizeof (struct symbol));
       sym = (struct symbol *)
        obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
       memset (sym, 0, sizeof (struct symbol));
-      DEPRECATED_SYMBOL_NAME (sym) = name;
+      SYMBOL_SET_LINKAGE_NAME (sym, name);
       SYMBOL_LANGUAGE (sym) = current_subfile->language;
       SYMBOL_CLASS (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
       SYMBOL_LANGUAGE (sym) = current_subfile->language;
       SYMBOL_CLASS (sym) = LOC_CONST;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
@@ -3531,11 +3510,11 @@ read_enum_type (char **pp, struct type *type,
 
   /* Now fill in the fields of the type-structure.  */
 
 
   /* Now fill in the fields of the type-structure.  */
 
-  TYPE_LENGTH (type) = gdbarch_int_bit (current_gdbarch) / HOST_CHAR_BIT;
+  TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
   TYPE_CODE (type) = TYPE_CODE_ENUM;
   TYPE_CODE (type) = TYPE_CODE_ENUM;
-  TYPE_FLAGS (type) &= ~TYPE_FLAG_STUB;
+  TYPE_STUB (type) = 0;
   if (unsigned_enum)
   if (unsigned_enum)
-    TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
+    TYPE_UNSIGNED (type) = 1;
   TYPE_NFIELDS (type) = nsyms;
   TYPE_FIELDS (type) = (struct field *)
     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
   TYPE_NFIELDS (type) = nsyms;
   TYPE_FIELDS (type) = (struct field *)
     TYPE_ALLOC (type, sizeof (struct field) * nsyms);
@@ -3557,7 +3536,7 @@ read_enum_type (char **pp, struct type *type,
        {
          struct symbol *xsym = syms->symbol[j];
          SYMBOL_TYPE (xsym) = type;
        {
          struct symbol *xsym = syms->symbol[j];
          SYMBOL_TYPE (xsym) = type;
-         TYPE_FIELD_NAME (type, n) = DEPRECATED_SYMBOL_NAME (xsym);
+         TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
          TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
          TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
          TYPE_FIELD_BITSIZE (type, n) = 0;
        }
@@ -3706,15 +3685,14 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
 {
   char *p = *pp;
   int sign = 1;
 {
   char *p = *pp;
   int sign = 1;
-  int sign_bit;
+  int sign_bit = 0;
   long n = 0;
   long n = 0;
-  long sn = 0;
   int radix = 10;
   char overflow = 0;
   int nbits = 0;
   int c;
   long upper_limit;
   int radix = 10;
   char overflow = 0;
   int nbits = 0;
   int c;
   long upper_limit;
-  int twos_complement_representation = radix == 8 && twos_complement_bits > 0;
+  int twos_complement_representation = 0;
 
   if (*p == '-')
     {
 
   if (*p == '-')
     {
@@ -3730,6 +3708,37 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
       p++;
     }
 
       p++;
     }
 
+  /* Skip extra zeros.  */
+  while (*p == '0')
+    p++;
+
+  if (sign > 0 && radix == 8 && twos_complement_bits > 0)
+    {
+      /* Octal, possibly signed.  Check if we have enough chars for a
+        negative number.  */
+
+      size_t len;
+      char *p1 = p;
+      while ((c = *p1) >= '0' && c < '8')
+       p1++;
+
+      len = p1 - p;
+      if (len > twos_complement_bits / 3
+         || (twos_complement_bits % 3 == 0 && 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.  */
+         sign_bit = (twos_complement_bits % 3 + 2) % 3;
+         c = *p - '0';
+         if (c & (1 << sign_bit))
+           {
+             /* Definitely signed.  */
+             twos_complement_representation = 1;
+             sign = -1;
+           }
+       }
+    }
+
   upper_limit = LONG_MAX / radix;
 
   while ((c = *p++) >= '0' && c < ('0' + radix))
   upper_limit = LONG_MAX / radix;
 
   while ((c = *p++) >= '0' && c < ('0' + radix))
@@ -3738,23 +3747,18 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
         {
           if (twos_complement_representation)
             {
         {
           if (twos_complement_representation)
             {
-              /* Octal, signed, twos complement representation. In this case,
-                 sn is the signed value, n is the corresponding absolute
-                 value. signed_bit is the position of the sign bit in the
-                 first three bits.  */
-              if (sn == 0)
-                {
-                  sign_bit = (twos_complement_bits % 3 + 2) % 3;
-                  sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
-                }
+             /* Octal, signed, twos complement representation.  In
+                this case, n is the corresponding absolute value.  */
+             if (n == 0)
+               {
+                 long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit));
+                 n = -sn;
+               }
               else
                 {
               else
                 {
-                  sn *= radix;
-                  sn += c - '0';
+                  n *= radix;
+                  n -= c - '0';
                 }
                 }
-
-              if (sn < 0)
-                n = -sn;
             }
           else
             {
             }
           else
             {
@@ -3798,6 +3802,15 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
   else
     --p;
 
   else
     --p;
 
+  if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits)
+    {
+      /* We were supposed to parse a number with maximum
+        TWOS_COMPLEMENT_BITS bits, but something went wrong.  */
+      if (bits != NULL)
+       *bits = -1;
+      return 0;
+    }
+
   *pp = p;
   if (overflow)
     {
   *pp = p;
   if (overflow)
     {
@@ -3811,8 +3824,9 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
        }
 
       /* -0x7f is the same as 0x80.  So deal with it by adding one to
        }
 
       /* -0x7f is the same as 0x80.  So deal with it by adding one to
-         the number of bits.  */
-      if (sign == -1)
+         the number of bits.  Two's complement represention octals
+         can't have a '-' in front.  */
+      if (sign == -1 && !twos_complement_representation)
        ++nbits;
       if (bits)
        *bits = nbits;
        ++nbits;
       if (bits)
        *bits = nbits;
@@ -3821,10 +3835,7 @@ read_huge_number (char **pp, int end, int *bits, int twos_complement_bits)
     {
       if (bits)
        *bits = 0;
     {
       if (bits)
        *bits = 0;
-      if (twos_complement_representation)
-        return sn;
-      else
-        return n * sign;
+      return n * sign;
     }
   /* It's *BITS which has the interesting information.  */
   return 0;
     }
   /* It's *BITS which has the interesting information.  */
   return 0;
@@ -3834,6 +3845,7 @@ static struct type *
 read_range_type (char **pp, int typenums[2], int type_size,
                  struct objfile *objfile)
 {
 read_range_type (char **pp, int typenums[2], int type_size,
                  struct objfile *objfile)
 {
+  struct gdbarch *gdbarch = get_objfile_arch (objfile);
   char *orig_pp = *pp;
   int rangenums[2];
   long n2, n3;
   char *orig_pp = *pp;
   int rangenums[2];
   long n2, n3;
@@ -3949,15 +3961,20 @@ read_range_type (char **pp, int typenums[2], int type_size,
        return float_type;
     }
 
        return float_type;
     }
 
-  /* If the upper bound is -1, it must really be an unsigned int.  */
+  /* If the upper bound is -1, it must really be an unsigned integral.  */
 
   else if (n2 == 0 && n3 == -1)
     {
 
   else if (n2 == 0 && n3 == -1)
     {
-      /* It is unsigned int or unsigned long.  */
-      /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
-         compatibility hack.  */
-      return init_type (TYPE_CODE_INT, 
-                       gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
+      int bits = type_size;
+      if (bits <= 0)
+       {
+         /* We don't know its size.  It is unsigned int or unsigned
+            long.  GCC 2.3.3 uses this for long long too, but that is
+            just a GDB 3.5 compatibility hack.  */
+         bits = gdbarch_int_bit (gdbarch);
+       }
+
+      return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT,
                        TYPE_FLAG_UNSIGNED, NULL, objfile);
     }
 
                        TYPE_FLAG_UNSIGNED, NULL, objfile);
     }
 
@@ -4000,7 +4017,7 @@ read_range_type (char **pp, int typenums[2], int type_size,
   else if (n3 == 0 && n2 < 0
           && (self_subrange
               || n2 == -gdbarch_long_long_bit
   else if (n3 == 0 && n2 < 0
           && (self_subrange
               || n2 == -gdbarch_long_long_bit
-                         (current_gdbarch) / TARGET_CHAR_BIT))
+                         (gdbarch) / TARGET_CHAR_BIT))
     return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
   else if (n2 == -n3 - 1)
     {
     return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile);
   else if (n2 == -n3 - 1)
     {
@@ -4017,7 +4034,7 @@ read_range_type (char **pp, int typenums[2], int type_size,
 handle_true_range:
 
   if (self_subrange)
 handle_true_range:
 
   if (self_subrange)
-    index_type = builtin_type_int;
+    index_type = builtin_type (gdbarch)->builtin_int;
   else
     index_type = *dbx_lookup_type (rangenums);
   if (index_type == NULL)
   else
     index_type = *dbx_lookup_type (rangenums);
   if (index_type == NULL)
@@ -4025,16 +4042,10 @@ handle_true_range:
       /* Does this actually ever happen?  Is that why we are worrying
          about dealing with it rather than just calling error_type?  */
 
       /* Does this actually ever happen?  Is that why we are worrying
          about dealing with it rather than just calling error_type?  */
 
-      static struct type *range_type_index;
-
       complaint (&symfile_complaints,
                 _("base type %d of range type is not defined"), rangenums[1]);
       complaint (&symfile_complaints,
                 _("base type %d of range type is not defined"), rangenums[1]);
-      if (range_type_index == NULL)
-       range_type_index =
-         init_type (TYPE_CODE_INT, 
-                    gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
-                    0, "range type index type", NULL);
-      index_type = range_type_index;
+
+      index_type = builtin_type (gdbarch)->builtin_int;
     }
 
   result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
     }
 
   result_type = create_range_type ((struct type *) NULL, index_type, n2, n3);
@@ -4140,7 +4151,7 @@ common_block_end (struct objfile *objfile)
     obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
   memset (sym, 0, sizeof (struct symbol));
   /* Note: common_block_name already saved on objfile_obstack */
     obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
   memset (sym, 0, sizeof (struct symbol));
   /* Note: common_block_name already saved on objfile_obstack */
-  DEPRECATED_SYMBOL_NAME (sym) = common_block_name;
+  SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
   SYMBOL_CLASS (sym) = LOC_BLOCK;
 
   /* Now we copy all the symbols which have been defined since the BCOMM.  */
   SYMBOL_CLASS (sym) = LOC_BLOCK;
 
   /* Now we copy all the symbols which have been defined since the BCOMM.  */
@@ -4167,7 +4178,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 (DEPRECATED_SYMBOL_NAME (sym));
+  i = hashname (SYMBOL_LINKAGE_NAME (sym));
   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;
@@ -4253,7 +4264,7 @@ add_undefined_type (struct type *type, int typenums[2])
 
 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector.  */
 
 
 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector.  */
 
-void
+static void
 cleanup_undefined_types_noname (void)
 {
   int i;
 cleanup_undefined_types_noname (void)
 {
   int i;
@@ -4265,7 +4276,14 @@ cleanup_undefined_types_noname (void)
 
       type = dbx_lookup_type (nat.typenums);
       if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
 
       type = dbx_lookup_type (nat.typenums);
       if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
-        replace_type (nat.type, *type);
+        {
+          /* The instance flags of the undefined type are still unset,
+             and needs to be copied over from the reference type.
+             Since replace_type expects them to be identical, we need
+             to set these flags manually before hand.  */
+          TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type);
+          replace_type (nat.type, *type);
+        }
     }
 
   noname_undefs_length = 0;
     }
 
   noname_undefs_length = 0;
@@ -4281,11 +4299,30 @@ cleanup_undefined_types_noname (void)
    yet defined at the time a pointer to it was made.
    Fix:  Do a full lookup on the struct/union tag.  */
 
    yet defined at the time a pointer to it was made.
    Fix:  Do a full lookup on the struct/union tag.  */
 
-void
+static void
 cleanup_undefined_types_1 (void)
 {
   struct type **type;
 
 cleanup_undefined_types_1 (void)
 {
   struct type **type;
 
+  /* Iterate over every undefined type, and look for a symbol whose type
+     matches our undefined type.  The symbol matches if:
+       1. It is a typedef in the STRUCT domain;
+       2. It has the same name, and same type code;
+       3. The instance flags are identical.
+     
+     It is important to check the instance flags, because we have seen
+     examples where the debug info contained definitions such as:
+
+         "foo_t:t30=B31=xefoo_t:"
+
+     In this case, we have created an undefined type named "foo_t" whose
+     instance flags is null (when processing "xefoo_t"), and then created
+     another type with the same name, but with different instance flags
+     ('B' means volatile).  I think that the definition above is wrong,
+     since the same type cannot be volatile and non-volatile at the same
+     time, but we need to be able to cope with it when it happens.  The
+     approach taken here is to treat these two types as different.  */
+
   for (type = undef_types; type < undef_types + undef_types_length; type++)
     {
       switch (TYPE_CODE (*type))
   for (type = undef_types; type < undef_types + undef_types_length; type++)
     {
       switch (TYPE_CODE (*type))
@@ -4321,7 +4358,10 @@ cleanup_undefined_types_1 (void)
                            && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
                            && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
                                TYPE_CODE (*type))
                            && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
                            && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
                                TYPE_CODE (*type))
-                           && strcmp (DEPRECATED_SYMBOL_NAME (sym), typename) == 0)
+                           && (TYPE_INSTANCE_FLAGS (*type) ==
+                               TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
+                           && strcmp (SYMBOL_LINKAGE_NAME (sym),
+                                      typename) == 0)
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
                           replace_type (*type, SYMBOL_TYPE (sym));
                      }
                  }
@@ -4387,9 +4427,7 @@ scan_file_globals (struct objfile *objfile)
       if (hash >= HASHSIZE)
        return;
 
       if (hash >= HASHSIZE)
        return;
 
-      for (msymbol = resolve_objfile->msymbols;
-          msymbol && DEPRECATED_SYMBOL_NAME (msymbol) != NULL;
-          msymbol++)
+      ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol)
        {
          QUIT;
 
        {
          QUIT;
 
@@ -4409,12 +4447,12 @@ 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 (DEPRECATED_SYMBOL_NAME (msymbol));
+         hash = hashname (SYMBOL_LINKAGE_NAME (msymbol));
 
          for (sym = global_sym_chain[hash]; sym;)
            {
 
          for (sym = global_sym_chain[hash]; sym;)
            {
-             if (DEPRECATED_SYMBOL_NAME (msymbol)[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
-                 strcmp (DEPRECATED_SYMBOL_NAME (msymbol) + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
+             if (strcmp (SYMBOL_LINKAGE_NAME (msymbol),
+                         SYMBOL_LINKAGE_NAME (sym)) == 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. */
@@ -4486,7 +4524,7 @@ scan_file_globals (struct objfile *objfile)
          else
            complaint (&symfile_complaints,
                       _("%s: common block `%s' from global_sym_chain unresolved"),
          else
            complaint (&symfile_complaints,
                       _("%s: common block `%s' from global_sym_chain unresolved"),
-                      objfile->name, DEPRECATED_SYMBOL_NAME (prev));
+                      objfile->name, SYMBOL_PRINT_NAME (prev));
        }
     }
   memset (global_sym_chain, 0, sizeof (global_sym_chain));
        }
     }
   memset (global_sym_chain, 0, sizeof (global_sym_chain));
GDB Binutils - Deliverables
This page took 0.036332 seconds and 4 git commands to generate.