Add support for the readnever concept
[deliverable/binutils-gdb.git] / gdb / xcoffread.c
index 4dd048d5d96f306f17d539461da65748fb06dff1..b1c634c93bfb203959396c5aca276354aea55d9d 100644 (file)
@@ -1,7 +1,5 @@
 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
-   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
-   2010, 2011 Free Software Foundation, Inc.
+   Copyright (C) 1986-2017 Free Software Foundation, Inc.
    Derived from coffread.c, dbxread.c, and a lot of hacking.
    Contributed by IBM Corporation.
 
 #include <sys/types.h>
 #include <fcntl.h>
 #include <ctype.h>
-#include "gdb_string.h"
-
-#include <sys/param.h>
 #ifdef HAVE_SYS_FILE_H
 #include <sys/file.h>
 #endif
-#include "gdb_stat.h"
+#include <sys/stat.h>
 
 #include "coff/internal.h"
 #include "libcoff.h"           /* FIXME, internal data from BFD */
 #include "aout/stab_gnu.h"
 
 \f
+/* Key for XCOFF-associated data.  */
+
+static const struct objfile_data *xcoff_objfile_data_key;
+
 /* We put a pointer to this structure in the read_symtab_private field
    of the psymtab.  */
 
@@ -93,7 +92,7 @@ struct coff_symbol
     char *c_name;
     int c_symnum;              /* Symbol number of this entry.  */
     int c_naux;                        /* 0 if syment only, 1 if syment + auxent.  */
-    long c_value;
+    CORE_ADDR c_value;
     unsigned char c_sclass;
     int c_secnum;
     unsigned int c_type;
@@ -120,11 +119,6 @@ static CORE_ADDR first_object_file_end;
 
 #define        INITIAL_STABVECTOR_LENGTH       40
 
-/* Nonzero if within a function (so symbols should be local,
-   if nothing says specifically).  */
-
-int within_function;
-
 /* Size of a COFF symbol.  I think it is always 18, so I'm not sure
    there is any reason not to just use a #define, but might as well
    ask BFD for the size and store it here, I guess.  */
@@ -152,6 +146,37 @@ struct coff_symfile_info
     CORE_ADDR toc_offset;
   };
 
+/* Convenience macro to access the per-objfile XCOFF data.  */
+
+#define XCOFF_DATA(objfile)                                            \
+  ((struct coff_symfile_info *) objfile_data ((objfile),               \
+                                             xcoff_objfile_data_key))
+
+/* XCOFF names for dwarf sections.  There is no compressed sections.  */
+
+static const struct dwarf2_debug_sections dwarf2_xcoff_names = {
+  { ".dwinfo", NULL },
+  { ".dwabrev", NULL },
+  { ".dwline", NULL },
+  { ".dwloc", NULL },
+  { NULL, NULL }, /* debug_loclists */
+  /* AIX XCOFF defines one, named DWARF section for macro debug information.
+     XLC does not generate debug_macinfo for DWARF4 and below.
+     The section is assigned to debug_macro for DWARF5 and above. */
+  { NULL, NULL },
+  { ".dwmac", NULL },
+  { ".dwstr", NULL },
+  { NULL, NULL }, /* debug_line_str */
+  { ".dwrnges", NULL },
+  { NULL, NULL }, /* debug_rnglists */
+  { ".dwpbtyp", NULL },
+  { NULL, NULL }, /* debug_addr */
+  { ".dwframe", NULL },
+  { NULL, NULL }, /* eh_frame */
+  { NULL, NULL }, /* gdb_index */
+  23
+};
+
 static void
 bf_notfound_complaint (void)
 {
@@ -173,11 +198,12 @@ eb_complaint (int arg1)
             _("Mismatched .eb symbol ignored starting at symnum %d"), arg1);
 }
 
-static void xcoff_initial_scan (struct objfile *, int);
+static void xcoff_initial_scan (struct objfile *, symfile_add_flags);
 
-static void scan_xcoff_symtab (struct objfile *);
+static void scan_xcoff_symtab (minimal_symbol_reader &,
+                              struct objfile *);
 
-static char *xcoff_next_symbol_text (struct objfile *);
+static const char *xcoff_next_symbol_text (struct objfile *);
 
 static void record_include_begin (struct coff_symbol *);
 
@@ -193,9 +219,6 @@ static void xcoff_new_init (struct objfile *);
 
 static void xcoff_symfile_finish (struct objfile *);
 
-static void xcoff_symfile_offsets (struct objfile *,
-                                  struct section_addr_info *addrs);
-
 static char *coff_getfilename (union internal_auxent *, struct objfile *);
 
 static void read_symbol (struct internal_syment *, int);
@@ -207,7 +230,7 @@ static CORE_ADDR read_symbol_nvalue (int);
 static struct symbol *process_xcoff_symbol (struct coff_symbol *,
                                            struct objfile *);
 
-static void read_xcoff_symtab (struct partial_symtab *);
+static void read_xcoff_symtab (struct objfile *, struct partial_symtab *);
 
 #if 0
 static void add_stab_to_list (char *, struct pending_stabs **);
@@ -251,41 +274,58 @@ find_targ_sec (bfd *abfd, asection *sect, void *obj)
       else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
        *args->resultp = SECT_OFF_DATA (objfile);
       else
-       *args->resultp = sect->index;
+       *args->resultp = gdb_bfd_section_index (abfd, sect);
       *args->bfd_sect = sect;
     }
 }
 
-/* Return the section number (SECT_OFF_*) that CS points to.  */
-static int
-secnum_to_section (int secnum, struct objfile *objfile)
-{
-  int off = SECT_OFF_TEXT (objfile);
+/* Search all BFD sections for the section whose target_index is
+   equal to N_SCNUM.  Set *BFD_SECT to that section.  The section's
+   associated index in the objfile's section_offset table is also
+   stored in *SECNUM.
+
+   If no match is found, *BFD_SECT is set to NULL, and *SECNUM
+   is set to the text section's number.  */
 
-  asection *sect = NULL;
+static void
+xcoff_secnum_to_sections (int n_scnum, struct objfile *objfile,
+                         asection **bfd_sect, int *secnum)
+{
   struct find_targ_sec_arg args;
-  args.targ_index = secnum;
-  args.resultp = &off;
-  args.bfd_sect = &sect;
+
+  args.targ_index = n_scnum;
+  args.resultp = secnum;
+  args.bfd_sect = bfd_sect;
   args.objfile = objfile;
+
+  *bfd_sect = NULL;
+  *secnum = SECT_OFF_TEXT (objfile);
+
   bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
-  return off;
 }
 
-/* Return the BFD section that CS points to.  */
+/* Return the section number (SECT_OFF_*) that N_SCNUM points to.  */
+
+static int
+secnum_to_section (int n_scnum, struct objfile *objfile)
+{
+  int secnum;
+  asection *ignored;
+
+  xcoff_secnum_to_sections (n_scnum, objfile, &ignored, &secnum);
+  return secnum;
+}
+
+/* Return the BFD section that N_SCNUM points to.  */
+
 static asection *
-secnum_to_bfd_section (int secnum, struct objfile *objfile)
+secnum_to_bfd_section (int n_scnum, struct objfile *objfile)
 {
-  int off = SECT_OFF_TEXT (objfile);
+  int ignored;
+  asection *bfd_sect;
 
-  asection *sect = NULL;
-  struct find_targ_sec_arg args;
-  args.targ_index = secnum;
-  args.resultp = &off;
-  args.bfd_sect = &sect;
-  args.objfile = objfile;
-  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
-  return sect;
+  xcoff_secnum_to_sections (n_scnum, objfile, &bfd_sect, &ignored);
+  return bfd_sect;
 }
 \f
 /* add a given stab string into given stab vector.  */
@@ -397,12 +437,12 @@ arrange_linetable (struct linetable *oldLineTb)
   struct linetable_entry *fentry;      /* function entry vector */
   int fentry_size;             /* # of function entries */
   struct linetable *newLineTb; /* new line table */
+  int extra_lines = 0;
 
 #define NUM_OF_FUNCTIONS 20
 
   fentry_size = NUM_OF_FUNCTIONS;
-  fentry = (struct linetable_entry *)
-    xmalloc (fentry_size * sizeof (struct linetable_entry));
+  fentry = XNEWVEC (struct linetable_entry, fentry_size);
 
   for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
     {
@@ -418,6 +458,12 @@ arrange_linetable (struct linetable *oldLineTb)
          fentry[function_count].line = ii;
          fentry[function_count].pc = oldLineTb->item[ii].pc;
          ++function_count;
+
+         /* If the function was compiled with XLC, we may have to add an
+             extra line entry later.  Reserve space for that.  */
+         if (ii + 1 < oldLineTb->nitems
+             && oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc)
+           extra_lines++;
        }
     }
 
@@ -434,7 +480,7 @@ arrange_linetable (struct linetable *oldLineTb)
   newLineTb = (struct linetable *)
     xmalloc
     (sizeof (struct linetable) +
-    (oldLineTb->nitems - function_count) * sizeof (struct linetable_entry));
+    (oldLineTb->nitems - function_count + extra_lines) * sizeof (struct linetable_entry));
 
   /* If line table does not start with a function beginning, copy up until
      a function begin.  */
@@ -449,13 +495,26 @@ arrange_linetable (struct linetable *oldLineTb)
 
   for (ii = 0; ii < function_count; ++ii)
     {
+      /* If the function was compiled with XLC, we may have to add an
+         extra line to cover the function prologue.  */
+      jj = fentry[ii].line;
+      if (jj + 1 < oldLineTb->nitems
+         && oldLineTb->item[jj].pc != oldLineTb->item[jj + 1].pc)
+       {
+         newLineTb->item[newline] = oldLineTb->item[jj];
+         newLineTb->item[newline].line = oldLineTb->item[jj + 1].line;
+         newline++;
+       }
+
       for (jj = fentry[ii].line + 1;
           jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
           ++jj, ++newline)
        newLineTb->item[newline] = oldLineTb->item[jj];
     }
   xfree (fentry);
-  newLineTb->nitems = oldLineTb->nitems - function_count;
+  /* The number of items in the line table must include these
+     extra lines which were added in case of XLC compiled functions.  */
+  newLineTb->nitems = oldLineTb->nitems - function_count + extra_lines;
   return newLineTb;
 }
 
@@ -531,18 +590,14 @@ allocate_include_entry (void)
 {
   if (inclTable == NULL)
     {
-      inclTable = (InclTable *)
-       xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
-      memset (inclTable,
-             '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+      inclTable = XCNEWVEC (InclTable, INITIAL_INCLUDE_TABLE_LENGTH);
       inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
       inclIndx = 0;
     }
   else if (inclIndx >= inclLength)
     {
       inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
-      inclTable = (InclTable *)
-       xrealloc (inclTable, sizeof (InclTable) * inclLength);
+      inclTable = XRESIZEVEC (InclTable, inclTable, inclLength);
       memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
              '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
     }
@@ -552,6 +607,9 @@ allocate_include_entry (void)
    in psymtab to symtab processing.  */
 static struct partial_symtab *this_symtab_psymtab;
 
+/* Objfile related to this_symtab_psymtab; set at the same time.  */
+static struct objfile *this_symtab_objfile;
+
 /* given the start and end addresses of a compilation unit (or a csect,
    at times) process its lines and create appropriate line vectors.  */
 
@@ -559,9 +617,8 @@ static void
 process_linenos (CORE_ADDR start, CORE_ADDR end)
 {
   int offset, ii;
-  file_ptr max_offset =
-    ((struct coff_symfile_info *) this_symtab_psymtab->objfile
-     ->deprecated_sym_private)->max_lineno_offset;
+  file_ptr max_offset
+    = XCOFF_DATA (this_symtab_objfile)->max_lineno_offset;
 
   /* subfile structure for the main compilation unit.  */
   struct subfile main_subfile;
@@ -594,7 +651,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end)
       /* There was source with line numbers in include files.  */
 
       int linesz =
-       coff_data (this_symtab_psymtab->objfile->obfd)->local_linesz;
+       coff_data (this_symtab_objfile->obfd)->local_linesz;
       main_source_baseline = 0;
 
       for (ii = 0; ii < inclIndx; ++ii)
@@ -609,7 +666,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end)
                 start, 0, &main_source_baseline);
            }
 
-         if (strcmp (inclTable[ii].name, last_source_file) == 0)
+         if (strcmp (inclTable[ii].name, get_last_source_file ()) == 0)
            {
               /* The entry in the include table refers to the main source
                  file.  Add the lines to the main subfile.  */
@@ -624,8 +681,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end)
            {
              /* Have a new subfile for the include file.  */
 
-             tmpSubfile = inclTable[ii].subfile =
-               (struct subfile *) xmalloc (sizeof (struct subfile));
+             tmpSubfile = inclTable[ii].subfile = XNEW (struct subfile);
 
              memset (tmpSubfile, '\0', sizeof (struct subfile));
              firstLine = &(inclTable[ii].funStartLine);
@@ -709,17 +765,17 @@ process_linenos (CORE_ADDR start, CORE_ADDR end)
             fool it.  */
 
 #if 0
-         start_subfile (inclTable[ii].name, (char *) 0);
+         start_subfile (inclTable[ii].name);
 #else
          {
            /* Pick a fake name that will produce the same results as this
               one when passed to deduce_language_from_filename.  Kludge on
               top of kludge.  */
-           char *fakename = strrchr (inclTable[ii].name, '.');
+           const char *fakename = strrchr (inclTable[ii].name, '.');
 
            if (fakename == NULL)
              fakename = " ?";
-           start_subfile (fakename, (char *) 0);
+           start_subfile (fakename);
            xfree (current_subfile->name);
          }
          current_subfile->name = xstrdup (inclTable[ii].name);
@@ -741,7 +797,7 @@ process_linenos (CORE_ADDR start, CORE_ADDR end)
 
          current_subfile->line_vector_length =
            current_subfile->line_vector->nitems;
-         start_subfile (pop_subfile (), (char *) 0);
+         start_subfile (pop_subfile ());
        }
     }
 
@@ -749,14 +805,15 @@ return_after_cleanup:
 
   /* We don't want to keep alloc/free'ing the global include file table.  */
   inclIndx = 0;
-
-  /* Start with a fresh subfile structure for the next file.  */
-  memset (&main_subfile, '\0', sizeof (struct subfile));
 }
 
 static void
-aix_process_linenos (void)
+aix_process_linenos (struct objfile *objfile)
 {
+  /* There is no linenos to read if there are only dwarf info.  */
+  if (this_symtab_psymtab == NULL)
+    return;
+
   /* Process line numbers and enter them into line vector.  */
   process_linenos (last_source_start_addr, cur_src_end_addr);
 }
@@ -778,7 +835,7 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset,
                  CORE_ADDR startaddr,  /* offsets to line table */
                  CORE_ADDR endaddr, unsigned *firstLine)
 {
-  struct objfile *objfile = this_symtab_psymtab->objfile;
+  struct objfile *objfile = this_symtab_objfile;
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   unsigned int curoffset;
   CORE_ADDR addr;
@@ -791,9 +848,7 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset,
   if (endoffset == 0 && startaddr == 0 && endaddr == 0)
     return;
   curoffset = beginoffset;
-  limit_offset =
-    ((struct coff_symfile_info *) objfile->deprecated_sym_private)
-    ->max_lineno_offset;
+  limit_offset = XCOFF_DATA (objfile)->max_lineno_offset;
 
   if (endoffset != 0)
     {
@@ -846,7 +901,7 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset,
    text address for the file, and SIZE is the number of bytes of text.  */
 
 #define complete_symtab(name, start_addr) {    \
-  last_source_file = xstrdup (name);           \
+  set_last_source_file (name);                 \
   last_source_start_addr = start_addr;         \
 }
 
@@ -857,21 +912,35 @@ enter_line_range (struct subfile *subfile, unsigned beginoffset,
    This function can read past the end of the symbol table
    (into the string table) but this does no harm.  */
 
-/* Reading symbol table has to be fast! Keep the followings as macros, rather
-   than functions.  */
-
-#define        RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, SECTION, OBJFILE) \
-{                                              \
-  char *namestr;                               \
-                                               \
-  namestr = (NAME);                            \
-  if (namestr[0] == '.') ++namestr;            \
-  prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE),     \
-                                      (SECTION), (asection *)NULL, \
-                                      (OBJFILE));                  \
-  misc_func_recorded = 1;                      \
-}
+/* Create a new minimal symbol (using record_with_info).
+
+   Creation of all new minimal symbols should go through this function
+   rather than calling the various record functions in order
+   to make sure that all symbol addresses get properly relocated.
+
+   Arguments are:
 
+   NAME - the symbol's name (but if NAME starts with a period, that
+   leading period is discarded).
+   ADDRESS - the symbol's address, prior to relocation.  This function
+      relocates the address before recording the minimal symbol.
+   MS_TYPE - the symbol's type.
+   N_SCNUM - the symbol's XCOFF section number.
+   OBJFILE - the objfile associated with the minimal symbol.  */
+
+static void
+record_minimal_symbol (minimal_symbol_reader &reader,
+                      const char *name, CORE_ADDR address,
+                      enum minimal_symbol_type ms_type,
+                      int n_scnum,
+                      struct objfile *objfile)
+{
+  if (name[0] == '.')
+    ++name;
+
+  reader.record_with_info (name, address, ms_type,
+                          secnum_to_section (n_scnum, objfile));
+}
 
 /* xcoff has static blocks marked in `.bs', `.es' pairs.  They cannot be
    nested.  At any given time, a symbol can only be in one static block.
@@ -894,15 +963,15 @@ static char *raw_symbol;
 /* This is the function which stabsread.c calls to get symbol
    continuations.  */
 
-static char *
+static const char *
 xcoff_next_symbol_text (struct objfile *objfile)
 {
   struct internal_syment symbol;
-  char *retval;
+  const char *retval;
 
   /* FIXME: is this the same as the passed arg?  */
-  if (this_symtab_psymtab)
-    objfile = this_symtab_psymtab->objfile;
+  if (this_symtab_objfile)
+    objfile = this_symtab_objfile;
 
   bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
   if (symbol.n_zeroes)
@@ -915,9 +984,7 @@ xcoff_next_symbol_text (struct objfile *objfile)
     }
   else if (symbol.n_sclass & 0x80)
     {
-      retval = ((struct coff_symfile_info *)
-               objfile->deprecated_sym_private)->debugsec
-       + symbol.n_offset;
+      retval = XCOFF_DATA (objfile)->debugsec + symbol.n_offset;
       raw_symbol += coff_data (objfile->obfd)->local_symesz;
       ++symnum;
     }
@@ -935,15 +1002,13 @@ xcoff_next_symbol_text (struct objfile *objfile)
 /* Read symbols for a given partial symbol table.  */
 
 static void
-read_xcoff_symtab (struct partial_symtab *pst)
+read_xcoff_symtab (struct objfile *objfile, struct partial_symtab *pst)
 {
-  struct objfile *objfile = pst->objfile;
   bfd *abfd = objfile->obfd;
   char *raw_auxptr;            /* Pointer to first raw aux entry for sym.  */
-  char *strtbl = 
-    ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl;
-  char *debugsec =
-    ((struct coff_symfile_info *) objfile->deprecated_sym_private)->debugsec;
+  struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
+  char *strtbl = xcoff->strtbl;
+  char *debugsec = xcoff->debugsec;
   const char *debugfmt = bfd_xcoff_is_xcoff64 (abfd) ? "XCOFF64" : "XCOFF";
 
   struct internal_syment symbol[1];
@@ -956,41 +1021,38 @@ read_xcoff_symtab (struct partial_symtab *pst)
   unsigned int max_symnum;
   int just_started = 1;
   int depth = 0;
-  int fcn_start_addr = 0;
+  CORE_ADDR fcn_start_addr = 0;
 
   struct coff_symbol fcn_stab_saved = { 0 };
 
   /* fcn_cs_saved is global because process_xcoff_symbol needs it.  */
-  union internal_auxent fcn_aux_saved;
-  struct context_stack *new;
+  union internal_auxent fcn_aux_saved = main_aux;
+  struct context_stack *newobj;
 
-  char *filestring = " _start_ ";      /* Name of the current file.  */
+  const char *filestring = pst->filename;      /* Name of the current file.  */
 
-  char *last_csect_name;       /* Last seen csect's name and value.  */
-  CORE_ADDR last_csect_val;
-  int last_csect_sec;
+  const char *last_csect_name; /* Last seen csect's name.  */
 
   this_symtab_psymtab = pst;
+  this_symtab_objfile = objfile;
 
   /* Get the appropriate COFF "constants" related to the file we're
      handling.  */
   local_symesz = coff_data (abfd)->local_symesz;
 
-  last_source_file = NULL;
+  set_last_source_file (NULL);
   last_csect_name = 0;
-  last_csect_val = 0;
 
   start_stabs ();
-  start_symtab (filestring, (char *) NULL, file_start_addr);
+  start_symtab (objfile, filestring, (char *) NULL, file_start_addr,
+               language_unknown);
   record_debugformat (debugfmt);
   symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
   max_symnum =
     symnum + ((struct symloc *) pst->read_symtab_private)->numsyms;
   first_object_file_end = 0;
 
-  raw_symbol =
-    ((struct coff_symfile_info *) objfile->deprecated_sym_private)->symtbl
-    + symnum * local_symesz;
+  raw_symbol = xcoff->symtbl + symnum * local_symesz;
 
   while (symnum < max_symnum)
     {
@@ -1023,7 +1085,8 @@ read_xcoff_symtab (struct partial_symtab *pst)
              {
                char *p;
 
-               p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
+               p = (char *) obstack_alloc (&objfile->objfile_obstack,
+                                           E_SYMNMLEN + 1);
                strncpy (p, cs->c_name, E_SYMNMLEN);
                p[E_SYMNMLEN] = '\0';
                cs->c_name = p;
@@ -1067,22 +1130,23 @@ read_xcoff_symtab (struct partial_symtab *pst)
 
       if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
        {
-         if (last_source_file)
+         if (get_last_source_file ())
            {
-             pst->symtab = end_symtab (cur_src_end_addr, objfile,
-                                       SECT_OFF_TEXT (objfile));
+             pst->compunit_symtab = end_symtab (cur_src_end_addr,
+                                                SECT_OFF_TEXT (objfile));
              end_stabs ();
            }
 
          start_stabs ();
-         start_symtab ("_globals_", (char *) NULL, (CORE_ADDR) 0);
+         start_symtab (objfile, "_globals_", (char *) NULL, (CORE_ADDR) 0,
+                       language_unknown);
          record_debugformat (debugfmt);
          cur_src_end_addr = first_object_file_end;
          /* Done with all files, everything from here on is globals.  */
        }
 
-      if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
-         && cs->c_naux == 1)
+      if (cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT ||
+         cs->c_sclass == C_WEAKEXT)
        {
          /* Dealing with a symbol with a csect entry.  */
 
@@ -1092,9 +1156,41 @@ read_xcoff_symtab (struct partial_symtab *pst)
 #define        CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
 #define        CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
 
-         /* Convert the auxent to something we can access.  */
-         bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
-                               0, cs->c_naux, &main_aux);
+         /* Convert the auxent to something we can access.
+            XCOFF can have more than one auxiliary entries.
+
+            Actual functions will have two auxiliary entries, one to have the
+            function size and other to have the smtype/smclass (LD/PR).
+
+            c_type value of main symbol table will be set only in case of
+            C_EXT/C_HIDEEXT/C_WEAKEXT storage class symbols.
+            Bit 10 of type is set if symbol is a function, ie the value is set
+            to 32(0x20). So we need to read the first function auxiliay entry
+            which contains the size. */
+         if (cs->c_naux > 1 && ISFCN (cs->c_type))
+         {
+           /* a function entry point.  */
+
+           fcn_start_addr = cs->c_value;
+
+           /* save the function header info, which will be used
+              when `.bf' is seen.  */
+           fcn_cs_saved = *cs;
+
+           /* Convert the auxent to something we can access.  */
+           bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+                                 0, cs->c_naux, &fcn_aux_saved);
+           continue;
+         }
+         /* Read the csect auxiliary header, which is always the last by
+            onvention. */
+         bfd_coff_swap_aux_in (abfd,
+                              raw_auxptr
+                              + ((coff_data (abfd)->local_symesz)
+                              * (cs->c_naux - 1)),
+                              cs->c_type, cs->c_sclass,
+                              cs->c_naux - 1, cs->c_naux,
+                              &main_aux);
 
          switch (CSECT_SMTYP (&main_aux))
            {
@@ -1127,13 +1223,13 @@ read_xcoff_symtab (struct partial_symtab *pst)
                        {
                          complete_symtab (filestring, file_start_addr);
                          cur_src_end_addr = file_end_addr;
-                         end_symtab (file_end_addr, objfile,
-                                     SECT_OFF_TEXT (objfile));
+                         end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
                          end_stabs ();
                          start_stabs ();
                          /* Give all csects for this source file the same
                             name.  */
-                         start_symtab (filestring, NULL, (CORE_ADDR) 0);
+                         start_symtab (objfile, filestring, NULL,
+                                       (CORE_ADDR) 0, language_unknown);
                          record_debugformat (debugfmt);
                        }
 
@@ -1151,14 +1247,8 @@ read_xcoff_symtab (struct partial_symtab *pst)
                                                SECT_OFF_TEXT (objfile));
                      file_end_addr = file_start_addr + CSECT_LEN (&main_aux);
 
-                     if (cs->c_name && (cs->c_name[0] == '.'
-                                        || cs->c_name[0] == '@'))
-                       {
-                         last_csect_name = cs->c_name;
-                         last_csect_val = cs->c_value;
-                         last_csect_sec = secnum_to_section (cs->c_secnum,
-                                                             objfile);
-                       }
+                     if (cs->c_name && (cs->c_name[0] == '.' || cs->c_name[0] == '@'))
+                       last_csect_name = cs->c_name;
                    }
                    continue;
 
@@ -1185,16 +1275,11 @@ read_xcoff_symtab (struct partial_symtab *pst)
 
              switch (CSECT_SCLAS (&main_aux))
                {
+               /* We never really come to this part as this case has been
+                  handled in ISFCN check above.
+                  This and other cases of XTY_LD are kept just for
+                  reference. */
                case XMC_PR:
-                 /* a function entry point.  */
-               function_entry_point:
-
-                 fcn_start_addr = cs->c_value;
-
-                 /* save the function header info, which will be used
-                    when `.bf' is seen.  */
-                 fcn_cs_saved = *cs;
-                 fcn_aux_saved = main_aux;
                  continue;
 
                case XMC_GL:
@@ -1227,16 +1312,6 @@ read_xcoff_symtab (struct partial_symtab *pst)
            }
        }
 
-      /* If explicitly specified as a function, treat is as one.  This check
-        evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur
-        after the above CSECT check.  */
-      if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
-       {
-         bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
-                               0, cs->c_naux, &main_aux);
-         goto function_entry_point;
-       }
-
       switch (cs->c_sclass)
        {
        case C_FILE:
@@ -1255,7 +1330,7 @@ read_xcoff_symtab (struct partial_symtab *pst)
 
          complete_symtab (filestring, file_start_addr);
          cur_src_end_addr = file_end_addr;
-         end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile));
+         end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
          end_stabs ();
 
          /* XCOFF, according to the AIX 3.2 documentation, puts the
@@ -1274,7 +1349,8 @@ read_xcoff_symtab (struct partial_symtab *pst)
            filestring = cs->c_name;
 
          start_stabs ();
-         start_symtab (filestring, (char *) NULL, (CORE_ADDR) 0);
+         start_symtab (objfile, filestring, (char *) NULL, (CORE_ADDR) 0,
+                       language_unknown);
          record_debugformat (debugfmt);
          last_csect_name = 0;
 
@@ -1299,13 +1375,13 @@ read_xcoff_symtab (struct partial_symtab *pst)
 
              within_function = 1;
 
-             new = push_context (0, fcn_start_addr + off);
+             newobj = push_context (0, fcn_start_addr + off);
 
-             new->name = define_symbol
+             newobj->name = define_symbol
                (fcn_cs_saved.c_value + off,
                 fcn_stab_saved.c_name, 0, 0, objfile);
-             if (new->name != NULL)
-               SYMBOL_SECTION (new->name) = SECT_OFF_TEXT (objfile);
+             if (newobj->name != NULL)
+               SYMBOL_SECTION (newobj->name) = SECT_OFF_TEXT (objfile);
            }
          else if (strcmp (cs->c_name, ".ef") == 0)
            {
@@ -1323,22 +1399,21 @@ read_xcoff_symtab (struct partial_symtab *pst)
                  within_function = 0;
                  break;
                }
-             new = pop_context ();
+             newobj = pop_context ();
              /* Stack must be empty now.  */
-             if (context_stack_depth > 0 || new == NULL)
+             if (context_stack_depth > 0 || newobj == NULL)
                {
                  ef_complaint (cs->c_symnum);
                  within_function = 0;
                  break;
                }
 
-             finish_block (new->name, &local_symbols, new->old_blocks,
-                           new->start_addr,
+             finish_block (newobj->name, &local_symbols, newobj->old_blocks,
+                           NULL, newobj->start_addr,
                            (fcn_cs_saved.c_value
                             + fcn_aux_saved.x_sym.x_misc.x_fsize
                             + ANOFFSET (objfile->section_offsets,
-                                        SECT_OFF_TEXT (objfile))),
-                           objfile);
+                                        SECT_OFF_TEXT (objfile))));
              within_function = 0;
            }
          break;
@@ -1404,7 +1479,7 @@ read_xcoff_symtab (struct partial_symtab *pst)
          if (strcmp (cs->c_name, ".bb") == 0)
            {
              depth++;
-             new = push_context (depth,
+             newobj = push_context (depth,
                                  (cs->c_value
                                   + ANOFFSET (objfile->section_offsets,
                                               SECT_OFF_TEXT (objfile))));
@@ -1416,8 +1491,8 @@ read_xcoff_symtab (struct partial_symtab *pst)
                  eb_complaint (cs->c_symnum);
                  break;
                }
-             new = pop_context ();
-             if (depth-- != new->depth)
+             newobj = pop_context ();
+             if (depth-- != newobj->depth)
                {
                  eb_complaint (cs->c_symnum);
                  break;
@@ -1425,14 +1500,14 @@ read_xcoff_symtab (struct partial_symtab *pst)
              if (local_symbols && context_stack_depth > 0)
                {
                  /* Make a block for the local symbols within.  */
-                 finish_block (new->name, &local_symbols, new->old_blocks,
-                               new->start_addr,
+                 finish_block (newobj->name, &local_symbols,
+                               newobj->old_blocks, NULL,
+                               newobj->start_addr,
                                (cs->c_value
                                 + ANOFFSET (objfile->section_offsets,
-                                            SECT_OFF_TEXT (objfile))),
-                               objfile);
+                                            SECT_OFF_TEXT (objfile))));
                }
-             local_symbols = new->locals;
+             local_symbols = newobj->locals;
            }
          break;
 
@@ -1442,32 +1517,31 @@ read_xcoff_symtab (struct partial_symtab *pst)
        }
     }
 
-  if (last_source_file)
+  if (get_last_source_file ())
     {
-      struct symtab *s;
+      struct compunit_symtab *cust;
 
       complete_symtab (filestring, file_start_addr);
       cur_src_end_addr = file_end_addr;
-      s = end_symtab (file_end_addr, objfile, SECT_OFF_TEXT (objfile));
+      cust = end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
       /* When reading symbols for the last C_FILE of the objfile, try
-         to make sure that we set pst->symtab to the symtab for the
+         to make sure that we set pst->compunit_symtab to the symtab for the
          file, not to the _globals_ symtab.  I'm not sure whether this
          actually works right or when/if it comes up.  */
-      if (pst->symtab == NULL)
-       pst->symtab = s;
+      if (pst->compunit_symtab == NULL)
+       pst->compunit_symtab = cust;
       end_stabs ();
     }
 }
 
 #define        SYMBOL_DUP(SYMBOL1, SYMBOL2)    \
-  (SYMBOL2) = (struct symbol *)                \
-       obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \
+  (SYMBOL2) = XOBNEW (&objfile->objfile_obstack, struct symbol); \
   *(SYMBOL2) = *(SYMBOL1);
 
 
 #define        SYMNAME_ALLOC(NAME, ALLOCED)    \
-  ((ALLOCED) ? (NAME) : obsavestring ((NAME), strlen (NAME), \
-                                     &objfile->objfile_obstack))
+  ((ALLOCED) ? (NAME) : obstack_copy0 (&objfile->objfile_obstack, \
+                                      (NAME), strlen (NAME)))
 
 
 /* process one xcoff symbol.  */
@@ -1500,7 +1574,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
   if (name[0] == '.')
     ++name;
 
-  memset (sym, '\0', sizeof (struct symbol));
+  initialize_objfile_symbol (sym);
 
   /* default assumptions */
   SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off;
@@ -1513,13 +1587,14 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
          will be patched with the type from its stab entry later on in
          patch_block_stabs (), unless the file was compiled without -g.  */
 
-      SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced));
+      SYMBOL_SET_LINKAGE_NAME (sym, ((const char *)
+                                    SYMNAME_ALLOC (name, symname_alloced)));
       SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
 
-      SYMBOL_CLASS (sym) = LOC_BLOCK;
+      SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
       SYMBOL_DUP (sym, sym2);
 
-      if (cs->c_sclass == C_EXT)
+      if (cs->c_sclass == C_EXT || C_WEAKEXT)
        add_symbol_to_list (sym2, &global_symbols);
       else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
        add_symbol_to_list (sym2, &file_symbols);
@@ -1588,7 +1663,7 @@ process_xcoff_symbol (struct coff_symbol *cs, struct objfile *objfile)
          if (*name == ':')
            return NULL;
 
-         pp = (char *) strchr (name, ':');
+         pp = strchr (name, ':');
          if (pp == NULL)
            return NULL;
 
@@ -1620,9 +1695,8 @@ coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile)
   static char buffer[BUFSIZ];
 
   if (aux_entry->x_file.x_n.x_zeroes == 0)
-    strcpy (buffer, ((struct coff_symfile_info *)
-                    objfile->deprecated_sym_private)->strtbl
-           + aux_entry->x_file.x_n.x_offset);
+    strcpy (buffer, (XCOFF_DATA (objfile)->strtbl
+                    + aux_entry->x_file.x_n.x_offset));
   else
     {
       strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
@@ -1635,11 +1709,9 @@ coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile)
 static void
 read_symbol (struct internal_syment *symbol, int symno)
 {
-  int nsyms
-    = ((struct coff_symfile_info *)
-       this_symtab_psymtab->objfile->deprecated_sym_private)->symtbl_num_syms;
-  char *stbl = ((struct coff_symfile_info *)
-               this_symtab_psymtab->objfile->deprecated_sym_private)->symtbl;
+  struct coff_symfile_info *xcoff = XCOFF_DATA (this_symtab_objfile);
+  int nsyms = xcoff->symtbl_num_syms;
+  char *stbl = xcoff->symtbl;
 
   if (symno < 0 || symno >= nsyms)
     {
@@ -1648,7 +1720,7 @@ read_symbol (struct internal_syment *symbol, int symno)
       symbol->n_scnum = -1;
       return;
     }
-  bfd_coff_swap_sym_in (this_symtab_psymtab->objfile->obfd,
+  bfd_coff_swap_sym_in (this_symtab_objfile->obfd,
                        stbl + (symno * local_symesz),
                        symbol);
 }
@@ -1671,11 +1743,10 @@ read_symbol_nvalue (int symno)
 static int
 read_symbol_lineno (int symno)
 {
-  struct objfile *objfile = this_symtab_psymtab->objfile;
+  struct objfile *objfile = this_symtab_objfile;
   int xcoff64 = bfd_xcoff_is_xcoff64 (objfile->obfd);
 
-  struct coff_symfile_info *info =
-    (struct coff_symfile_info *)objfile->deprecated_sym_private;
+  struct coff_symfile_info *info = XCOFF_DATA (objfile);
   int nsyms = info->symtbl_num_syms;
   char *stbl = info->symtbl;
   char *strtbl = info->strtbl;
@@ -1762,12 +1833,9 @@ find_linenos (struct bfd *abfd, struct bfd_section *asect, void *vpinfo)
     info->max_lineno_offset = maxoff;
 }
 \f
-static void xcoff_psymtab_to_symtab_1 (struct partial_symtab *);
-
 static void
-xcoff_psymtab_to_symtab_1 (struct partial_symtab *pst)
+xcoff_psymtab_to_symtab_1 (struct objfile *objfile, struct partial_symtab *pst)
 {
-  struct cleanup *old_chain;
   int i;
 
   if (!pst)
@@ -1796,7 +1864,7 @@ xcoff_psymtab_to_symtab_1 (struct partial_symtab *pst)
            wrap_here ("");     /* Flush output */
            gdb_flush (gdb_stdout);
          }
-       xcoff_psymtab_to_symtab_1 (pst->dependencies[i]);
+       xcoff_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
       }
 
   if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
@@ -1804,57 +1872,46 @@ xcoff_psymtab_to_symtab_1 (struct partial_symtab *pst)
       /* Init stuff necessary for reading in symbols.  */
       stabsread_init ();
       buildsym_init ();
-      old_chain = make_cleanup (really_free_pendings, 0);
-
-      read_xcoff_symtab (pst);
 
-      do_cleanups (old_chain);
+      scoped_free_pendings free_pending;
+      read_xcoff_symtab (objfile, pst);
     }
 
   pst->readin = 1;
 }
 
-static void xcoff_psymtab_to_symtab (struct partial_symtab *);
-
 /* Read in all of the symbols for a given psymtab for real.
-   Be verbose about it if the user wants that.  */
+   Be verbose about it if the user wants that.  SELF is not NULL.  */
 
 static void
-xcoff_psymtab_to_symtab (struct partial_symtab *pst)
+xcoff_read_symtab (struct partial_symtab *self, struct objfile *objfile)
 {
-  bfd *sym_bfd;
-
-  if (!pst)
-    return;
-
-  if (pst->readin)
+  if (self->readin)
     {
       fprintf_unfiltered
        (gdb_stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
-        pst->filename);
+        self->filename);
       return;
     }
 
-  if (((struct symloc *) pst->read_symtab_private)->numsyms != 0
-      || pst->number_of_dependencies)
+  if (((struct symloc *) self->read_symtab_private)->numsyms != 0
+      || self->number_of_dependencies)
     {
       /* Print the message now, before reading the string table,
          to avoid disconcerting pauses.  */
       if (info_verbose)
        {
-         printf_filtered ("Reading in symbols for %s...", pst->filename);
+         printf_filtered ("Reading in symbols for %s...", self->filename);
          gdb_flush (gdb_stdout);
        }
 
-      sym_bfd = pst->objfile->obfd;
-
       next_symbol_text_func = xcoff_next_symbol_text;
 
-      xcoff_psymtab_to_symtab_1 (pst);
+      xcoff_psymtab_to_symtab_1 (objfile, self);
 
       /* Match with global symbols.  This only needs to be done once,
          after all of the symtabs and dependencies have been read in.   */
-      scan_file_globals (pst->objfile);
+      scan_file_globals (objfile);
 
       /* Finish up the debug error message.  */
       if (info_verbose)
@@ -1878,16 +1935,16 @@ xcoff_new_init (struct objfile *objfile)
 static void
 xcoff_symfile_init (struct objfile *objfile)
 {
+  struct coff_symfile_info *xcoff;
+
   /* Allocate struct to keep track of the symfile.  */
-  objfile->deprecated_sym_private
-    = xmalloc (sizeof (struct coff_symfile_info));
+  xcoff = XNEW (struct coff_symfile_info);
+  set_objfile_data (objfile, xcoff_objfile_data_key, xcoff);
 
   /* XCOFF objects may be reordered, so set OBJF_REORDERED.  If we
      find this causes a significant slowdown in gdb then we could
      set it in the debug symbol readers only when necessary.  */
   objfile->flags |= OBJF_REORDERED;
-
-  init_entry_point_info (objfile);
 }
 
 /* Perform any local cleanups required when we are done with a particular
@@ -1898,11 +1955,6 @@ xcoff_symfile_init (struct objfile *objfile)
 static void
 xcoff_symfile_finish (struct objfile *objfile)
 {
-  if (objfile->deprecated_sym_private != NULL)
-    {
-      xfree (objfile->deprecated_sym_private);
-    }
-
   /* Start with a fresh include table for the next objfile.  */
   if (inclTable)
     {
@@ -1910,6 +1962,8 @@ xcoff_symfile_finish (struct objfile *objfile)
       inclTable = NULL;
     }
   inclIndx = inclLength = inclDepth = 0;
+
+  dwarf2_free_objfile (objfile);
 }
 
 
@@ -1920,9 +1974,9 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile)
   int val;
   unsigned char lengthbuf[4];
   char *strtbl;
+  struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
 
-  ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl
-    = NULL;
+  xcoff->strtbl = NULL;
 
   if (bfd_seek (abfd, offset, SEEK_SET) < 0)
     error (_("cannot seek to string table in %s: %s"),
@@ -1941,8 +1995,7 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile)
      as long as we have its symbol table around.  */
 
   strtbl = (char *) obstack_alloc (&objfile->objfile_obstack, length);
-  ((struct coff_symfile_info *) objfile->deprecated_sym_private)->strtbl
-    = strtbl;
+  xcoff->strtbl = strtbl;
 
   /* Copy length buffer, the first byte is usually zero and is
      used for stabs with a name length of zero.  */
@@ -1967,10 +2020,6 @@ init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile)
    for the psymtab.  */
 static unsigned int first_fun_line_offset;
 
-static struct partial_symtab *xcoff_start_psymtab
-  (struct objfile *, char *, int,
-   struct partial_symbol **, struct partial_symbol **);
-
 /* Allocate and partially fill a partial symtab.  It will be
    completely filled at the end of the symbol list.
 
@@ -1979,21 +2028,22 @@ static struct partial_symtab *xcoff_start_psymtab
    (normal).  */
 
 static struct partial_symtab *
-xcoff_start_psymtab (struct objfile *objfile, char *filename, int first_symnum,
-                    struct partial_symbol **global_syms,
-                    struct partial_symbol **static_syms)
+xcoff_start_psymtab (struct objfile *objfile,
+                    const char *filename, int first_symnum,
+                    std::vector<partial_symbol *> &global_psymbols,
+                    std::vector<partial_symbol *> &static_psymbols)
 {
   struct partial_symtab *result =
-    start_psymtab_common (objfile, objfile->section_offsets,
+    start_psymtab_common (objfile,
                          filename,
                          /* We fill in textlow later.  */
                          0,
-                         global_syms, static_syms);
+                         global_psymbols, static_psymbols);
 
-  result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
-                                              sizeof (struct symloc));
+  result->read_symtab_private =
+    XOBNEW (&objfile->objfile_obstack, struct symloc);
   ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
-  result->read_symtab = xcoff_psymtab_to_symtab;
+  result->read_symtab = xcoff_read_symtab;
 
   /* Deduce the source language from the filename for this psymtab.  */
   psymtab_language = deduce_language_from_filename (filename);
@@ -2001,10 +2051,6 @@ xcoff_start_psymtab (struct objfile *objfile, char *filename, int first_symnum,
   return result;
 }
 
-static struct partial_symtab *xcoff_end_psymtab
-  (struct partial_symtab *, char **, int, int,
-   struct partial_symtab **, int, int);
-
 /* Close off the current usage of PST.
    Returns PST, or NULL if the partial symtab was empty and thrown away.
 
@@ -2014,13 +2060,13 @@ static struct partial_symtab *xcoff_end_psymtab
    are the information for includes and dependencies.  */
 
 static struct partial_symtab *
-xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
-                  int num_includes, int capping_symbol_number,
+xcoff_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
+                  const char **include_list, int num_includes,
+                  int capping_symbol_number,
                   struct partial_symtab **dependency_list,
                   int number_dependencies, int textlow_not_set)
 {
   int i;
-  struct objfile *objfile = pst->objfile;
 
   if (capping_symbol_number != -1)
     ((struct symloc *) pst->read_symtab_private)->numsyms =
@@ -2029,17 +2075,15 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
   ((struct symloc *) pst->read_symtab_private)->lineno_off =
     first_fun_line_offset;
   first_fun_line_offset = 0;
-  pst->n_global_syms = objfile->global_psymbols.next
-    - (objfile->global_psymbols.list + pst->globals_offset);
-  pst->n_static_syms = objfile->static_psymbols.next
-    - (objfile->static_psymbols.list + pst->statics_offset);
+
+  end_psymtab_common (objfile, pst);
 
   pst->number_of_dependencies = number_dependencies;
   if (number_dependencies)
     {
-      pst->dependencies = (struct partial_symtab **)
-       obstack_alloc (&objfile->objfile_obstack,
-                   number_dependencies * sizeof (struct partial_symtab *));
+      pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
+                                    struct partial_symtab *,
+                                    number_dependencies);
       memcpy (pst->dependencies, dependency_list,
              number_dependencies * sizeof (struct partial_symtab *));
     }
@@ -2051,7 +2095,6 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
       struct partial_symtab *subpst =
        allocate_psymtab (include_list[i], objfile);
 
-      subpst->section_offsets = pst->section_offsets;
       subpst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
                                                   sizeof (struct symloc));
       ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
@@ -2061,9 +2104,8 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
 
       /* We could save slight bits of space by only making one of these,
          shared by the entire set of include files.  FIXME-someday.  */
-      subpst->dependencies = (struct partial_symtab **)
-       obstack_alloc (&objfile->objfile_obstack,
-                      sizeof (struct partial_symtab *));
+      subpst->dependencies =
+         XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
       subpst->dependencies[0] = pst;
       subpst->number_of_dependencies = 1;
 
@@ -2073,12 +2115,10 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
        subpst->n_static_syms = 0;
 
       subpst->readin = 0;
-      subpst->symtab = 0;
+      subpst->compunit_symtab = NULL;
       subpst->read_symtab = pst->read_symtab;
     }
 
-  sort_pst_symbols (pst);
-
   if (num_includes == 0
       && number_dependencies == 0
       && pst->n_global_syms == 0
@@ -2089,25 +2129,21 @@ xcoff_end_psymtab (struct partial_symtab *pst, char **include_list,
       /* Empty psymtabs happen as a result of header files which don't have
          any symbols in them.  There can be a lot of them.  */
 
-      discard_psymtab (pst);
+      discard_psymtab (objfile, pst);
 
       /* Indicate that psymtab was thrown away.  */
-      pst = (struct partial_symtab *) NULL;
+      pst = NULL;
     }
   return pst;
 }
 
-static void swap_sym (struct internal_syment *,
-                     union internal_auxent *, char **, char **,
-                     unsigned int *, struct objfile *);
-
 /* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
    *SYMBOL, the first auxent in *AUX.  Advance *RAW and *SYMNUMP over
    the symbol and its auxents.  */
 
 static void
 swap_sym (struct internal_syment *symbol, union internal_auxent *aux,
-         char **name, char **raw, unsigned int *symnump,
+         const char **name, char **raw, unsigned int *symnump,
          struct objfile *objfile)
 {
   bfd_coff_swap_sym_in (objfile->obfd, *raw, symbol);
@@ -2121,7 +2157,8 @@ swap_sym (struct internal_syment *symbol, union internal_auxent *aux,
             into the minimal symbols.  */
          char *p;
 
-         p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
+         p = (char *) obstack_alloc (&objfile->objfile_obstack,
+                                     E_SYMNMLEN + 1);
          strncpy (p, symbol->n_name, E_SYMNMLEN);
          p[E_SYMNMLEN] = '\0';
          *name = p;
@@ -2133,13 +2170,11 @@ swap_sym (struct internal_syment *symbol, union internal_auxent *aux,
     }
   else if (symbol->n_sclass & 0x80)
     {
-      *name = ((struct coff_symfile_info *)
-              objfile->deprecated_sym_private)->debugsec + symbol->n_offset;
+      *name = XCOFF_DATA (objfile)->debugsec + symbol->n_offset;
     }
   else
     {
-      *name = ((struct coff_symfile_info *)
-              objfile->deprecated_sym_private)->strtbl + symbol->n_offset;
+      *name = XCOFF_DATA (objfile)->strtbl + symbol->n_offset;
     }
   ++*symnump;
   *raw += coff_data (objfile->obfd)->local_symesz;
@@ -2163,14 +2198,14 @@ function_outside_compilation_unit_complaint (const char *arg1)
 }
 
 static void
-scan_xcoff_symtab (struct objfile *objfile)
+scan_xcoff_symtab (minimal_symbol_reader &reader,
+                  struct objfile *objfile)
 {
   struct gdbarch *gdbarch = get_objfile_arch (objfile);
   CORE_ADDR toc_offset = 0;    /* toc offset value in data section.  */
-  char *filestring = NULL;
+  const char *filestring = NULL;
 
-  char *namestring;
-  int past_first_source_file = 0;
+  const char *namestring;
   bfd *abfd;
   asection *bfd_sect;
   unsigned int nsyms;
@@ -2179,7 +2214,7 @@ scan_xcoff_symtab (struct objfile *objfile)
   struct partial_symtab *pst;
 
   /* List of current psymtab's include files.  */
-  char **psymtab_include_list;
+  const char **psymtab_include_list;
   int includes_allocated;
   int includes_used;
 
@@ -2192,7 +2227,7 @@ scan_xcoff_symtab (struct objfile *objfile)
   union internal_auxent main_aux[5];
   unsigned int ssymnum;
 
-  char *last_csect_name = NULL;        /* Last seen csect's name and value.  */
+  const char *last_csect_name = NULL; /* Last seen csect's name and value.  */
   CORE_ADDR last_csect_val = 0;
   int last_csect_sec = 0;
   int misc_func_recorded = 0;  /* true if any misc. function.  */
@@ -2202,8 +2237,8 @@ scan_xcoff_symtab (struct objfile *objfile)
 
   includes_allocated = 30;
   includes_used = 0;
-  psymtab_include_list = (char **) alloca (includes_allocated *
-                                          sizeof (char *));
+  psymtab_include_list = (const char **) alloca (includes_allocated *
+                                                sizeof (const char *));
 
   dependencies_allocated = 30;
   dependencies_used = 0;
@@ -2211,15 +2246,13 @@ scan_xcoff_symtab (struct objfile *objfile)
     (struct partial_symtab **) alloca (dependencies_allocated *
                                       sizeof (struct partial_symtab *));
 
-  last_source_file = NULL;
+  set_last_source_file (NULL);
 
   abfd = objfile->obfd;
   next_symbol_text_func = xcoff_next_symbol_text;
 
-  sraw_symbol = ((struct coff_symfile_info *)
-                objfile->deprecated_sym_private)->symtbl;
-  nsyms = ((struct coff_symfile_info *)
-          objfile->deprecated_sym_private)->symtbl_num_syms;
+  sraw_symbol = XCOFF_DATA (objfile)->symtbl;
+  nsyms = XCOFF_DATA (objfile)->symtbl_num_syms;
   ssymnum = 0;
   while (ssymnum < nsyms)
     {
@@ -2234,6 +2267,7 @@ scan_xcoff_symtab (struct objfile *objfile)
        {
        case C_EXT:
        case C_HIDEXT:
+       case C_WEAKEXT:
          {
            /* The CSECT auxent--always the last auxent.  */
            union internal_auxent csect_aux;
@@ -2275,10 +2309,10 @@ scan_xcoff_symtab (struct objfile *objfile)
 
                        if (!misc_func_recorded)
                          {
-                           RECORD_MINIMAL_SYMBOL
-                             (last_csect_name, last_csect_val,
-                              mst_text, last_csect_sec,
-                              objfile);
+                           record_minimal_symbol
+                             (reader, last_csect_name, last_csect_val,
+                              mst_text, last_csect_sec, objfile);
+                           misc_func_recorded = 1;
                          }
 
                        if (pst != NULL)
@@ -2287,8 +2321,8 @@ scan_xcoff_symtab (struct objfile *objfile)
                               each program csect, because their text
                               sections need not be adjacent.  */
                            xcoff_end_psymtab
-                             (pst, psymtab_include_list, includes_used,
-                              symnum_before, dependency_list,
+                             (objfile, pst, psymtab_include_list,
+                              includes_used, symnum_before, dependency_list,
                               dependencies_used, textlow_not_set);
                            includes_used = 0;
                            dependencies_used = 0;
@@ -2298,8 +2332,8 @@ scan_xcoff_symtab (struct objfile *objfile)
                              (objfile,
                               filestring,
                               symnum_before,
-                              objfile->global_psymbols.next,
-                              objfile->static_psymbols.next);
+                              objfile->global_psymbols,
+                              objfile->static_psymbols);
                          }
                      }
                    /* Activate the misc_func_recorded mechanism for
@@ -2310,8 +2344,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                      {
                        last_csect_name = namestring;
                        last_csect_val = symbol.n_value;
-                       last_csect_sec =
-                         secnum_to_section (symbol.n_scnum, objfile);
+                       last_csect_sec = symbol.n_scnum;
                      }
                    if (pst != NULL)
                      {
@@ -2331,11 +2364,10 @@ scan_xcoff_symtab (struct objfile *objfile)
                    /* Data variables are recorded in the minimal symbol
                       table, except for section symbols.  */
                    if (*namestring != '.')
-                     prim_record_minimal_symbol_and_info
-                       (namestring, symbol.n_value,
+                     record_minimal_symbol
+                       (reader, namestring, symbol.n_value,
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
-                        secnum_to_section (symbol.n_scnum, objfile),
-                        NULL, objfile);
+                        symbol.n_scnum, objfile);
                    break;
 
                  case XMC_TC0:
@@ -2369,11 +2401,12 @@ scan_xcoff_symtab (struct objfile *objfile)
                    if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
                      first_fun_line_offset =
                        main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
-                   RECORD_MINIMAL_SYMBOL
-                     (namestring, symbol.n_value,
+
+                   record_minimal_symbol
+                     (reader, namestring, symbol.n_value,
                       sclass == C_HIDEXT ? mst_file_text : mst_text,
-                      secnum_to_section (symbol.n_scnum, objfile),
-                      objfile);
+                      symbol.n_scnum, objfile);
+                   misc_func_recorded = 1;
                    break;
 
                  case XMC_GL:
@@ -2384,11 +2417,10 @@ scan_xcoff_symtab (struct objfile *objfile)
                       mst_solib_trampoline symbol.  When we lookup mst
                       symbols, we will choose mst_text over
                       mst_solib_trampoline.  */
-                   RECORD_MINIMAL_SYMBOL
-                     (namestring, symbol.n_value,
-                      mst_solib_trampoline,
-                      secnum_to_section (symbol.n_scnum, objfile),
-                      objfile);
+                   record_minimal_symbol
+                     (reader, namestring, symbol.n_value,
+                      mst_solib_trampoline, symbol.n_scnum, objfile);
+                   misc_func_recorded = 1;
                    break;
 
                  case XMC_DS:
@@ -2407,11 +2439,10 @@ scan_xcoff_symtab (struct objfile *objfile)
                       typically be XMC_RW; I suspect XMC_RO and
                       XMC_BS might be possible too.  */
                    if (*namestring != '.')
-                     prim_record_minimal_symbol_and_info
-                       (namestring, symbol.n_value,
+                     record_minimal_symbol
+                       (reader, namestring, symbol.n_value,
                         sclass == C_HIDEXT ? mst_file_data : mst_data,
-                        secnum_to_section (symbol.n_scnum, objfile),
-                        NULL, objfile);
+                        symbol.n_scnum, objfile);
                    break;
                  }
                break;
@@ -2424,11 +2455,10 @@ scan_xcoff_symtab (struct objfile *objfile)
                    /* Common variables are recorded in the minimal symbol
                       table, except for section symbols.  */
                    if (*namestring != '.')
-                     prim_record_minimal_symbol_and_info
-                       (namestring, symbol.n_value,
+                     record_minimal_symbol
+                       (reader, namestring, symbol.n_value,
                         sclass == C_HIDEXT ? mst_file_bss : mst_bss,
-                        secnum_to_section (symbol.n_scnum, objfile),
-                        NULL, objfile);
+                        symbol.n_scnum, objfile);
                    break;
                  }
                break;
@@ -2454,16 +2484,17 @@ scan_xcoff_symtab (struct objfile *objfile)
                   it as a function.  This will take care of functions like
                   strcmp() compiled by xlc.  */
 
-               RECORD_MINIMAL_SYMBOL
-                 (last_csect_name, last_csect_val,
-                  mst_text, last_csect_sec, objfile);
+               record_minimal_symbol (reader, last_csect_name, last_csect_val,
+                                      mst_text, last_csect_sec, objfile);
+               misc_func_recorded = 1;
              }
 
            if (pst)
              {
-               xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
-                                  symnum_before, dependency_list,
-                                  dependencies_used, textlow_not_set);
+               xcoff_end_psymtab (objfile, pst, psymtab_include_list,
+                                  includes_used, symnum_before,
+                                  dependency_list, dependencies_used,
+                                  textlow_not_set);
                includes_used = 0;
                dependencies_used = 0;
              }
@@ -2484,8 +2515,8 @@ scan_xcoff_symtab (struct objfile *objfile)
            pst = xcoff_start_psymtab (objfile,
                                       filestring,
                                       symnum_before,
-                                      objfile->global_psymbols.next,
-                                      objfile->static_psymbols.next);
+                                      objfile->global_psymbols,
+                                      objfile->static_psymbols);
            last_csect_name = NULL;
          }
          break;
@@ -2597,13 +2628,13 @@ scan_xcoff_symtab (struct objfile *objfile)
            psymtab_include_list[includes_used++] = namestring;
            if (includes_used >= includes_allocated)
              {
-               char **orig = psymtab_include_list;
+               const char **orig = psymtab_include_list;
 
-               psymtab_include_list = (char **)
+               psymtab_include_list = (const char **)
                  alloca ((includes_allocated *= 2) *
-                         sizeof (char *));
+                         sizeof (const char *));
                memcpy (psymtab_include_list, orig,
-                       includes_used * sizeof (char *));
+                       includes_used * sizeof (const char *));
              }
            continue;
          }
@@ -2618,12 +2649,12 @@ scan_xcoff_symtab (struct objfile *objfile)
        case C_DECL:
        case C_STSYM:
          {
-           char *p;
+           const char *p;
 
            swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
                      &ssymnum, objfile);
 
-           p = (char *) strchr (namestring, ':');
+           p = strchr (namestring, ':');
            if (!p)
              continue;                 /* Not a debugging symbol.   */
 
@@ -2647,7 +2678,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                add_psymbol_to_list (namestring, p - namestring, 1,
                                     VAR_DOMAIN, LOC_STATIC,
                                     &objfile->static_psymbols,
-                                    0, symbol.n_value,
+                                    symbol.n_value,
                                     psymtab_language, objfile);
                continue;
 
@@ -2659,7 +2690,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                add_psymbol_to_list (namestring, p - namestring, 1,
                                     VAR_DOMAIN, LOC_STATIC,
                                     &objfile->global_psymbols,
-                                    0, symbol.n_value,
+                                    symbol.n_value,
                                     psymtab_language, objfile);
                continue;
 
@@ -2677,16 +2708,14 @@ scan_xcoff_symtab (struct objfile *objfile)
                    add_psymbol_to_list (namestring, p - namestring, 1,
                                         STRUCT_DOMAIN, LOC_TYPEDEF,
                                         &objfile->static_psymbols,
-                                        symbol.n_value, 0,
-                                        psymtab_language, objfile);
+                                        0, psymtab_language, objfile);
                    if (p[2] == 't')
                      {
                        /* Also a typedef with the same name.  */
                        add_psymbol_to_list (namestring, p - namestring, 1,
                                             VAR_DOMAIN, LOC_TYPEDEF,
                                             &objfile->static_psymbols,
-                                            symbol.n_value, 0,
-                                            psymtab_language, objfile);
+                                            0, psymtab_language, objfile);
                        p += 1;
                      }
                  }
@@ -2698,8 +2727,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                    add_psymbol_to_list (namestring, p - namestring, 1,
                                         VAR_DOMAIN, LOC_TYPEDEF,
                                         &objfile->static_psymbols,
-                                        symbol.n_value, 0,
-                                        psymtab_language, objfile);
+                                        0, psymtab_language, objfile);
                  }
              check_enum:
                /* If this is an enumerated type, we need to
@@ -2745,7 +2773,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                       Accept either.  */
                    while (*p && *p != ';' && *p != ',')
                      {
-                       char *q;
+                       const char *q;
 
                        /* Check for and handle cretinous dbx symbol name
                           continuation!  */
@@ -2760,7 +2788,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                           enum constants in psymtabs, just in symtabs.  */
                        add_psymbol_to_list (p, q - p, 1,
                                             VAR_DOMAIN, LOC_CONST,
-                                            &objfile->static_psymbols, 0,
+                                            &objfile->static_psymbols,
                                             0, psymtab_language, objfile);
                        /* Point past the name.  */
                        p = q;
@@ -2778,7 +2806,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                /* Constant, e.g. from "const" in Pascal.  */
                add_psymbol_to_list (namestring, p - namestring, 1,
                                     VAR_DOMAIN, LOC_CONST,
-                                    &objfile->static_psymbols, symbol.n_value,
+                                    &objfile->static_psymbols,
                                     0, psymtab_language, objfile);
                continue;
 
@@ -2786,7 +2814,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                if (! pst)
                  {
                    int name_len = p - namestring;
-                   char *name = xmalloc (name_len + 1);
+                   char *name = (char *) xmalloc (name_len + 1);
 
                    memcpy (name, namestring, name_len);
                    name[name_len] = '\0';
@@ -2798,7 +2826,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                add_psymbol_to_list (namestring, p - namestring, 1,
                                     VAR_DOMAIN, LOC_BLOCK,
                                     &objfile->static_psymbols,
-                                    0, symbol.n_value,
+                                    symbol.n_value,
                                     psymtab_language, objfile);
                continue;
 
@@ -2809,7 +2837,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                if (! pst)
                  {
                    int name_len = p - namestring;
-                   char *name = xmalloc (name_len + 1);
+                   char *name = (char *) xmalloc (name_len + 1);
 
                    memcpy (name, namestring, name_len);
                    name[name_len] = '\0';
@@ -2821,7 +2849,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                   loader-generated definitions.  Keeping the global
                   symbols leads to "in psymbols but not in symbols"
                   errors.  */
-               if (strncmp (namestring, "@FIX", 4) == 0)
+               if (startswith (namestring, "@FIX"))
                  continue;
 
                symbol.n_value += ANOFFSET (objfile->section_offsets,
@@ -2829,7 +2857,7 @@ scan_xcoff_symtab (struct objfile *objfile)
                add_psymbol_to_list (namestring, p - namestring, 1,
                                     VAR_DOMAIN, LOC_BLOCK,
                                     &objfile->global_psymbols,
-                                    0, symbol.n_value,
+                                    symbol.n_value,
                                     psymtab_language, objfile);
                continue;
 
@@ -2885,7 +2913,7 @@ scan_xcoff_symtab (struct objfile *objfile)
 
   if (pst)
     {
-      xcoff_end_psymtab (pst, psymtab_include_list, includes_used,
+      xcoff_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
                         ssymnum, dependency_list,
                         dependencies_used, textlow_not_set);
     }
@@ -2895,8 +2923,7 @@ scan_xcoff_symtab (struct objfile *objfile)
      Another place to obtain this information would be file auxiliary
      header.  */
 
-  ((struct coff_symfile_info *) objfile->deprecated_sym_private)->toc_offset
-    = toc_offset;
+  XCOFF_DATA (objfile)->toc_offset = toc_offset;
 }
 
 /* Return the toc offset value for a given objfile.  */
@@ -2905,8 +2932,7 @@ CORE_ADDR
 xcoff_get_toc_offset (struct objfile *objfile)
 {
   if (objfile)
-    return ((struct coff_symfile_info *)
-           objfile->deprecated_sym_private)->toc_offset;
+    return XCOFF_DATA (objfile)->toc_offset;
   return 0;
 }
 
@@ -2920,21 +2946,20 @@ xcoff_get_toc_offset (struct objfile *objfile)
    loaded).  */
 
 static void
-xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
+xcoff_initial_scan (struct objfile *objfile, symfile_add_flags symfile_flags)
 {
   bfd *abfd;
   int val;
-  struct cleanup *back_to;
   int num_symbols;             /* # of symbols */
   file_ptr symtab_offset;      /* symbol table and */
   file_ptr stringtab_offset;   /* string table file offsets */
   struct coff_symfile_info *info;
-  char *name;
+  const char *name;
   unsigned int size;
 
-  info = (struct coff_symfile_info *) objfile->deprecated_sym_private;
+  info = XCOFF_DATA (objfile);
   symfile_bfd = abfd = objfile->obfd;
-  name = objfile->name;
+  name = objfile_name (objfile);
 
   num_symbols = bfd_get_symcount (abfd);       /* # of symbols */
   symtab_offset = obj_sym_filepos (abfd);      /* symbol table file offset */
@@ -2950,33 +2975,33 @@ xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
       /* Read the string table.  */
       init_stringtab (abfd, stringtab_offset, objfile);
 
-      /* Read the .debug section, if present.  */
-      {
-       struct bfd_section *secp;
-       bfd_size_type length;
-       char *debugsec = NULL;
+      /* Read the .debug section, if present and if we're not ignoring
+        it.  */
+      if (!(objfile->flags & OBJF_READNEVER))
+       {
+         struct bfd_section *secp;
+         bfd_size_type length;
+         bfd_byte *debugsec = NULL;
 
-       secp = bfd_get_section_by_name (abfd, ".debug");
-       if (secp)
-         {
-           length = bfd_section_size (abfd, secp);
-           if (length)
-             {
-               debugsec =
-                 (char *) obstack_alloc (&objfile->objfile_obstack, length);
+         secp = bfd_get_section_by_name (abfd, ".debug");
+         if (secp)
+           {
+             length = bfd_section_size (abfd, secp);
+             if (length)
+               {
+                 debugsec
+                   = (bfd_byte *) obstack_alloc (&objfile->objfile_obstack,
+                                                 length);
 
-               if (!bfd_get_section_contents (abfd, secp, debugsec,
-                                              (file_ptr) 0, length))
-                 {
-                   error (_("Error reading .debug section of `%s': %s"),
-                          name, bfd_errmsg (bfd_get_error ()));
-                 }
-             }
-         }
-       ((struct coff_symfile_info *)
-        objfile->deprecated_sym_private)->debugsec
-         = debugsec;
-      }
+                 if (!bfd_get_full_section_contents (abfd, secp, &debugsec))
+                   {
+                     error (_("Error reading .debug section of `%s': %s"),
+                            name, bfd_errmsg (bfd_get_error ()));
+                   }
+               }
+           }
+         info->debugsec = (char *) debugsec;
+       }
     }
 
   /* Read the symbols.  We keep them in core because we will want to
@@ -2986,20 +3011,16 @@ xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
     error (_("Error reading symbols from %s: %s"),
           name, bfd_errmsg (bfd_get_error ()));
   size = coff_data (abfd)->local_symesz * num_symbols;
-  ((struct coff_symfile_info *) objfile->deprecated_sym_private)->symtbl =
-    obstack_alloc (&objfile->objfile_obstack, size);
-  ((struct coff_symfile_info *)
-   objfile->deprecated_sym_private)->symtbl_num_syms
-    = num_symbols;
-
-  val = bfd_bread (((struct coff_symfile_info *)
-                   objfile->deprecated_sym_private)->symtbl,
-                  size, abfd);
+  info->symtbl = (char *) obstack_alloc (&objfile->objfile_obstack, size);
+  info->symtbl_num_syms = num_symbols;
+
+  val = bfd_bread (info->symtbl, size, abfd);
   if (val != size)
     perror_with_name (_("reading symbol table"));
 
   /* If we are reinitializing, or if we have never loaded syms yet, init.  */
-  if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
+  if (objfile->global_psymbols.capacity () == 0
+      && objfile->static_psymbols.capacity () == 0)
     /* I'm not sure how how good num_symbols is; the rule of thumb in
        init_psymbol_list was developed for a.out.  On the one hand,
        num_symbols includes auxents.  On the other hand, it doesn't
@@ -3007,66 +3028,64 @@ xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
     init_psymbol_list (objfile, num_symbols);
 
   free_pending_blocks ();
-  back_to = make_cleanup (really_free_pendings, 0);
 
-  init_minimal_symbol_collection ();
-  make_cleanup_discard_minimal_symbols ();
+  scoped_free_pendings free_pending;
+  minimal_symbol_reader reader (objfile);
 
   /* Now that the symbol table data of the executable file are all in core,
      process them and define symbols accordingly.  */
 
-  scan_xcoff_symtab (objfile);
+  scan_xcoff_symtab (reader, objfile);
 
   /* Install any minimal symbols that have been collected as the current
      minimal symbols for this objfile.  */
 
-  install_minimal_symbols (objfile);
+  reader.install ();
+
+  /* DWARF2 sections.  */
 
-  do_cleanups (back_to);
+  if (dwarf2_has_info (objfile, &dwarf2_xcoff_names))
+    dwarf2_build_psymtabs (objfile);
+
+  dwarf2_build_frame_info (objfile);
 }
 \f
 static void
 xcoff_symfile_offsets (struct objfile *objfile,
-                      struct section_addr_info *addrs)
+                      const struct section_addr_info *addrs)
 {
-  asection *sect = NULL;
-  int i;
+  const char *first_section_name;
 
-  objfile->num_sections = bfd_count_sections (objfile->obfd);
-  objfile->section_offsets = (struct section_offsets *)
-    obstack_alloc (&objfile->objfile_obstack, 
-                  SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
+  default_symfile_offsets (objfile, addrs);
 
-  /* Initialize the section indexes for future use.  */
-  sect = bfd_get_section_by_name (objfile->obfd, ".text");
-  if (sect) 
-    objfile->sect_index_text = sect->index;
+  /* Oneof the weird side-effects of default_symfile_offsets is that
+     it sometimes sets some section indices to zero for sections that,
+     in fact do not exist. See the body of default_symfile_offsets
+     for more info on when that happens. Undo that, as this then allows
+     us to test whether the associated section exists or not, and then
+     access it quickly (without searching it again).  */
 
-  sect = bfd_get_section_by_name (objfile->obfd, ".data");
-  if (sect) 
-    objfile->sect_index_data = sect->index;
+  if (objfile->num_sections == 0)
+    return; /* Is that even possible?  Better safe than sorry.  */
 
-  sect = bfd_get_section_by_name (objfile->obfd, ".bss");
-  if (sect) 
-    objfile->sect_index_bss = sect->index;
+  first_section_name
+    = bfd_section_name (objfile->obfd, objfile->sections[0].the_bfd_section);
 
-  sect = bfd_get_section_by_name (objfile->obfd, ".rodata");
-  if (sect) 
-    objfile->sect_index_rodata = sect->index;
+  if (objfile->sect_index_text == 0
+      && strcmp (first_section_name, ".text") != 0)
+    objfile->sect_index_text = -1;
 
-  for (i = 0; i < objfile->num_sections; ++i)
-    {
-      /* syms_from_objfile kindly subtracts from addr the
-        bfd_section_vma of the .text section.  This strikes me as
-        wrong--whether the offset to be applied to symbol reading is
-        relative to the start address of the section depends on the
-        symbol format.  In any event, this whole "addr" concept is
-        pretty broken (it doesn't handle any section but .text
-        sensibly), so just ignore the addr parameter and use 0.
-        rs6000-nat.c will set the correct section offsets via
-        objfile_relocate.  */
-       (objfile->section_offsets)->offsets[i] = 0;
-    }
+  if (objfile->sect_index_data == 0
+      && strcmp (first_section_name, ".data") != 0)
+    objfile->sect_index_data = -1;
+
+  if (objfile->sect_index_bss == 0
+      && strcmp (first_section_name, ".bss") != 0)
+    objfile->sect_index_bss = -1;
+
+  if (objfile->sect_index_rodata == 0
+      && strcmp (first_section_name, ".rodata") != 0)
+    objfile->sect_index_rodata = -1;
 }
 
 /* Register our ability to parse symbols for xcoff BFD files.  */
@@ -3083,8 +3102,6 @@ static const struct sym_fns xcoff_sym_fns =
      xcoffread.c reads all the symbols and does in fact randomly access them
      (in C_BSTAT and line number processing).  */
 
-  bfd_target_xcoff_flavour,
-
   xcoff_new_init,              /* init anything gbl to entire symtab */
   xcoff_symfile_init,          /* read initial info, setup for sym_read() */
   xcoff_initial_scan,          /* read a symbol file into symtab */
@@ -3094,14 +3111,84 @@ static const struct sym_fns xcoff_sym_fns =
   default_symfile_segments,    /* Get segment information from a file.  */
   aix_process_linenos,
   default_symfile_relocate,    /* Relocate a debug section.  */
+  NULL,                                /* sym_probe_fns */
   &psym_functions
 };
 
-/* Provide a prototype to silence -Wmissing-prototypes.  */
-extern initialize_file_ftype _initialize_xcoffread;
+/* Same as xcoff_get_n_import_files, but for core files.  */
+
+static int
+xcoff_get_core_n_import_files (bfd *abfd)
+{
+  asection *sect = bfd_get_section_by_name (abfd, ".ldinfo");
+  gdb_byte buf[4];
+  file_ptr offset = 0;
+  int n_entries = 0;
+
+  if (sect == NULL)
+    return -1;  /* Not a core file.  */
+
+  for (offset = 0; offset < bfd_get_section_size (sect);)
+    {
+      int next;
+
+      n_entries++;
+
+      if (!bfd_get_section_contents (abfd, sect, buf, offset, 4))
+       return -1;
+      next = bfd_get_32 (abfd, buf);
+      if (next == 0)
+       break;  /* This is the last entry.  */
+      offset += next;
+    }
+
+  /* Return the number of entries, excluding the first one, which is
+     the path to the executable that produced this core file.  */
+  return n_entries - 1;
+}
+
+/* Return the number of import files (shared libraries) that the given
+   BFD depends on.  Return -1 if this number could not be computed.  */
+
+int
+xcoff_get_n_import_files (bfd *abfd)
+{
+  asection *sect = bfd_get_section_by_name (abfd, ".loader");
+  gdb_byte buf[4];
+  int l_nimpid;
+
+  /* If the ".loader" section does not exist, the objfile is probably
+     not an executable.  Might be a core file...  */
+  if (sect == NULL)
+    return xcoff_get_core_n_import_files (abfd);
+
+  /* The number of entries in the Import Files Table is stored in
+     field l_nimpid.  This field is always at offset 16, and is
+     always 4 bytes long.  Read those 4 bytes.  */
+
+  if (!bfd_get_section_contents (abfd, sect, buf, 16, 4))
+    return -1;
+  l_nimpid = bfd_get_32 (abfd, buf);
+
+  /* By convention, the first entry is the default LIBPATH value
+     to be used by the system loader, so it does not count towards
+     the number of import files.  */
+  return l_nimpid - 1;
+}
+
+/* Free the per-objfile xcoff data.  */
+
+static void
+xcoff_free_info (struct objfile *objfile, void *arg)
+{
+  xfree (arg);
+}
 
 void
 _initialize_xcoffread (void)
 {
-  add_symtab_fns (&xcoff_sym_fns);
+  add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
+
+  xcoff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
+                                                              xcoff_free_info);
 }
This page took 0.055688 seconds and 4 git commands to generate.