projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* symtab.h: Rename SYMBOL_OPS to SYMBOL_COMPUTED_OPS.
[deliverable/binutils-gdb.git] / gdb / coffread.c
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 215be80ef96032760256a66ae283a131b1caae8a..201cfa26f2e7bfd66075ec8f2fc43482b7791ba9 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.
 /* Read coff symbol tables and convert to internal format, for GDB.
-   Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
-   1997, 1998, 1999, 2000, 2001, 2002, 2003
+   Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+   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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, 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"
@@ -35,8 +33,6 @@
 
 #include "coff/internal.h"     /* Internal format of COFF symbols in BFD */
 #include "libcoff.h"           /* FIXME secret internal data from BFD */
 
 #include "coff/internal.h"     /* Internal format of COFF symbols in BFD */
 #include "libcoff.h"           /* FIXME secret internal data from BFD */
-
-#include "symfile.h"
 #include "objfiles.h"
 #include "buildsym.h"
 #include "gdb-stabs.h"
 #include "objfiles.h"
 #include "buildsym.h"
 #include "gdb-stabs.h"
@@ -141,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 *,
@@ -202,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);
@@ -211,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;
     }
@@ -261,29 +262,27 @@ find_targ_sec (bfd *abfd, asection *sect, void *obj)
     *args->resultp = sect;
 }
 
     *args->resultp = sect;
 }
 
-/* Return the section number (SECT_OFF_*) that CS points to.  */
-static int
-cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
+/* Return the bfd_section that CS points to.  */
+static struct bfd_section*
+cs_to_bfd_section (struct coff_symbol *cs, struct objfile *objfile)
 {
   asection *sect = NULL;
   struct find_targ_sec_arg args;
 {
   asection *sect = NULL;
   struct find_targ_sec_arg args;
-  int off = SECT_OFF_TEXT (objfile);
 
   args.targ_index = cs->c_secnum;
   args.resultp = &sect;
   bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
 
   args.targ_index = cs->c_secnum;
   args.resultp = &sect;
   bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
-  if (sect != NULL)
-    {
-      /* This is the section.  Figure out what SECT_OFF_* code it is.  */
-      if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
-       off = SECT_OFF_TEXT (objfile);
-      else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
-       off = SECT_OFF_DATA (objfile);
-      else
-       /* Just return the bfd section index. */
-       off = sect->index;
-    }
-  return off;
+  return sect;
+}
+
+/* Return the section number (SECT_OFF_*) that CS points to.  */
+static int
+cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
+{
+  asection *sect = cs_to_bfd_section (cs, objfile);
+  if (sect == NULL)
+    return SECT_OFF_TEXT (objfile);
+  return sect->index;
 }
 
 /* Return the address of the section of a COFF symbol.  */
 }
 
 /* Return the address of the section of a COFF symbol.  */
@@ -365,7 +364,7 @@ coff_start_symtab (char *name)
      this pointer into last_source_file and we put it in
      subfiles->name, which end_symtab frees; that's why
      it must be malloc'd.  */
      this pointer into last_source_file and we put it in
      subfiles->name, which end_symtab frees; that's why
      it must be malloc'd.  */
-                savestring (name, strlen (name)),
+                xstrdup (name),
   /* We never know the directory name for COFF.  */
                 NULL,
   /* The start address is irrelevant, since we set
   /* We never know the directory name for COFF.  */
                 NULL,
   /* The start address is irrelevant, since we set
@@ -384,16 +383,9 @@ complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size)
 {
   if (last_source_file != NULL)
     xfree (last_source_file);
 {
   if (last_source_file != NULL)
     xfree (last_source_file);
-  last_source_file = savestring (name, strlen (name));
+  last_source_file = xstrdup (name);
   current_source_start_addr = start_addr;
   current_source_end_addr = start_addr + size;
   current_source_start_addr = start_addr;
   current_source_end_addr = start_addr + size;
-
-  if (current_objfile->ei.entry_point >= current_source_start_addr &&
-      current_objfile->ei.entry_point < current_source_end_addr)
-    {
-      current_objfile->ei.deprecated_entry_file_lowpc = current_source_start_addr;
-      current_objfile->ei.deprecated_entry_file_highpc = current_source_end_addr;
-    }
 }
 
 /* Finish the symbol definitions for one main source file,
 }
 
 /* Finish the symbol definitions for one main source file,
@@ -417,15 +409,19 @@ coff_end_symtab (struct objfile *objfile)
   last_source_file = NULL;
 }
 \f
   last_source_file = NULL;
 }
 \f
-static void
-record_minimal_symbol (char *name, CORE_ADDR address,
-                      enum minimal_symbol_type type, struct objfile *objfile)
+static struct minimal_symbol *
+record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address,
+                      enum minimal_symbol_type type, int section, 
+                      struct objfile *objfile)
 {
 {
+  struct bfd_section *bfd_section;
   /* We don't want TDESC entry points in the minimal symbol table */
   /* We don't want TDESC entry points in the minimal symbol table */
-  if (name[0] == '@')
-    return;
+  if (cs->c_name[0] == '@')
+    return NULL;
 
 
-  prim_record_minimal_symbol (name, address, type, objfile);
+  bfd_section = cs_to_bfd_section (cs, objfile);
+  return prim_record_minimal_symbol_and_info (cs->c_name, address, type,
+                                             section, bfd_section, objfile);
 }
 \f
 /* coff_symfile_init ()
 }
 \f
 /* coff_symfile_init ()
@@ -445,17 +441,16 @@ static void
 coff_symfile_init (struct objfile *objfile)
 {
   /* Allocate struct to keep track of stab reading. */
 coff_symfile_init (struct objfile *objfile)
 {
   /* Allocate struct to keep track of stab reading. */
-  objfile->sym_stab_info = (struct dbx_symfile_info *)
-    xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
+  objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *)
+    xmalloc (sizeof (struct dbx_symfile_info));
 
 
-  memset (objfile->sym_stab_info, 0,
+  memset (objfile->deprecated_sym_stab_info, 0,
          sizeof (struct dbx_symfile_info));
 
   /* Allocate struct to keep track of the symfile */
          sizeof (struct dbx_symfile_info));
 
   /* Allocate struct to keep track of the symfile */
-  objfile->sym_private = xmmalloc (objfile->md,
-                                  sizeof (struct coff_symfile_info));
+  objfile->deprecated_sym_private = xmalloc (sizeof (struct coff_symfile_info));
 
 
-  memset (objfile->sym_private, 0, sizeof (struct coff_symfile_info));
+  memset (objfile->deprecated_sym_private, 0, sizeof (struct coff_symfile_info));
 
   /* COFF objects may be reordered, so set OBJF_REORDERED.  If we
      find this causes a significant slowdown in gdb then we could
 
   /* COFF objects may be reordered, so set OBJF_REORDERED.  If we
      find this causes a significant slowdown in gdb then we could
@@ -522,8 +517,8 @@ coff_symfile_read (struct objfile *objfile, int mainline)
   int len;
   char * target;
   
   int len;
   char * target;
   
-  info = (struct coff_symfile_info *) objfile->sym_private;
-  dbxinfo = objfile->sym_stab_info;
+  info = (struct coff_symfile_info *) objfile->deprecated_sym_private;
+  dbxinfo = objfile->deprecated_sym_stab_info;
   symfile_bfd = abfd;          /* Kludge for swap routines */
 
 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
   symfile_bfd = abfd;          /* Kludge for swap routines */
 
 /* WARNING WILL ROBINSON!  ACCESSING BFD-PRIVATE DATA HERE!  FIXME!  */
@@ -586,7 +581,7 @@ coff_symfile_read (struct objfile *objfile, int mainline)
       val = init_lineno (abfd, info->min_lineno_offset,
                          info->max_lineno_offset - info->min_lineno_offset);
       if (val < 0)
       val = init_lineno (abfd, info->min_lineno_offset,
                          info->max_lineno_offset - info->min_lineno_offset);
       if (val < 0)
-        error ("\"%s\": error reading line numbers\n", name);
+        error (_("\"%s\": error reading line numbers."), name);
     }
 
   /* Now read the string table, all at once.  */
     }
 
   /* Now read the string table, all at once.  */
@@ -594,7 +589,7 @@ coff_symfile_read (struct objfile *objfile, int mainline)
   make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
   val = init_stringtab (abfd, stringtab_offset);
   if (val < 0)
   make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
   val = init_stringtab (abfd, stringtab_offset);
   if (val < 0)
-    error ("\"%s\": can't get string table", name);
+    error (_("\"%s\": can't get string table"), name);
 
   init_minimal_symbol_collection ();
   cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols ();
 
   init_minimal_symbol_collection ();
   cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols ();
@@ -612,15 +607,23 @@ coff_symfile_read (struct objfile *objfile, int mainline)
   /* Free the installed minimal symbol data.  */
   do_cleanups (cleanup_minimal_symbols);
 
   /* Free the installed minimal symbol data.  */
   do_cleanups (cleanup_minimal_symbols);
 
+  /* If we are reinitializing, or if we have not loaded syms yet,
+     empty the psymtab.  "mainline" is cleared so the *_read_psymtab
+     functions do not all re-initialize it.  */
+  if (mainline)
+    {
+      init_psymbol_list (objfile, 0);
+      mainline = 0;
+    }
+
   bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
 
   if (info->stabsects)
     {
       if (!info->stabstrsect)
        {
   bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
 
   if (info->stabsects)
     {
       if (!info->stabstrsect)
        {
-         error (("The debugging information in `%s' is corrupted.\n"
-                 "The file has a `.stabs' section, but no `.stabstr' "
-                 "section."),
+         error (_("The debugging information in `%s' is corrupted.\n"
+                  "The file has a `.stabs' section, but no `.stabstr' section."),
                 name);
        }
 
                 name);
        }
 
@@ -636,12 +639,14 @@ coff_symfile_read (struct objfile *objfile, int mainline)
                               info->stabsects,
                               info->stabstrsect->filepos, stabstrsize);
     }
                               info->stabsects,
                               info->stabstrsect->filepos, stabstrsize);
     }
-  if (dwarf2_has_info (abfd))
+  if (dwarf2_has_info (objfile))
     {
       /* DWARF2 sections.  */
       dwarf2_build_psymtabs (objfile, mainline);
     }
 
     {
       /* DWARF2 sections.  */
       dwarf2_build_psymtabs (objfile, mainline);
     }
 
+  dwarf2_build_frame_info (objfile);
+
   do_cleanups (back_to);
 }
 
   do_cleanups (back_to);
 }
 
@@ -658,13 +663,15 @@ coff_new_init (struct objfile *ignore)
 static void
 coff_symfile_finish (struct objfile *objfile)
 {
 static void
 coff_symfile_finish (struct objfile *objfile)
 {
-  if (objfile->sym_private != NULL)
+  if (objfile->deprecated_sym_private != NULL)
     {
     {
-      xmfree (objfile->md, objfile->sym_private);
+      xfree (objfile->deprecated_sym_private);
     }
 
   /* Let stabs reader clean up */
   stabsread_clear_cache ();
     }
 
   /* Let stabs reader clean up */
   stabsread_clear_cache ();
+
+  dwarf2_free_objfile (objfile);
 }
 \f
 
 }
 \f
 
@@ -677,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;
@@ -699,6 +707,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
   long fcn_line_ptr = 0;
   int val;
   CORE_ADDR tmpaddr;
   long fcn_line_ptr = 0;
   int val;
   CORE_ADDR tmpaddr;
+  struct minimal_symbol *msym;
 
   /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
      it's hard to know I've really worked around it.  The fix should be
 
   /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
      it's hard to know I've really worked around it.  The fix should be
@@ -749,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 */
        }
@@ -762,8 +776,9 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
       if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
        {
          /* Record all functions -- external and static -- in minsyms. */
       if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
        {
          /* Record all functions -- external and static -- in minsyms. */
+         int section = cs_to_section (cs, objfile);
          tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
          tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
-         record_minimal_symbol (cs->c_name, tmpaddr, mst_text, objfile);
+         record_minimal_symbol (cs, tmpaddr, mst_text, section, objfile);
 
          fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
          fcn_start_addr = tmpaddr;
 
          fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
          fcn_start_addr = tmpaddr;
@@ -782,7 +797,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
        case C_LINE:
        case C_ALIAS:
        case C_HIDDEN:
        case C_LINE:
        case C_ALIAS:
        case C_HIDDEN:
-         complaint (&symfile_complaints, "Bad n_sclass for symbol %s",
+         complaint (&symfile_complaints, _("Bad n_sclass for symbol %s"),
                     cs->c_name);
          break;
 
                     cs->c_name);
          break;
 
@@ -819,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! */
@@ -890,6 +905,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              }
            else
              {
              }
            else
              {
+               asection *bfd_section = cs_to_bfd_section (cs, objfile);
                sec = cs_to_section (cs, objfile);
                tmpaddr = cs->c_value;
                /* Statics in a PE file also get relocated */
                sec = cs_to_section (cs, objfile);
                tmpaddr = cs->c_value;
                /* Statics in a PE file also get relocated */
@@ -899,39 +915,35 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
                    || (pe_file && (cs->c_sclass == C_STAT)))
                  tmpaddr += ANOFFSET (objfile->section_offsets, sec);
 
                    || (pe_file && (cs->c_sclass == C_STAT)))
                  tmpaddr += ANOFFSET (objfile->section_offsets, sec);
 
-               if (sec == SECT_OFF_TEXT (objfile))
+               if (bfd_section->flags & SEC_CODE)
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
                      || cs->c_sclass == C_THUMBEXT ?
                      mst_text : mst_file_text;
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
                      || cs->c_sclass == C_THUMBEXT ?
                      mst_text : mst_file_text;
-                   tmpaddr = SMASH_TEXT_ADDRESS (tmpaddr);
+                   tmpaddr = gdbarch_smash_text_address (gdbarch, tmpaddr);
                  }
                  }
-               else if (sec == SECT_OFF_DATA (objfile))
+               else if (bfd_section->flags & SEC_ALLOC
+                        && bfd_section->flags & SEC_LOAD)
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
                      mst_data : mst_file_data;
                  }
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
                      mst_data : mst_file_data;
                  }
-               else if (sec == SECT_OFF_BSS (objfile))
+               else if (bfd_section->flags & SEC_ALLOC)
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
                  {
                    ms_type =
                      cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ?
-                     mst_data : mst_file_data;
+                     mst_bss : mst_file_bss;
                  }
                else
                  ms_type = mst_unknown;
              }
 
                  }
                else
                  ms_type = mst_unknown;
              }
 
-           if (cs->c_name[0] != '@' /* Skip tdesc symbols */ )
-             {
-               struct minimal_symbol *msym;
-               msym = prim_record_minimal_symbol_and_info
-                 (cs->c_name, tmpaddr, ms_type, NULL,
-                  sec, NULL, objfile);
-               if (msym)
-                 COFF_MAKE_MSYMBOL_SPECIAL (cs->c_sclass, msym);
-             }
+           msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile);
+           if (msym)
+             gdbarch_coff_make_msymbol_special (gdbarch, cs->c_sclass, msym);
+
            if (SDB_TYPE (cs->c_type))
              {
                struct symbol *sym;
            if (SDB_TYPE (cs->c_type))
              {
                struct symbol *sym;
@@ -944,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;
 
@@ -953,7 +965,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
                 contains line number of '{' } */
              if (cs->c_naux != 1)
                complaint (&symfile_complaints,
                 contains line number of '{' } */
              if (cs->c_naux != 1)
                complaint (&symfile_complaints,
-                          "`.bf' symbol %d has no aux entry", cs->c_symnum);
+                          _("`.bf' symbol %d has no aux entry"), cs->c_symnum);
              fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
              fcn_first_line_addr = cs->c_value;
 
              fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
              fcn_first_line_addr = cs->c_value;
 
@@ -966,10 +978,10 @@ 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)
            {
              if (!within_function)
-               error ("Bad coff function information\n");
+               error (_("Bad coff function information."));
              /* the value of .ef is the address of epilogue code;
                 not useful for gdb.  */
              /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
              /* the value of .ef is the address of epilogue code;
                 not useful for gdb.  */
              /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
@@ -978,7 +990,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              if (context_stack_depth <= 0)
                {               /* We attempted to pop an empty context stack */
                  complaint (&symfile_complaints,
              if (context_stack_depth <= 0)
                {               /* We attempted to pop an empty context stack */
                  complaint (&symfile_complaints,
-                            "`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d",
+                            _("`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d"),
                             cs->c_symnum);
                  within_function = 0;
                  break;
                             cs->c_symnum);
                  within_function = 0;
                  break;
@@ -989,7 +1001,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              if (context_stack_depth > 0 || new == NULL)
                {
                  complaint (&symfile_complaints,
              if (context_stack_depth > 0 || new == NULL)
                {
                  complaint (&symfile_complaints,
-                            "Unmatched .ef symbol(s) ignored starting at symnum %d",
+                            _("Unmatched .ef symbol(s) ignored starting at symnum %d"),
                             cs->c_symnum);
                  within_function = 0;
                  break;
                             cs->c_symnum);
                  within_function = 0;
                  break;
@@ -997,7 +1009,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              if (cs->c_naux != 1)
                {
                  complaint (&symfile_complaints,
              if (cs->c_naux != 1)
                {
                  complaint (&symfile_complaints,
-                            "`.ef' symbol %d has no aux entry", cs->c_symnum);
+                            _("`.ef' symbol %d has no aux entry"), cs->c_symnum);
                  fcn_last_line = 0x7FFFFFFF;
                }
              else
                  fcn_last_line = 0x7FFFFFFF;
                }
              else
@@ -1019,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;
@@ -1042,18 +1041,18 @@ 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 */
                  complaint (&symfile_complaints,
            {
              if (context_stack_depth <= 0)
                {               /* We attempted to pop an empty context stack */
                  complaint (&symfile_complaints,
-                            "`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d",
+                            _("`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d"),
                             cs->c_symnum);
                  break;
                }
                             cs->c_symnum);
                  break;
                }
@@ -1062,7 +1061,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
              if (depth-- != new->depth)
                {
                  complaint (&symfile_complaints,
              if (depth-- != new->depth)
                {
                  complaint (&symfile_complaints,
-                            "Mismatched .eb symbol ignored starting at symnum %d",
+                            _("Mismatched .eb symbol ignored starting at symnum %d"),
                             symnum);
                  break;
                }
                             symnum);
                  break;
                }
@@ -1087,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);
     }
@@ -1115,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;
@@ -1140,7 +1148,7 @@ read_one_sym (struct coff_symbol *cs,
 
 #if 0
   if (cs->c_sclass & 128)
 
 #if 0
   if (cs->c_sclass & 128)
-    printf ("thumb symbol %s, class 0x%x\n", cs->c_name, cs->c_sclass);
+    printf (_("thumb symbol %s, class 0x%x\n"), cs->c_name, cs->c_sclass);
 #endif
 
   symnum += 1 + cs->c_naux;
 #endif
 
   symnum += 1 + cs->c_naux;
@@ -1350,7 +1358,7 @@ enter_linenos (long file_offset, int first_line,
   if (file_offset < linetab_offset)
     {
       complaint (&symfile_complaints,
   if (file_offset < linetab_offset)
     {
       complaint (&symfile_complaints,
-                "Line number pointer %ld lower than start of line numbers",
+                _("Line number pointer %ld lower than start of line numbers"),
                 file_offset);
       if (file_offset > linetab_size)  /* Too big to be an offset? */
        return;
                 file_offset);
       if (file_offset > linetab_size)  /* Too big to be an offset? */
        return;
@@ -1364,11 +1372,15 @@ enter_linenos (long file_offset, int first_line,
   /* line numbers start at one for the first line of the function */
   first_line--;
 
   /* line numbers start at one for the first line of the function */
   first_line--;
 
-  for (;;)
+  /* If the line number table is full (e.g. 64K lines in COFF debug
+     info), the next function's L_LNNO32 might not be zero, so don't
+     overstep the table's end in any case.  */
+  while (rawptr <= &linetab[0] + linetab_size)
     {
       bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
       rawptr += local_linesz;
     {
       bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
       rawptr += local_linesz;
-      /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
+      /* The next function, or the sentinel, will have L_LNNO32 zero;
+        we exit. */
       if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
        record_line (current_subfile, first_line + L_LNNO32 (&lptr),
                     lptr.l_addr.l_paddr
       if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
        record_line (current_subfile, first_line + L_LNNO32 (&lptr),
                     lptr.l_addr.l_paddr
@@ -1395,7 +1407,7 @@ patch_type (struct type *type, struct type *real_type)
     {
       if (TYPE_NAME (target))
        xfree (TYPE_NAME (target));
     {
       if (TYPE_NAME (target))
        xfree (TYPE_NAME (target));
-      TYPE_NAME (target) = concat (TYPE_NAME (real_target), NULL);
+      TYPE_NAME (target) = concat (TYPE_NAME (real_target), (char *)NULL);
     }
 }
 
     }
 }
 
@@ -1422,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)
                    {
@@ -1462,20 +1474,30 @@ patch_opaque_types (struct symtab *s)
     }
 }
 \f
     }
 }
 \f
+static int
+coff_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
+{
+  return gdbarch_sdb_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+}
+
+static const struct symbol_register_ops coff_register_funcs = {
+  coff_reg_to_regnum
+};
+
 static struct symbol *
 process_coff_symbol (struct coff_symbol *cs,
                     union internal_auxent *aux,
                     struct objfile *objfile)
 {
   struct symbol *sym
 static struct symbol *
 process_coff_symbol (struct coff_symbol *cs,
                     union internal_auxent *aux,
                     struct objfile *objfile)
 {
   struct symbol *sym
-  = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
+  = (struct symbol *) obstack_alloc (&objfile->objfile_obstack,
                                     sizeof (struct symbol));
   char *name;
 
   memset (sym, 0, sizeof (struct symbol));
   name = cs->c_name;
   name = EXTERNAL_NAME (name, objfile->obfd);
                                     sizeof (struct symbol));
   char *name;
 
   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 */
@@ -1487,7 +1509,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
@@ -1499,7 +1521,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:
@@ -1542,7 +1564,8 @@ process_coff_symbol (struct coff_symbol *cs,
 #endif
        case C_REG:
          SYMBOL_CLASS (sym) = LOC_REGISTER;
 #endif
        case C_REG:
          SYMBOL_CLASS (sym) = LOC_REGISTER;
-         SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+         SYMBOL_REGISTER_OPS (sym) = &coff_register_funcs;
+         SYMBOL_VALUE (sym) = cs->c_value;
          add_symbol_to_list (sym, &local_symbols);
          break;
 
          add_symbol_to_list (sym, &local_symbols);
          break;
 
@@ -1552,52 +1575,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 (TARGET_BYTE_ORDER == 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_VALUE (sym) = SDB_REG_TO_REGNUM (cs->c_value);
+         SYMBOL_CLASS (sym) = LOC_REGISTER;
+         SYMBOL_REGISTER_OPS (sym) = &coff_register_funcs;
+         SYMBOL_IS_ARGUMENT (sym) = 1;
+         SYMBOL_VALUE (sym) = cs->c_value;
          add_symbol_to_list (sym, &local_symbols);
          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:
@@ -1632,7 +1619,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), 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,
@@ -1645,7 +1632,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;
@@ -1663,11 +1650,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), NULL);
+               concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);
 
          add_symbol_to_list (sym, &file_symbols);
          break;
 
          add_symbol_to_list (sym, &file_symbols);
          break;
@@ -1683,7 +1670,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;
@@ -1693,12 +1680,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))
@@ -1720,8 +1707,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 =
@@ -1750,13 +1737,13 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
       else
        {
          complaint (&symfile_complaints,
       else
        {
          complaint (&symfile_complaints,
-                    "Symbol table entry for %s has bad tagndx value",
+                    _("Symbol table entry for %s has bad tagndx value"),
                     cs->c_name);
          /* And fall through to decode_base_type... */
        }
     }
 
                     cs->c_name);
          /* And fall through to decode_base_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;
@@ -1764,58 +1751,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
 
     case T_LONG:
       if (cs->c_sclass == C_FIELD
-         && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
-       return lookup_fundamental_type (current_objfile, FT_LONG_LONG);
+         && aux->x_sym.x_misc.x_lnsz.x_size
+            > 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)
@@ -1837,7 +1826,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;
 
@@ -1860,7 +1850,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;
@@ -1884,7 +1875,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;
 
@@ -1893,23 +1885,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
 
     case T_ULONG:
       if (cs->c_sclass == C_FIELD
-         && aux->x_sym.x_misc.x_lnsz.x_size > TARGET_LONG_BIT)
-       return lookup_fundamental_type (current_objfile, FT_UNSIGNED_LONG_LONG);
+         && aux->x_sym.x_misc.x_lnsz.x_size
+            > 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);
-  return lookup_fundamental_type (current_objfile, FT_VOID);
+  complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name);
+  return builtin_type (gdbarch)->builtin_void;
 }
 \f
 /* This page contains subroutines of read_type.  */
 }
 \f
 /* This page contains subroutines of read_type.  */
@@ -1918,7 +1911,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
     {
@@ -1947,7 +1941,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)
        {
@@ -1961,13 +1955,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->symbol_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;
 
@@ -1980,13 +1972,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->symbol_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;
 
@@ -2014,8 +2004,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;
@@ -2043,19 +2035,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->symbol_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->symbol_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;
@@ -2076,8 +2067,8 @@ coff_read_enum_type (int index, int length, int lastsym)
 
   if (length > 0)
     TYPE_LENGTH (type) = length;
 
   if (length > 0)
     TYPE_LENGTH (type) = length;
-  else
-    TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;     /* Assume ints */
+  else /* Assume ints.  */
+    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 *)
@@ -2101,19 +2092,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;
 }
@@ -2128,6 +2118,9 @@ static struct sym_fns coff_sym_fns =
   coff_symfile_read,           /* sym_read: read a symbol file into symtab */
   coff_symfile_finish,         /* sym_finish: finished with file, cleanup */
   default_symfile_offsets,     /* sym_offsets:  xlate external to internal form */
   coff_symfile_read,           /* sym_read: read a symbol file into symtab */
   coff_symfile_finish,         /* sym_finish: finished with file, cleanup */
   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 */
 };
 
GDB Binutils - Deliverables
This page took 0.040348 seconds and 4 git commands to generate.