* coffread.c (process_coff_symbol): Set the symbol's language to

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

diff --git a/gdb/coffread.c b/gdb/coffread.c
index dcd17d35faa069f805840a86b61acf60f702cf9c..30b7726ae26f4e94a6b1daf16409da8130553ca0 100644 (file)
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -1,6 +1,6 @@
 /* Read coff symbol tables and convert to internal format, for GDB.
    Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
 /* Read coff symbol tables and convert to internal format, for GDB.
    Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,

-   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
+   1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009

    Free Software Foundation, Inc.
    Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
 
    Free Software Foundation, Inc.
    Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
 


@@ -8,7 +8,7 @@
 
    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 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/>.  */

 
 #include "defs.h"
 #include "symtab.h"
 
 #include "defs.h"
 #include "symtab.h"


@@ -139,19 +137,24 @@ struct coff_symbol
 
 extern void stabsread_clear_cache (void);
 
 
 extern void stabsread_clear_cache (void);
 

-static struct type *coff_read_struct_type (int, int, int);
+static struct type *coff_read_struct_type (int, int, int,
+                                          struct objfile *);

 
 static struct type *decode_base_type (struct coff_symbol *,
 
 static struct type *decode_base_type (struct coff_symbol *,

-                                     unsigned int, union internal_auxent *);
+                                     unsigned int, union internal_auxent *,
+                                     struct objfile *);

 
 static struct type *decode_type (struct coff_symbol *, unsigned int,
 
 static struct type *decode_type (struct coff_symbol *, unsigned int,

-                                union internal_auxent *);
+                                union internal_auxent *,
+                                struct objfile *);

 
 static struct type *decode_function_type (struct coff_symbol *,
                                          unsigned int,
 
 static struct type *decode_function_type (struct coff_symbol *,
                                          unsigned int,

-                                         union internal_auxent *);
+                                         union internal_auxent *,
+                                         struct objfile *);

 
 

-static struct type *coff_read_enum_type (int, int, int);
+static struct type *coff_read_enum_type (int, int, int,
+                                        struct objfile *);

 
 static struct symbol *process_coff_symbol (struct coff_symbol *,
                                           union internal_auxent *,
 
 static struct symbol *process_coff_symbol (struct coff_symbol *,
                                           union internal_auxent *,


@@ -200,7 +203,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
 
   csi = (struct coff_symfile_info *) csip;
   name = bfd_get_section_name (abfd, sectp);
 
   csi = (struct coff_symfile_info *) csip;
   name = bfd_get_section_name (abfd, sectp);

-  if (DEPRECATED_STREQ (name, ".text"))
+  if (strcmp (name, ".text") == 0)

     {
       csi->textaddr = bfd_section_vma (abfd, sectp);
       csi->textsize += bfd_section_size (abfd, sectp);
     {
       csi->textaddr = bfd_section_vma (abfd, sectp);
       csi->textsize += bfd_section_size (abfd, sectp);


@@ -209,7 +212,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
     {
       csi->textsize += bfd_section_size (abfd, sectp);
     }
     {
       csi->textsize += bfd_section_size (abfd, sectp);
     }

-  else if (DEPRECATED_STREQ (name, ".stabstr"))
+  else if (strcmp (name, ".stabstr") == 0)

     {
       csi->stabstrsect = sectp;
     }
     {
       csi->stabstrsect = sectp;
     }


@@ -418,7 +421,7 @@ record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address,
 
   bfd_section = cs_to_bfd_section (cs, objfile);
   return prim_record_minimal_symbol_and_info (cs->c_name, address, type,
 
   bfd_section = cs_to_bfd_section (cs, objfile);
   return prim_record_minimal_symbol_and_info (cs->c_name, address, type,

-    NULL, section, bfd_section, objfile);
+                                             section, bfd_section, objfile);

 }
 \f
 /* coff_symfile_init ()
 }
 \f
 /* coff_symfile_init ()


@@ -667,6 +670,8 @@ coff_symfile_finish (struct objfile *objfile)
 
   /* Let stabs reader clean up */
   stabsread_clear_cache ();
 
   /* Let stabs reader clean up */
   stabsread_clear_cache ();

+
+  dwarf2_free_objfile (objfile);

 }
 \f
 
 }
 \f
 


@@ -679,6 +684,7 @@ static void
 coff_symtab_read (long symtab_offset, unsigned int nsyms,
                  struct objfile *objfile)
 {
 coff_symtab_read (long symtab_offset, unsigned int nsyms,
                  struct objfile *objfile)
 {

+  struct gdbarch *gdbarch = get_objfile_arch (objfile);

   struct context_stack *new;
   struct coff_symbol coff_symbol;
   struct coff_symbol *cs = &coff_symbol;
   struct context_stack *new;
   struct coff_symbol coff_symbol;
   struct coff_symbol *cs = &coff_symbol;


@@ -752,6 +758,11 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
            coff_end_symtab (objfile);
 
          coff_start_symtab ("_globals_");
            coff_end_symtab (objfile);
 
          coff_start_symtab ("_globals_");

+         /* coff_start_symtab will set the language of this symtab to
+            language_unknown, since such a ``file name'' is not
+            recognized.  Override that with the minimal language to
+            allow printing values in this symtab.  */
+         current_subfile->language = language_minimal;

          complete_symtab ("_globals_", 0, 0);
          /* done with all files, everything from here on out is globals */
        }
          complete_symtab ("_globals_", 0, 0);
          /* done with all files, everything from here on out is globals */
        }


@@ -823,7 +834,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
        case C_THUMBSTATFUNC:
          if (cs->c_name[0] == '.')
            {
        case C_THUMBSTATFUNC:
          if (cs->c_name[0] == '.')
            {

-             if (DEPRECATED_STREQ (cs->c_name, ".text"))
+             if (strcmp (cs->c_name, ".text") == 0)

                {
                  /* FIXME:  don't wire in ".text" as section name
                     or symbol name! */
                {
                  /* FIXME:  don't wire in ".text" as section name
                     or symbol name! */


@@ -910,8 +921,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
                      || cs->c_sclass == C_THUMBEXT ?
                      mst_text : mst_file_text;
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
                      || cs->c_sclass == C_THUMBEXT ?
                      mst_text : mst_file_text;

-                   tmpaddr = gdbarch_smash_text_address
-                               (current_gdbarch, tmpaddr);
+                   tmpaddr = gdbarch_smash_text_address (gdbarch, tmpaddr);

                  }
                else if (bfd_section->flags & SEC_ALLOC
                         && bfd_section->flags & SEC_LOAD)
                  }
                else if (bfd_section->flags & SEC_ALLOC
                         && bfd_section->flags & SEC_LOAD)


@@ -932,8 +942,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
 
            msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile);
            if (msym)
 
            msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile);
            if (msym)

-             gdbarch_coff_make_msymbol_special
-             (current_gdbarch, cs->c_sclass, msym);
+             gdbarch_coff_make_msymbol_special (gdbarch, cs->c_sclass, msym);

 
            if (SDB_TYPE (cs->c_type))
              {
 
            if (SDB_TYPE (cs->c_type))
              {


@@ -947,7 +956,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
          break;
 
        case C_FCN:
          break;
 
        case C_FCN:

-         if (DEPRECATED_STREQ (cs->c_name, ".bf"))
+         if (strcmp (cs->c_name, ".bf") == 0)

            {
              within_function = 1;
 
            {
              within_function = 1;
 


@@ -969,7 +978,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              new->name =
                process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
            }
              new->name =
                process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile);
            }

-         else if (DEPRECATED_STREQ (cs->c_name, ".ef"))
+         else if (strcmp (cs->c_name, ".ef") == 0)

            {
              if (!within_function)
                error (_("Bad coff function information."));
            {
              if (!within_function)
                error (_("Bad coff function information."));


@@ -1022,22 +1031,9 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
 
              finish_block (new->name, &local_symbols, new->old_blocks,
                            new->start_addr,
 
              finish_block (new->name, &local_symbols, new->old_blocks,
                            new->start_addr,

-#if defined (FUNCTION_EPILOGUE_SIZE)
-             /* This macro should be defined only on
-                machines where the
-                fcn_aux_saved.x_sym.x_misc.x_fsize
-                field is always zero.
-                So use the .bf record information that
-                points to the epilogue and add the size
-                of the epilogue.  */
-                           cs->c_value
-                           + FUNCTION_EPILOGUE_SIZE
-                           + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
-#else

                            fcn_cs_saved.c_value
                            + fcn_aux_saved.x_sym.x_misc.x_fsize
                            + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),
                            fcn_cs_saved.c_value
                            + fcn_aux_saved.x_sym.x_misc.x_fsize
                            + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)),

-#endif

                            objfile
                );
              within_function = 0;
                            objfile
                );
              within_function = 0;


@@ -1045,13 +1041,13 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
          break;
 
        case C_BLOCK:
          break;
 
        case C_BLOCK:

-         if (DEPRECATED_STREQ (cs->c_name, ".bb"))
+         if (strcmp (cs->c_name, ".bb") == 0)

            {
              tmpaddr = cs->c_value;
              tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
              push_context (++depth, tmpaddr);
            }
            {
              tmpaddr = cs->c_value;
              tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
              push_context (++depth, tmpaddr);
            }

-         else if (DEPRECATED_STREQ (cs->c_name, ".eb"))
+         else if (strcmp (cs->c_name, ".eb") == 0)

            {
              if (context_stack_depth <= 0)
                {               /* We attempted to pop an empty context stack */
            {
              if (context_stack_depth <= 0)
                {               /* We attempted to pop an empty context stack */


@@ -1090,7 +1086,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
 
   if ((nsyms == 0) && (pe_file))
     {
 
   if ((nsyms == 0) && (pe_file))
     {

-      /* We've got no debugging symbols, but it's is a portable
+      /* We've got no debugging symbols, but it's a portable

         executable, so try to read the export table */
       read_pe_exported_syms (objfile);
     }
         executable, so try to read the export table */
       read_pe_exported_syms (objfile);
     }


@@ -1118,20 +1114,29 @@ read_one_sym (struct coff_symbol *cs,
              union internal_auxent *aux)
 {
   int i;
              union internal_auxent *aux)
 {
   int i;

+  bfd_size_type bytes;

 
   cs->c_symnum = symnum;
 
   cs->c_symnum = symnum;

-  bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
+  bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
+  if (bytes != local_symesz)
+    error ("%s: error reading symbols", current_objfile->name);

   bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
   cs->c_naux = sym->n_numaux & 0xff;
   if (cs->c_naux >= 1)
     {
   bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
   cs->c_naux = sym->n_numaux & 0xff;
   if (cs->c_naux >= 1)
     {

-      bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+      bytes  = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+      if (bytes != local_auxesz)
+       error ("%s: error reading symbols", current_objfile->name);

       bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
                            0, cs->c_naux, (char *) aux);
       /* If more than one aux entry, read past it (only the first aux
          is important). */
       for (i = 1; i < cs->c_naux; i++)
       bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass,
                            0, cs->c_naux, (char *) aux);
       /* If more than one aux entry, read past it (only the first aux
          is important). */
       for (i = 1; i < cs->c_naux; i++)

-       bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+       {
+         bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
+         if (bytes != local_auxesz)
+           error ("%s: error reading symbols", current_objfile->name);
+       }

     }
   cs->c_name = getsymname (sym);
   cs->c_value = sym->n_value;
     }
   cs->c_name = getsymname (sym);
   cs->c_value = sym->n_value;


@@ -1429,15 +1434,15 @@ patch_opaque_types (struct symtab *s)
          TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
          TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
        {
          TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR &&
          TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
        {

-         char *name = DEPRECATED_SYMBOL_NAME (real_sym);
+         char *name = SYMBOL_LINKAGE_NAME (real_sym);

          int hash = hashname (name);
          struct symbol *sym, *prev;
 
          prev = 0;
          for (sym = opaque_type_chain[hash]; sym;)
            {
          int hash = hashname (name);
          struct symbol *sym, *prev;
 
          prev = 0;
          for (sym = opaque_type_chain[hash]; sym;)
            {

-             if (name[0] == DEPRECATED_SYMBOL_NAME (sym)[0] &&
-                 strcmp (name + 1, DEPRECATED_SYMBOL_NAME (sym) + 1) == 0)
+             if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0] &&
+                 strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0)

                {
                  if (prev)
                    {
                {
                  if (prev)
                    {


@@ -1482,7 +1487,7 @@ process_coff_symbol (struct coff_symbol *cs,
   memset (sym, 0, sizeof (struct symbol));
   name = cs->c_name;
   name = EXTERNAL_NAME (name, objfile->obfd);
   memset (sym, 0, sizeof (struct symbol));
   name = cs->c_name;
   name = EXTERNAL_NAME (name, objfile->obfd);

-  SYMBOL_LANGUAGE (sym) = language_auto;
+  SYMBOL_LANGUAGE (sym) = current_subfile->language;

   SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
 
   /* default assumptions */
   SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
 
   /* default assumptions */


@@ -1494,7 +1499,7 @@ process_coff_symbol (struct coff_symbol *cs,
     {
       SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
       SYMBOL_TYPE (sym) =
     {
       SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
       SYMBOL_TYPE (sym) =

-       lookup_function_type (decode_function_type (cs, cs->c_type, aux));
+       lookup_function_type (decode_function_type (cs, cs->c_type, aux, objfile));

 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT


@@ -1506,7 +1511,7 @@ process_coff_symbol (struct coff_symbol *cs,
     }
   else
     {
     }
   else
     {

-      SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux);
+      SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile);

       switch (cs->c_sclass)
        {
        case C_NULL:
       switch (cs->c_sclass)
        {
        case C_NULL:


@@ -1560,53 +1565,16 @@ process_coff_symbol (struct coff_symbol *cs,
 
        case C_ARG:
          SYMBOL_CLASS (sym) = LOC_ARG;
 
        case C_ARG:
          SYMBOL_CLASS (sym) = LOC_ARG;

+         SYMBOL_IS_ARGUMENT (sym) = 1;

          add_symbol_to_list (sym, &local_symbols);
          add_symbol_to_list (sym, &local_symbols);

-#if !defined (BELIEVE_PCC_PROMOTION)
-         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
-           {
-             /* If PCC says a parameter is a short or a char,
-                aligned on an int boundary, realign it to the
-                "little end" of the int.  */
-             struct type *temptype;
-             temptype = lookup_fundamental_type (current_objfile,
-                                                 FT_INTEGER);
-             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
-                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
-                 && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
-               {
-                 SYMBOL_VALUE (sym) +=
-                   TYPE_LENGTH (temptype)
-                   - TYPE_LENGTH (SYMBOL_TYPE (sym));
-               }
-           }
-#endif

          break;
 
        case C_REGPARM:
          break;
 
        case C_REGPARM:

-         SYMBOL_CLASS (sym) = LOC_REGPARM;
+         SYMBOL_CLASS (sym) = LOC_REGISTER;
+         SYMBOL_IS_ARGUMENT (sym) = 1;

          SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum
                                 (current_gdbarch, cs->c_value);
          add_symbol_to_list (sym, &local_symbols);
          SYMBOL_VALUE (sym) = gdbarch_sdb_reg_to_regnum
                                 (current_gdbarch, cs->c_value);
          add_symbol_to_list (sym, &local_symbols);

-#if !defined (BELIEVE_PCC_PROMOTION)
-         /* FIXME:  This should retain the current type, since it's just
-            a register value.  gnu@adobe, 26Feb93 */
-         {
-           /* If PCC says a parameter is a short or a char,
-              it is really an int.  */
-           struct type *temptype;
-           temptype =
-             lookup_fundamental_type (current_objfile, FT_INTEGER);
-           if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
-               && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
-             {
-               SYMBOL_TYPE (sym) =
-                 (TYPE_UNSIGNED (SYMBOL_TYPE (sym))
-                  ? lookup_fundamental_type (current_objfile,
-                                             FT_UNSIGNED_INTEGER)
-                  : temptype);
-             }
-         }
-#endif

          break;
 
        case C_TPDEF:
          break;
 
        case C_TPDEF:


@@ -1641,7 +1609,7 @@ process_coff_symbol (struct coff_symbol *cs,
                }
              else
                TYPE_NAME (SYMBOL_TYPE (sym)) =
                }
              else
                TYPE_NAME (SYMBOL_TYPE (sym)) =

-                 concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
+                 concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);

            }
 
          /* Keep track of any type which points to empty structured type,
            }
 
          /* Keep track of any type which points to empty structured type,


@@ -1654,7 +1622,7 @@ process_coff_symbol (struct coff_symbol *cs,
              TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
              TYPE_CODE_UNDEF)
            {
              TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
              TYPE_CODE_UNDEF)
            {

-             int i = hashname (DEPRECATED_SYMBOL_NAME (sym));
+             int i = hashname (SYMBOL_LINKAGE_NAME (sym));

 
              SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
              opaque_type_chain[i] = sym;
 
              SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
              opaque_type_chain[i] = sym;


@@ -1672,11 +1640,11 @@ process_coff_symbol (struct coff_symbol *cs,
             names for anonymous enums, structures, and unions, like
             "~0fake" or ".0fake".  Thanks, but no thanks... */
          if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
             names for anonymous enums, structures, and unions, like
             "~0fake" or ".0fake".  Thanks, but no thanks... */
          if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)

-           if (DEPRECATED_SYMBOL_NAME (sym) != NULL
-               && *DEPRECATED_SYMBOL_NAME (sym) != '~'
-               && *DEPRECATED_SYMBOL_NAME (sym) != '.')
+           if (SYMBOL_LINKAGE_NAME (sym) != NULL
+               && *SYMBOL_LINKAGE_NAME (sym) != '~'
+               && *SYMBOL_LINKAGE_NAME (sym) != '.')

              TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
              TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =

-               concat (DEPRECATED_SYMBOL_NAME (sym), (char *)NULL);
+               concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);

 
          add_symbol_to_list (sym, &file_symbols);
          break;
 
          add_symbol_to_list (sym, &file_symbols);
          break;


@@ -1692,7 +1660,7 @@ process_coff_symbol (struct coff_symbol *cs,
 
 static struct type *
 decode_type (struct coff_symbol *cs, unsigned int c_type,
 
 static struct type *
 decode_type (struct coff_symbol *cs, unsigned int c_type,

-            union internal_auxent *aux)
+            union internal_auxent *aux, struct objfile *objfile)

 {
   struct type *type = 0;
   unsigned int new_c_type;
 {
   struct type *type = 0;
   unsigned int new_c_type;


@@ -1702,12 +1670,12 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
       new_c_type = DECREF (c_type);
       if (ISPTR (c_type))
        {
       new_c_type = DECREF (c_type);
       if (ISPTR (c_type))
        {

-         type = decode_type (cs, new_c_type, aux);
+         type = decode_type (cs, new_c_type, aux, objfile);

          type = lookup_pointer_type (type);
        }
       else if (ISFCN (c_type))
        {
          type = lookup_pointer_type (type);
        }
       else if (ISFCN (c_type))
        {

-         type = decode_type (cs, new_c_type, aux);
+         type = decode_type (cs, new_c_type, aux, objfile);

          type = lookup_function_type (type);
        }
       else if (ISARY (c_type))
          type = lookup_function_type (type);
        }
       else if (ISARY (c_type))


@@ -1729,8 +1697,8 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
            *dim = *(dim + 1);
          *dim = 0;
 
            *dim = *(dim + 1);
          *dim = 0;
 

-         base_type = decode_type (cs, new_c_type, aux);
-         index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
+         base_type = decode_type (cs, new_c_type, aux, objfile);
+         index_type = builtin_type_int32;

          range_type =
            create_range_type ((struct type *) NULL, index_type, 0, n - 1);
          type =
          range_type =
            create_range_type ((struct type *) NULL, index_type, 0, n - 1);
          type =


@@ -1765,7 +1733,7 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
        }
     }
 
        }
     }
 

-  return decode_base_type (cs, BTYPE (c_type), aux);
+  return decode_base_type (cs, BTYPE (c_type), aux, objfile);

 }
 
 /* Decode a coff type specifier for function definition;
 }
 
 /* Decode a coff type specifier for function definition;


@@ -1773,59 +1741,60 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
 
 static struct type *
 decode_function_type (struct coff_symbol *cs, unsigned int c_type,
 
 static struct type *
 decode_function_type (struct coff_symbol *cs, unsigned int c_type,

-                     union internal_auxent *aux)
+                     union internal_auxent *aux, struct objfile *objfile)

 {
   if (aux->x_sym.x_tagndx.l == 0)
     cs->c_naux = 0;            /* auxent refers to function, not base type */
 
 {
   if (aux->x_sym.x_tagndx.l == 0)
     cs->c_naux = 0;            /* auxent refers to function, not base type */
 

-  return decode_type (cs, DECREF (c_type), aux);
+  return decode_type (cs, DECREF (c_type), aux, objfile);

 }
 \f
 /* basic C types */
 
 static struct type *
 decode_base_type (struct coff_symbol *cs, unsigned int c_type,
 }
 \f
 /* basic C types */
 
 static struct type *
 decode_base_type (struct coff_symbol *cs, unsigned int c_type,

-                 union internal_auxent *aux)
+                 union internal_auxent *aux, struct objfile *objfile)

 {
 {

+  struct gdbarch *gdbarch = get_objfile_arch (objfile);

   struct type *type;
 
   switch (c_type)
     {
     case T_NULL:
       /* shows up with "void (*foo)();" structure members */
   struct type *type;
 
   switch (c_type)
     {
     case T_NULL:
       /* shows up with "void (*foo)();" structure members */

-      return lookup_fundamental_type (current_objfile, FT_VOID);
+      return builtin_type (gdbarch)->builtin_void;

 
 #ifdef T_VOID
     case T_VOID:
       /* Intel 960 COFF has this symbol and meaning.  */
 
 #ifdef T_VOID
     case T_VOID:
       /* Intel 960 COFF has this symbol and meaning.  */

-      return lookup_fundamental_type (current_objfile, FT_VOID);
+      return builtin_type (gdbarch)->builtin_void;

 #endif
 
     case T_CHAR:
 #endif
 
     case T_CHAR:

-      return lookup_fundamental_type (current_objfile, FT_CHAR);
+      return builtin_type (gdbarch)->builtin_char;

 
     case T_SHORT:
 
     case T_SHORT:

-      return lookup_fundamental_type (current_objfile, FT_SHORT);
+      return builtin_type (gdbarch)->builtin_short;

 
     case T_INT:
 
     case T_INT:

-      return lookup_fundamental_type (current_objfile, FT_INTEGER);
+      return builtin_type (gdbarch)->builtin_int;

 
     case T_LONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size
 
     case T_LONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size

-            > gdbarch_long_bit (current_gdbarch))
-       return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
+            > gdbarch_long_bit (gdbarch))
+       return builtin_type (gdbarch)->builtin_long_long;

       else
       else

-       return lookup_fundamental_type (current_objfile, FT_LONG);
+       return builtin_type (gdbarch)->builtin_long;

 
     case T_FLOAT:
 
     case T_FLOAT:

-      return lookup_fundamental_type (current_objfile, FT_FLOAT);
+      return builtin_type (gdbarch)->builtin_float;

 
     case T_DOUBLE:
 
     case T_DOUBLE:

-      return lookup_fundamental_type (current_objfile, FT_DBL_PREC_FLOAT);
+      return builtin_type (gdbarch)->builtin_double;

 
     case T_LNGDBL:
 
     case T_LNGDBL:

-      return lookup_fundamental_type (current_objfile, FT_EXT_PREC_FLOAT);
+      return builtin_type (gdbarch)->builtin_long_double;

 
     case T_STRUCT:
       if (cs->c_naux != 1)
 
     case T_STRUCT:
       if (cs->c_naux != 1)


@@ -1847,7 +1816,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
        {
          type = coff_read_struct_type (cs->c_symnum,
                                        aux->x_sym.x_misc.x_lnsz.x_size,
        {
          type = coff_read_struct_type (cs->c_symnum,
                                        aux->x_sym.x_misc.x_lnsz.x_size,

-                                     aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+                                       objfile);

        }
       return type;
 
        }
       return type;
 


@@ -1870,7 +1840,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
        {
          type = coff_read_struct_type (cs->c_symnum,
                                        aux->x_sym.x_misc.x_lnsz.x_size,
        {
          type = coff_read_struct_type (cs->c_symnum,
                                        aux->x_sym.x_misc.x_lnsz.x_size,

-                                     aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+                                       aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+                                       objfile);

        }
       TYPE_CODE (type) = TYPE_CODE_UNION;
       return type;
        }
       TYPE_CODE (type) = TYPE_CODE_UNION;
       return type;


@@ -1894,7 +1865,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
        {
          type = coff_read_enum_type (cs->c_symnum,
                                      aux->x_sym.x_misc.x_lnsz.x_size,
        {
          type = coff_read_enum_type (cs->c_symnum,
                                      aux->x_sym.x_misc.x_lnsz.x_size,

-                                     aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+                                     aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
+                                     objfile);

        }
       return type;
 
        }
       return type;
 


@@ -1903,24 +1875,24 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
       break;
 
     case T_UCHAR:
       break;
 
     case T_UCHAR:

-      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_CHAR);
+      return builtin_type (gdbarch)->builtin_unsigned_char;

 
     case T_USHORT:
 
     case T_USHORT:

-      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_SHORT);
+      return builtin_type (gdbarch)->builtin_unsigned_short;

 
     case T_UINT:
 
     case T_UINT:

-      return lookup_fundamental_type (current_objfile, FT_UNSIGNED_INTEGER);
+      return builtin_type (gdbarch)->builtin_unsigned_int;

 
     case T_ULONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size
 
     case T_ULONG:
       if (cs->c_sclass == C_FIELD
          && aux->x_sym.x_misc.x_lnsz.x_size

-            > gdbarch_long_bit (current_gdbarch))
-       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
+            > gdbarch_long_bit (gdbarch))
+       return builtin_type (gdbarch)->builtin_unsigned_long_long;

       else
       else

-       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG);
+       return builtin_type (gdbarch)->builtin_unsigned_long;

     }
   complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);
     }
   complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);

-  return lookup_fundamental_type (current_objfile, FT_VOID);
+  return builtin_type (gdbarch)->builtin_void;

 }
 \f
 /* This page contains subroutines of read_type.  */
 }
 \f
 /* This page contains subroutines of read_type.  */


@@ -1929,7 +1901,8 @@ decode_base_type (struct coff_symbol *cs, unsigned int c_type,
    object describing the type.  */
 
 static struct type *
    object describing the type.  */
 
 static struct type *

-coff_read_struct_type (int index, int length, int lastsym)
+coff_read_struct_type (int index, int length, int lastsym,
+                      struct objfile *objfile)

 {
   struct nextfield
     {
 {
   struct nextfield
     {


@@ -1958,7 +1931,7 @@ coff_read_struct_type (int index, int length, int lastsym)
     {
       read_one_sym (ms, &sub_sym, &sub_aux);
       name = ms->c_name;
     {
       read_one_sym (ms, &sub_sym, &sub_aux);
       name = ms->c_name;

-      name = EXTERNAL_NAME (name, current_objfile->obfd);
+      name = EXTERNAL_NAME (name, objfile->obfd);

 
       switch (ms->c_sclass)
        {
 
       switch (ms->c_sclass)
        {


@@ -1972,13 +1945,11 @@ coff_read_struct_type (int index, int length, int lastsym)
 
          /* Save the data.  */
          list->field.name =
 
          /* Save the data.  */
          list->field.name =

-           obsavestring (name,
-                         strlen (name),
-                         &current_objfile->objfile_obstack);
-         FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
-         FIELD_BITPOS (list->field) = 8 * ms->c_value;
+           obsavestring (name, strlen (name), &objfile->objfile_obstack);
+         FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux,
+                                                 objfile);
+         SET_FIELD_BITPOS (list->field, 8 * ms->c_value);

          FIELD_BITSIZE (list->field) = 0;
          FIELD_BITSIZE (list->field) = 0;

-         FIELD_STATIC_KIND (list->field) = 0;

          nfields++;
          break;
 
          nfields++;
          break;
 


@@ -1991,13 +1962,11 @@ coff_read_struct_type (int index, int length, int lastsym)
 
          /* Save the data.  */
          list->field.name =
 
          /* Save the data.  */
          list->field.name =

-           obsavestring (name,
-                         strlen (name),
-                         &current_objfile->objfile_obstack);
-         FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux);
-         FIELD_BITPOS (list->field) = ms->c_value;
+           obsavestring (name, strlen (name), &objfile->objfile_obstack);
+         FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux,
+                                                 objfile);
+         SET_FIELD_BITPOS (list->field, ms->c_value);

          FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
          FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;

-         FIELD_STATIC_KIND (list->field) = 0;

          nfields++;
          break;
 
          nfields++;
          break;
 


@@ -2025,8 +1994,10 @@ coff_read_struct_type (int index, int length, int lastsym)
    Also defines the symbols that represent the values of the type.  */
 
 static struct type *
    Also defines the symbols that represent the values of the type.  */
 
 static struct type *

-coff_read_enum_type (int index, int length, int lastsym)
+coff_read_enum_type (int index, int length, int lastsym,
+                    struct objfile *objfile)

 {
 {

+  struct gdbarch *gdbarch = get_objfile_arch (objfile);

   struct symbol *sym;
   struct type *type;
   int nsyms = 0;
   struct symbol *sym;
   struct type *type;
   int nsyms = 0;


@@ -2054,19 +2025,18 @@ coff_read_enum_type (int index, int length, int lastsym)
     {
       read_one_sym (ms, &sub_sym, &sub_aux);
       name = ms->c_name;
     {
       read_one_sym (ms, &sub_sym, &sub_aux);
       name = ms->c_name;

-      name = EXTERNAL_NAME (name, current_objfile->obfd);
+      name = EXTERNAL_NAME (name, objfile->obfd);

 
       switch (ms->c_sclass)
        {
        case C_MOE:
          sym = (struct symbol *) obstack_alloc
 
       switch (ms->c_sclass)
        {
        case C_MOE:
          sym = (struct symbol *) obstack_alloc

-           (&current_objfile->objfile_obstack,
-            sizeof (struct symbol));
+           (&objfile->objfile_obstack, sizeof (struct symbol));

          memset (sym, 0, sizeof (struct symbol));
 
          memset (sym, 0, sizeof (struct symbol));
 

-         DEPRECATED_SYMBOL_NAME (sym) =
-           obsavestring (name, strlen (name),
-                         &current_objfile->objfile_obstack);
+         SYMBOL_SET_LINKAGE_NAME (sym,
+                                  obsavestring (name, strlen (name),
+                                                &objfile->objfile_obstack));

          SYMBOL_CLASS (sym) = LOC_CONST;
          SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
          SYMBOL_VALUE (sym) = ms->c_value;
          SYMBOL_CLASS (sym) = LOC_CONST;
          SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
          SYMBOL_VALUE (sym) = ms->c_value;


@@ -2088,7 +2058,7 @@ coff_read_enum_type (int index, int length, int lastsym)
   if (length > 0)
     TYPE_LENGTH (type) = length;
   else /* Assume ints.  */
   if (length > 0)
     TYPE_LENGTH (type) = length;
   else /* Assume ints.  */

-    TYPE_LENGTH (type) = gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT;
+    TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;

   TYPE_CODE (type) = TYPE_CODE_ENUM;
   TYPE_NFIELDS (type) = nsyms;
   TYPE_FIELDS (type) = (struct field *)
   TYPE_CODE (type) = TYPE_CODE_ENUM;
   TYPE_NFIELDS (type) = nsyms;
   TYPE_FIELDS (type) = (struct field *)


@@ -2112,19 +2082,18 @@ coff_read_enum_type (int index, int length, int lastsym)
        {
          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_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+         TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
+         SET_FIELD_BITPOS (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));

          if (SYMBOL_VALUE (xsym) < 0)
            unsigned_enum = 0;
          TYPE_FIELD_BITSIZE (type, n) = 0;
          if (SYMBOL_VALUE (xsym) < 0)
            unsigned_enum = 0;
          TYPE_FIELD_BITSIZE (type, n) = 0;

-         TYPE_FIELD_STATIC_KIND (type, n) = 0;

        }
       if (syms == osyms)
        break;
     }
 
   if (unsigned_enum)
        }
       if (syms == osyms)
        break;
     }
 
   if (unsigned_enum)

-    TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
+    TYPE_UNSIGNED (type) = 1;

 
   return type;
 }
 
   return type;
 }


@@ -2141,6 +2110,7 @@ static struct sym_fns coff_sym_fns =
   default_symfile_offsets,     /* sym_offsets:  xlate external to internal form */
   default_symfile_segments,    /* sym_segments: Get segment information from
                                   a file.  */
   default_symfile_offsets,     /* sym_offsets:  xlate external to internal form */
   default_symfile_segments,    /* sym_segments: Get segment information from
                                   a file.  */

+  NULL,                         /* sym_read_linetable  */

   NULL                         /* next: pointer to next struct sym_fns */
 };
 
   NULL                         /* next: pointer to next struct sym_fns */
 };