Mon Mar 24 19:43:16 1997 Geoffrey Noer <[email protected]>

[binutils.git] / gdb / dwarfread.c

diff --git a/gdb/dwarfread.c b/gdb/dwarfread.c
index 5e22da5c6a40d5aefdb9dda8ae4adc6cad994df5..529f01b3ff5edfb9091c1f2f67437026d43d27ba 100644 (file)
--- a/gdb/dwarfread.c
+++ b/gdb/dwarfread.c
@@ -1,5 +1,6 @@
 /* DWARF debugging format support for GDB.
 /* DWARF debugging format support for GDB.

-   Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+   Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996
+   Free Software Foundation, Inc.

    Written by Fred Fish at Cygnus Support.  Portions based on dbxread.c,
    mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
 
    Written by Fred Fish at Cygnus Support.  Portions based on dbxread.c,
    mipsread.c, coffread.c, and dwarfread.c from a Data General SVR4 gdb port.
 


@@ -17,14 +18,12 @@ 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
 
 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 /*
 
 
 /*
 

-FIXME: Figure out how to get the frame pointer register number in the
-execution environment of the target.  Remove R_FP kludge
-
-FIXME: Add generation of dependencies list to partial symtab code.
+FIXME: Do we need to generate dependencies in partial symtabs?
+(Perhaps we don't need to).

 
 FIXME: Resolve minor differences between what information we put in the
 partial symbol table and what dbxread puts in.  For example, we don't yet
 
 FIXME: Resolve minor differences between what information we put in the
 partial symbol table and what dbxread puts in.  For example, we don't yet


@@ -41,12 +40,10 @@ other things to work on, if you get bored. :-)
 */
 
 #include "defs.h"
 */
 
 #include "defs.h"

-#include "bfd.h"

 #include "symtab.h"
 #include "gdbtypes.h"
 #include "symfile.h"
 #include "objfiles.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "symfile.h"
 #include "objfiles.h"

-#include "libbfd.h"    /* FIXME Secret Internal BFD stuff (bfd_read) */

 #include "elf/dwarf.h"
 #include "buildsym.h"
 #include "demangle.h"
 #include "elf/dwarf.h"
 #include "buildsym.h"
 #include "demangle.h"


@@ -55,17 +52,7 @@ other things to work on, if you get bored. :-)
 #include "complaints.h"
 
 #include <fcntl.h>
 #include "complaints.h"
 
 #include <fcntl.h>

-#include <string.h>
-#include <sys/types.h>
-
-#ifndef        NO_SYS_FILE
-#include <sys/file.h>
-#endif
-
-/* FIXME -- convert this to SEEK_SET a la POSIX, move to config files.  */
-#ifndef L_SET
-#define L_SET 0
-#endif
+#include "gdb_string.h"

 
 /* Some macros to provide DIE info for complaints. */
 
 
 /* Some macros to provide DIE info for complaints. */
 


@@ -179,9 +166,10 @@ struct complaint not_row_major =
   "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
 };
 
   "DIE @ 0x%x \"%s\", array not row major; not handled correctly", 0, 0
 };
 

-#ifndef R_FP           /* FIXME */
-#define R_FP 14                /* Kludge to get frame pointer register number */
-#endif
+struct complaint missing_at_name =
+{
+  "DIE @ 0x%x, AT_name tag missing", 0, 0
+};

 
 typedef unsigned int DIE_REF;  /* Reference to a DIE */
 
 
 typedef unsigned int DIE_REF;  /* Reference to a DIE */
 


@@ -197,18 +185,14 @@ typedef unsigned int DIE_REF;     /* Reference to a DIE */
 #define LCC_PRODUCER "NCR C/C++"
 #endif
 
 #define LCC_PRODUCER "NCR C/C++"
 #endif
 

-#ifndef CFRONT_PRODUCER
-#define CFRONT_PRODUCER "CFRONT "      /* A wild a** guess... */
-#endif
-
-/* start-sanitize-chill */

 #ifndef CHILL_PRODUCER
 #define CHILL_PRODUCER "GNU Chill "
 #endif
 #ifndef CHILL_PRODUCER
 #define CHILL_PRODUCER "GNU Chill "
 #endif

-/* end-sanitize-chill */

 
 

-#define STREQ(a,b)             (strcmp(a,b)==0)
-#define STREQN(a,b,n)          (strncmp(a,b,n)==0)
+/* Provide a default mapping from a DWARF register number to a gdb REGNUM.  */
+#ifndef DWARF_REG_TO_REGNUM
+#define DWARF_REG_TO_REGNUM(num) (num)
+#endif

 
 /* Flags to target_to_host() that tell whether or not the data object is
    expected to be signed.  Used, for example, when fetching a signed
 
 /* Flags to target_to_host() that tell whether or not the data object is
    expected to be signed.  Used, for example, when fetching a signed


@@ -313,8 +297,8 @@ struct dieinfo {
   unsigned long                at_bit_size;
   BLOCK *              at_element_list;
   unsigned long                at_stmt_list;
   unsigned long                at_bit_size;
   BLOCK *              at_element_list;
   unsigned long                at_stmt_list;

-  unsigned long                at_low_pc;
-  unsigned long                at_high_pc;
+  CORE_ADDR            at_low_pc;
+  CORE_ADDR            at_high_pc;

   unsigned long                at_language;
   unsigned long                at_member;
   unsigned long                at_discr;
   unsigned long                at_language;
   unsigned long                at_member;
   unsigned long                at_discr;


@@ -340,47 +324,45 @@ static int dbsize;        /* Size of dwarf info in bytes */
 static int dbroff;     /* Relative offset from start of .debug section */
 static char *lnbase;   /* Base pointer to line section */
 static int isreg;      /* Kludge to identify register variables */
 static int dbroff;     /* Relative offset from start of .debug section */
 static char *lnbase;   /* Base pointer to line section */
 static int isreg;      /* Kludge to identify register variables */

-static int offreg;     /* Kludge to identify basereg references */
+static int optimized_out;  /* Kludge to identify optimized out variables */
+/* Kludge to identify basereg references.  Nonzero if we have an offset
+   relative to a basereg.  */
+static int offreg;
+/* Which base register is it relative to?  */
+static int basereg;

 
 /* This value is added to each symbol value.  FIXME:  Generalize to 
 
 /* This value is added to each symbol value.  FIXME:  Generalize to 

-   the section_offsets structure used by dbxread.  */
+   the section_offsets structure used by dbxread (once this is done,
+   pass the appropriate section number to end_symtab).  */

 static CORE_ADDR baseaddr;     /* Add to each symbol value */
 
 /* The section offsets used in the current psymtab or symtab.  FIXME,
    only used to pass one value (baseaddr) at the moment.  */
 static struct section_offsets *base_section_offsets;
 
 static CORE_ADDR baseaddr;     /* Add to each symbol value */
 
 /* The section offsets used in the current psymtab or symtab.  FIXME,
    only used to pass one value (baseaddr) at the moment.  */
 static struct section_offsets *base_section_offsets;
 

-/* Each partial symbol table entry contains a pointer to private data for the
-   read_symtab() function to use when expanding a partial symbol table entry
-   to a full symbol table entry.  For DWARF debugging info, this data is
-   contained in the following structure and macros are provided for easy
-   access to the members given a pointer to a partial symbol table entry.
-
-   dbfoff      Always the absolute file offset to the start of the ".debug"
-               section for the file containing the DIE's being accessed.
-
-   dbroff      Relative offset from the start of the ".debug" access to the
-               first DIE to be accessed.  When building the partial symbol
-               table, this value will be zero since we are accessing the
-               entire ".debug" section.  When expanding a partial symbol
-               table entry, this value will be the offset to the first
-               DIE for the compilation unit containing the symbol that
-               triggers the expansion.
-
-   dblength    The size of the chunk of DIE's being examined, in bytes.
-
-   lnfoff      The absolute file offset to the line table fragment.  Ignored
-               when building partial symbol tables, but used when expanding
-               them, and contains the absolute file offset to the fragment
-               of the ".line" section containing the line numbers for the
-               current compilation unit.
- */
+/* We put a pointer to this structure in the read_symtab_private field
+   of the psymtab.  */

 
 struct dwfinfo {
 
 struct dwfinfo {

-  file_ptr dbfoff;     /* Absolute file offset to start of .debug section */
-  int dbroff;          /* Relative offset from start of .debug section */
-  int dblength;                /* Size of the chunk of DIE's being examined */
-  file_ptr lnfoff;     /* Absolute file offset to line table fragment */
+  /* Always the absolute file offset to the start of the ".debug"
+     section for the file containing the DIE's being accessed.  */
+  file_ptr dbfoff;
+  /* Relative offset from the start of the ".debug" section to the
+     first DIE to be accessed.  When building the partial symbol
+     table, this value will be zero since we are accessing the
+     entire ".debug" section.  When expanding a partial symbol
+     table entry, this value will be the offset to the first
+     DIE for the compilation unit containing the symbol that
+     triggers the expansion.  */
+  int dbroff;
+  /* The size of the chunk of DIE's being examined, in bytes.  */
+  int dblength;
+  /* The absolute file offset to the line table fragment.  Ignored
+     when building partial symbol tables, but used when expanding
+     them, and contains the absolute file offset to the fragment
+     of the ".line" section containing the line numbers for the
+     current compilation unit.  */
+  file_ptr lnfoff;

 };
 
 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)
 };
 
 #define DBFOFF(p) (((struct dwfinfo *)((p)->read_symtab_private))->dbfoff)


@@ -456,10 +438,13 @@ static const struct language_defn *cu_language_defn;
 /* Forward declarations of static functions so we don't have to worry
    about ordering within this file.  */
 
 /* Forward declarations of static functions so we don't have to worry
    about ordering within this file.  */
 

+static void
+free_utypes PARAMS ((PTR));
+

 static int
 attribute_size PARAMS ((unsigned int));
 
 static int
 attribute_size PARAMS ((unsigned int));
 

-static unsigned long
+static CORE_ADDR

 target_to_host PARAMS ((char *, int, int, struct objfile *));
 
 static void
 target_to_host PARAMS ((char *, int, int, struct objfile *));
 
 static void


@@ -488,9 +473,6 @@ scan_compilation_units PARAMS ((char *, char *, file_ptr,
 static void
 add_partial_symbol PARAMS ((struct dieinfo *, struct objfile *));
 
 static void
 add_partial_symbol PARAMS ((struct dieinfo *, struct objfile *));
 

-static void
-init_psymbol_list PARAMS ((struct objfile *, int));
-

 static void
 basicdieinfo PARAMS ((struct dieinfo *, char *, struct objfile *));
 
 static void
 basicdieinfo PARAMS ((struct dieinfo *, char *, struct objfile *));
 


@@ -503,7 +485,7 @@ dwarf_psymtab_to_symtab PARAMS ((struct partial_symtab *));
 static void
 psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
 
 static void
 psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
 

-static struct symtab *
+static void

 read_ofile_symtab PARAMS ((struct partial_symtab *));
 
 static void
 read_ofile_symtab PARAMS ((struct partial_symtab *));
 
 static void


@@ -525,6 +507,9 @@ dwarf_read_array_type PARAMS ((struct dieinfo *));
 static void
 read_tag_pointer_type PARAMS ((struct dieinfo *dip));
 
 static void
 read_tag_pointer_type PARAMS ((struct dieinfo *dip));
 

+static void
+read_tag_string_type PARAMS ((struct dieinfo *dip));
+

 static void
 read_subroutine_type PARAMS ((struct dieinfo *, char *, char *));
 
 static void
 read_subroutine_type PARAMS ((struct dieinfo *, char *, char *));
 


@@ -574,10 +559,6 @@ synthesize_typedef PARAMS ((struct dieinfo *, struct objfile *,
 static int
 locval PARAMS ((char *));
 
 static int
 locval PARAMS ((char *));
 

-static void
-record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type,
-                              struct objfile *));
-

 static void
 set_cu_language PARAMS ((struct dieinfo *));
 
 static void
 set_cu_language PARAMS ((struct dieinfo *));
 


@@ -677,11 +658,9 @@ set_cu_language (dip)
       case LANG_C_PLUS_PLUS:
        cu_language = language_cplus;
        break;
       case LANG_C_PLUS_PLUS:
        cu_language = language_cplus;
        break;

-      /* start-sanitize-chill */

       case LANG_CHILL:
        cu_language = language_chill;
        break;
       case LANG_CHILL:
        cu_language = language_chill;
        break;

-      /* end-sanitize-chill */

       case LANG_MODULA2:
        cu_language = language_m2;
        break;
       case LANG_MODULA2:
        cu_language = language_m2;
        break;


@@ -691,9 +670,13 @@ set_cu_language (dip)
       case LANG_FORTRAN77:
       case LANG_FORTRAN90:
       case LANG_PASCAL83:
       case LANG_FORTRAN77:
       case LANG_FORTRAN90:
       case LANG_PASCAL83:

-      default:
+       /* We don't know anything special about these yet. */

        cu_language = language_unknown;
        break;
        cu_language = language_unknown;
        break;

+      default:
+       /* If no at_language, try to deduce one from the filename */
+       cu_language = deduce_language_from_filename (dip -> at_name);
+       break;

     }
   cu_language_defn = language_def (cu_language);
 }
     }
   cu_language_defn = language_def (cu_language);
 }


@@ -748,7 +731,7 @@ dwarf_build_psymtabs (objfile, section_offsets, mainline, dbfoff, dbfsize,
   dbsize = dbfsize;
   dbbase = xmalloc (dbsize);
   dbroff = 0;
   dbsize = dbfsize;
   dbbase = xmalloc (dbsize);
   dbroff = 0;

-  if ((bfd_seek (abfd, dbfoff, L_SET) != 0) ||
+  if ((bfd_seek (abfd, dbfoff, SEEK_SET) != 0) ||

       (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
     {
       free (dbbase);
       (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
     {
       free (dbbase);


@@ -781,39 +764,6 @@ dwarf_build_psymtabs (objfile, section_offsets, mainline, dbfoff, dbfsize,
   current_objfile = NULL;
 }
 
   current_objfile = NULL;
 }
 

-
-/*
-
-LOCAL FUNCTION
-
-       record_minimal_symbol -- add entry to gdb's minimal symbol table
-
-SYNOPSIS
-
-       static void record_minimal_symbol (char *name, CORE_ADDR address,
-                                         enum minimal_symbol_type ms_type,
-                                         struct objfile *objfile)
-
-DESCRIPTION
-
-       Given a pointer to the name of a symbol that should be added to the
-       minimal symbol table, and the address associated with that
-       symbol, records this information for later use in building the
-       minimal symbol table.
-
- */
-
-static void
-record_minimal_symbol (name, address, ms_type, objfile)
-     char *name;
-     CORE_ADDR address;
-     enum minimal_symbol_type ms_type;
-     struct objfile *objfile;
-{
-  name = obsavestring (name, strlen (name), &objfile -> symbol_obstack);
-  prim_record_minimal_symbol (name, address, ms_type);
-}
-

 /*
 
 LOCAL FUNCTION
 /*
 
 LOCAL FUNCTION


@@ -943,6 +893,33 @@ alloc_utype (die_ref, utypep)
   return (utypep);
 }
 
   return (utypep);
 }
 

+/*
+
+LOCAL FUNCTION
+
+       free_utypes -- free the utypes array and reset pointer & count
+
+SYNOPSIS
+
+       static void free_utypes (PTR dummy)
+
+DESCRIPTION
+
+       Called via do_cleanups to free the utypes array, reset the pointer to NULL,
+       and set numutypes back to zero.  This ensures that the utypes does not get
+       referenced after being freed.
+ */
+
+static void
+free_utypes (dummy)
+     PTR dummy;
+{
+  free (utypes);
+  utypes = NULL;
+  numutypes = 0;
+}
+
+

 /*
 
 LOCAL FUNCTION
 /*
 
 LOCAL FUNCTION


@@ -987,7 +964,7 @@ decode_die_type (dip)
     }
   else
     {
     }
   else
     {

-      type = dwarf_fundamental_type (current_objfile, FT_INTEGER);
+      type = dwarf_fundamental_type (current_objfile, FT_VOID);

     }
   return (type);
 }
     }
   return (type);
 }


@@ -1028,7 +1005,6 @@ struct_type (dip, thisdie, enddie, objfile)
   struct nextfield *new;
   int nfields = 0;
   int n;
   struct nextfield *new;
   int nfields = 0;
   int n;

-  char *tpart1;

   struct dieinfo mbr;
   char *nextdie;
   int anonymous_size;
   struct dieinfo mbr;
   char *nextdie;
   int anonymous_size;


@@ -1043,20 +1019,16 @@ struct_type (dip, thisdie, enddie, objfile)
     {
       case TAG_class_type:
         TYPE_CODE (type) = TYPE_CODE_CLASS;
     {
       case TAG_class_type:
         TYPE_CODE (type) = TYPE_CODE_CLASS;

-       tpart1 = "class";

        break;
       case TAG_structure_type:
         TYPE_CODE (type) = TYPE_CODE_STRUCT;
        break;
       case TAG_structure_type:
         TYPE_CODE (type) = TYPE_CODE_STRUCT;

-       tpart1 = "struct";

        break;
       case TAG_union_type:
        TYPE_CODE (type) = TYPE_CODE_UNION;
        break;
       case TAG_union_type:
        TYPE_CODE (type) = TYPE_CODE_UNION;

-       tpart1 = "union";

        break;
       default:
        /* Should never happen */
        TYPE_CODE (type) = TYPE_CODE_UNDEF;
        break;
       default:
        /* Should never happen */
        TYPE_CODE (type) = TYPE_CODE_UNDEF;

-       tpart1 = "???";

        complain (&missing_tag, DIE_ID, DIE_NAME);
        break;
     }
        complain (&missing_tag, DIE_ID, DIE_NAME);
        break;
     }


@@ -1067,8 +1039,8 @@ struct_type (dip, thisdie, enddie, objfile)
       && *dip -> at_name != '~'
       && *dip -> at_name != '.')
     {
       && *dip -> at_name != '~'
       && *dip -> at_name != '.')
     {

-      TYPE_NAME (type) = obconcat (&objfile -> type_obstack,
-                                  tpart1, " ", dip -> at_name);
+      TYPE_TAG_NAME (type) = obconcat (&objfile -> type_obstack,
+                                      "", "", dip -> at_name);

     }
   /* Use whatever size is known.  Zero is a valid size.  We might however
      wish to check has_at_byte_size to make sure that some byte size was
     }
   /* Use whatever size is known.  Zero is a valid size.  We might however
      wish to check has_at_byte_size to make sure that some byte size was


@@ -1108,39 +1080,47 @@ struct_type (dip, thisdie, enddie, objfile)
          list -> field.bitpos = 8 * locval (mbr.at_location);
          /* Handle bit fields. */
          list -> field.bitsize = mbr.at_bit_size;
          list -> field.bitpos = 8 * locval (mbr.at_location);
          /* Handle bit fields. */
          list -> field.bitsize = mbr.at_bit_size;

-#if BITS_BIG_ENDIAN
-         /* For big endian bits, the at_bit_offset gives the additional
-            bit offset from the MSB of the containing anonymous object to
-            the MSB of the field.  We don't have to do anything special
-            since we don't need to know the size of the anonymous object. */
-         list -> field.bitpos += mbr.at_bit_offset;
-#else
-         /* For little endian bits, we need to have a non-zero at_bit_size,
-            so that we know we are in fact dealing with a bitfield.  Compute
-            the bit offset to the MSB of the anonymous object, subtract off
-            the number of bits from the MSB of the field to the MSB of the
-            object, and then subtract off the number of bits of the field
-            itself.  The result is the bit offset of the LSB of the field. */
-         if (mbr.at_bit_size > 0)
+         if (BITS_BIG_ENDIAN)

            {
            {

-             if (mbr.has_at_byte_size)
-               {
-                 /* The size of the anonymous object containing the bit field
-                    is explicit, so use the indicated size (in bytes). */
-                 anonymous_size = mbr.at_byte_size;
-               }
-             else
+             /* For big endian bits, the at_bit_offset gives the
+                additional bit offset from the MSB of the containing
+                anonymous object to the MSB of the field.  We don't
+                have to do anything special since we don't need to
+                know the size of the anonymous object. */
+             list -> field.bitpos += mbr.at_bit_offset;
+           }
+         else
+           {
+             /* For little endian bits, we need to have a non-zero
+                at_bit_size, so that we know we are in fact dealing
+                with a bitfield.  Compute the bit offset to the MSB
+                of the anonymous object, subtract off the number of
+                bits from the MSB of the field to the MSB of the
+                object, and then subtract off the number of bits of
+                the field itself.  The result is the bit offset of
+                the LSB of the field. */
+             if (mbr.at_bit_size > 0)

                {
                {

-                 /* The size of the anonymous object containing the bit field
-                    matches the size of an object of the bit field's type.
-                    DWARF allows at_byte_size to be left out in such cases,
-                    as a debug information size optimization. */
-                 anonymous_size = TYPE_LENGTH (list -> field.type);
+                 if (mbr.has_at_byte_size)
+                   {
+                     /* The size of the anonymous object containing
+                        the bit field is explicit, so use the
+                        indicated size (in bytes). */
+                     anonymous_size = mbr.at_byte_size;
+                   }
+                 else
+                   {
+                     /* The size of the anonymous object containing
+                        the bit field matches the size of an object
+                        of the bit field's type.  DWARF allows
+                        at_byte_size to be left out in such cases, as
+                        a debug information size optimization. */
+                     anonymous_size = TYPE_LENGTH (list -> field.type);
+                   }
+                 list -> field.bitpos +=
+                   anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size;

                }
                }

-             list -> field.bitpos +=
-               anonymous_size * 8 - mbr.at_bit_offset - mbr.at_bit_size;

            }
            }

-#endif

          nfields++;
          break;
        default:
          nfields++;
          break;
        default:


@@ -1353,6 +1333,7 @@ decode_subscript_data_item (scan, end)
   struct type *typep = NULL;   /* Array type we are building */
   struct type *nexttype;       /* Type of each element (may be array) */
   struct type *indextype;      /* Type of this index */
   struct type *typep = NULL;   /* Array type we are building */
   struct type *nexttype;       /* Type of each element (may be array) */
   struct type *indextype;      /* Type of this index */

+  struct type *rangetype;

   unsigned int format;
   unsigned short fundtype;
   unsigned long lowbound;
   unsigned int format;
   unsigned short fundtype;
   unsigned long lowbound;


@@ -1384,8 +1365,9 @@ decode_subscript_data_item (scan, end)
          complain (&subscript_data_items, DIE_ID, DIE_NAME);
          nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
        }
          complain (&subscript_data_items, DIE_ID, DIE_NAME);
          nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
        }

-      typep = create_array_type ((struct type *) NULL, nexttype, indextype,
-                                lowbound, highbound);
+      rangetype = create_range_type ((struct type *) NULL, indextype,
+                                     lowbound, highbound);
+      typep = create_array_type ((struct type *) NULL, nexttype, rangetype);

       break;
     case FMT_FT_C_X:
     case FMT_FT_X_C:
       break;
     case FMT_FT_C_X:
     case FMT_FT_X_C:


@@ -1395,13 +1377,15 @@ decode_subscript_data_item (scan, end)
     case FMT_UT_X_C:
     case FMT_UT_X_X:
       complain (&unhandled_array_subscript_format, DIE_ID, DIE_NAME, format);
     case FMT_UT_X_C:
     case FMT_UT_X_X:
       complain (&unhandled_array_subscript_format, DIE_ID, DIE_NAME, format);

-      typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
-      typep = create_array_type ((struct type *) NULL, typep, typep, 0, 1);
+      nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
+      rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
+      typep = create_array_type ((struct type *) NULL, nexttype, rangetype);

       break;
     default:
       complain (&unknown_array_subscript_format, DIE_ID, DIE_NAME, format);
       break;
     default:
       complain (&unknown_array_subscript_format, DIE_ID, DIE_NAME, format);

-      typep = dwarf_fundamental_type (current_objfile, FT_INTEGER);
-      typep = create_array_type ((struct type *) NULL, typep, typep, 0, 1);
+      nexttype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
+      rangetype = create_range_type ((struct type *) NULL, nexttype, 0, 0);
+      typep = create_array_type ((struct type *) NULL, nexttype, rangetype);

       break;
     }
   return (typep);
       break;
     }
   return (typep);


@@ -1517,6 +1501,69 @@ read_tag_pointer_type (dip)
 
 /*
 
 
 /*
 

+LOCAL FUNCTION
+
+       read_tag_string_type -- read TAG_string_type DIE
+
+SYNOPSIS
+
+       static void read_tag_string_type (struct dieinfo *dip)
+
+DESCRIPTION
+
+       Extract all information from a TAG_string_type DIE and add to
+       the user defined type vector.  It isn't really a user defined
+       type, but it behaves like one, with other DIE's using an
+       AT_user_def_type attribute to reference it.
+ */
+
+static void
+read_tag_string_type (dip)
+     struct dieinfo *dip;
+{
+  struct type *utype;
+  struct type *indextype;
+  struct type *rangetype;
+  unsigned long lowbound = 0;
+  unsigned long highbound;
+
+  if (dip -> has_at_byte_size)
+    {
+      /* A fixed bounds string */
+      highbound = dip -> at_byte_size - 1;
+    }
+  else
+    {
+      /* A varying length string.  Stub for now.  (FIXME) */
+      highbound = 1;
+    }
+  indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
+  rangetype = create_range_type ((struct type *) NULL, indextype, lowbound,
+                                highbound);
+      
+  utype = lookup_utype (dip -> die_ref);
+  if (utype == NULL)
+    {
+      /* No type defined, go ahead and create a blank one to use. */
+      utype = alloc_utype (dip -> die_ref, (struct type *) NULL);
+    }
+  else
+    {
+      /* Already a type in our slot due to a forward reference. Make sure it
+        is a blank one.  If not, complain and leave it alone. */
+      if (TYPE_CODE (utype) != TYPE_CODE_UNDEF)
+       {
+         complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
+         return;
+       }
+    }
+
+  /* Create the string type using the blank type we either found or created. */
+  utype = create_string_type (utype, rangetype);
+}
+
+/*
+

 LOCAL FUNCTION
 
        read_subroutine_type -- process TAG_subroutine_type dies
 LOCAL FUNCTION
 
        read_subroutine_type -- process TAG_subroutine_type dies


@@ -1570,7 +1617,6 @@ read_subroutine_type (dip, thisdie, enddie)
       /* We have an existing partially constructed type, so bash it
         into the correct type. */
       TYPE_TARGET_TYPE (ftype) = type;
       /* We have an existing partially constructed type, so bash it
         into the correct type. */
       TYPE_TARGET_TYPE (ftype) = type;

-      TYPE_FUNCTION_TYPE (type) = ftype;

       TYPE_LENGTH (ftype) = 1;
       TYPE_CODE (ftype) = TYPE_CODE_FUNC;
     }
       TYPE_LENGTH (ftype) = 1;
       TYPE_CODE (ftype) = TYPE_CODE_FUNC;
     }


@@ -1675,6 +1721,7 @@ enum_type (dip, objfile)
   unsigned short blocksz;
   struct symbol *sym;
   int nbytes;
   unsigned short blocksz;
   struct symbol *sym;
   int nbytes;

+  int unsigned_enum = 1;

   
   if ((type = lookup_utype (dip -> die_ref)) == NULL)
     {
   
   if ((type = lookup_utype (dip -> die_ref)) == NULL)
     {


@@ -1689,8 +1736,8 @@ enum_type (dip, objfile)
       && *dip -> at_name != '~'
       && *dip -> at_name != '.')
     {
       && *dip -> at_name != '~'
       && *dip -> at_name != '.')
     {

-      TYPE_NAME (type) = obconcat (&objfile -> type_obstack, "enum",
-                                  " ", dip -> at_name);
+      TYPE_TAG_NAME (type) = obconcat (&objfile -> type_obstack,
+                                      "", "", dip -> at_name);

     }
   if (dip -> at_byte_size != 0)
     {
     }
   if (dip -> at_byte_size != 0)
     {


@@ -1730,10 +1777,13 @@ enum_type (dip, objfile)
          memset (sym, 0, sizeof (struct symbol));
          SYMBOL_NAME (sym) = create_name (list -> field.name,
                                           &objfile->symbol_obstack);
          memset (sym, 0, sizeof (struct symbol));
          SYMBOL_NAME (sym) = create_name (list -> field.name,
                                           &objfile->symbol_obstack);

+         SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);

          SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
          SYMBOL_CLASS (sym) = LOC_CONST;
          SYMBOL_TYPE (sym) = type;
          SYMBOL_VALUE (sym) = list -> field.bitpos;
          SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
          SYMBOL_CLASS (sym) = LOC_CONST;
          SYMBOL_TYPE (sym) = type;
          SYMBOL_VALUE (sym) = list -> field.bitpos;

+         if (SYMBOL_VALUE (sym) < 0)
+           unsigned_enum = 0;

          add_symbol_to_list (sym, list_in_scope);
        }
       /* Now create the vector of fields, and record how big it is. This is
          add_symbol_to_list (sym, list_in_scope);
        }
       /* Now create the vector of fields, and record how big it is. This is


@@ -1743,6 +1793,8 @@ enum_type (dip, objfile)
         vector. */
       if (nfields > 0)
        {
         vector. */
       if (nfields > 0)
        {

+         if (unsigned_enum)
+           TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;

          TYPE_NFIELDS (type) = nfields;
          TYPE_FIELDS (type) = (struct field *)
            obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields);
          TYPE_NFIELDS (type) = nfields;
          TYPE_FIELDS (type) = (struct field *)
            obstack_alloc (&objfile->symbol_obstack, sizeof (struct field) * nfields);


@@ -1786,6 +1838,16 @@ read_func_scope (dip, thisdie, enddie, objfile)
 {
   register struct context_stack *new;
   
 {
   register struct context_stack *new;
   

+  /* AT_name is absent if the function is described with an
+     AT_abstract_origin tag.
+     Ignore the function description for now to avoid GDB core dumps.
+     FIXME: Add code to handle AT_abstract_origin tags properly.  */
+  if (dip -> at_name == NULL)
+    {
+      complain (&missing_at_name, DIE_ID);
+      return;
+    }
+

   if (objfile -> ei.entry_point >= dip -> at_low_pc &&
       objfile -> ei.entry_point <  dip -> at_high_pc)
     {
   if (objfile -> ei.entry_point >= dip -> at_low_pc &&
       objfile -> ei.entry_point <  dip -> at_high_pc)
     {


@@ -1832,9 +1894,7 @@ handle_producer (producer)
 
   processing_gcc_compilation =
     STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER))
 
   processing_gcc_compilation =
     STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER))

-      /* start-sanitize-chill */

       || STREQN (producer, CHILL_PRODUCER, strlen (CHILL_PRODUCER))
       || STREQN (producer, CHILL_PRODUCER, strlen (CHILL_PRODUCER))

-      /* end-sanitize-chill */

       || STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER));
 
   /* Select a demangling style if we can identify the producer and if
       || STREQN (producer, GCC_PRODUCER, strlen (GCC_PRODUCER));
 
   /* Select a demangling style if we can identify the producer and if


@@ -1842,7 +1902,6 @@ handle_producer (producer)
      is not auto.  We also leave the demangling style alone if we find a
      gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
 
      is not auto.  We also leave the demangling style alone if we find a
      gcc (cc1) producer, as opposed to a g++ (cc1plus) producer. */
 

-#if 1 /* Works, but is experimental.  -fnf */

   if (AUTO_DEMANGLING)
     {
       if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))
   if (AUTO_DEMANGLING)
     {
       if (STREQN (producer, GPLUS_PRODUCER, strlen (GPLUS_PRODUCER)))


@@ -1853,12 +1912,7 @@ handle_producer (producer)
        {
          set_demangling_style (LUCID_DEMANGLING_STYLE_STRING);
        }
        {
          set_demangling_style (LUCID_DEMANGLING_STYLE_STRING);
        }

-      else if (STREQN (producer, CFRONT_PRODUCER, strlen (CFRONT_PRODUCER)))
-       {
-         set_demangling_style (CFRONT_DEMANGLING_STYLE_STRING);
-       }

     }
     }

-#endif

 }
 
 
 }
 
 


@@ -1907,20 +1961,19 @@ read_file_scope (dip, thisdie, enddie, objfile)
     }
   numutypes = (enddie - thisdie) / 4;
   utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));
     }
   numutypes = (enddie - thisdie) / 4;
   utypes = (struct type **) xmalloc (numutypes * sizeof (struct type *));

-  back_to = make_cleanup (free, utypes);
+  back_to = make_cleanup (free_utypes, NULL);

   memset (utypes, 0, numutypes * sizeof (struct type *));
   memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
   start_symtab (dip -> at_name, dip -> at_comp_dir, dip -> at_low_pc);
   decode_line_numbers (lnbase);
   process_dies (thisdie + dip -> die_length, enddie, objfile);
   memset (utypes, 0, numutypes * sizeof (struct type *));
   memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
   start_symtab (dip -> at_name, dip -> at_comp_dir, dip -> at_low_pc);
   decode_line_numbers (lnbase);
   process_dies (thisdie + dip -> die_length, enddie, objfile);

-  symtab = end_symtab (dip -> at_high_pc, 0, 0, objfile);
+
+  symtab = end_symtab (dip -> at_high_pc, objfile, 0);

   if (symtab != NULL)
     {
       symtab -> language = cu_language;
     }      
   do_cleanups (back_to);
   if (symtab != NULL)
     {
       symtab -> language = cu_language;
     }      
   do_cleanups (back_to);

-  utypes = NULL;
-  numutypes = 0;

 }
 
 /*
 }
 
 /*


@@ -1971,10 +2024,21 @@ process_dies (thisdie, enddie, objfile)
            {
              nextdie = thisdie + di.die_length;
            }
            {
              nextdie = thisdie + di.die_length;
            }

+#ifdef SMASH_TEXT_ADDRESS
+         /* I think that these are always text, not data, addresses.  */
+         SMASH_TEXT_ADDRESS (di.at_low_pc);
+         SMASH_TEXT_ADDRESS (di.at_high_pc);
+#endif

          switch (di.die_tag)
            {
            case TAG_compile_unit:
          switch (di.die_tag)
            {
            case TAG_compile_unit:

-             read_file_scope (&di, thisdie, nextdie, objfile);
+             /* Skip Tag_compile_unit if we are already inside a compilation
+                unit, we are unable to handle nested compilation units
+                properly (FIXME).  */
+             if (current_subfile == NULL)
+               read_file_scope (&di, thisdie, nextdie, objfile);
+             else
+               nextdie = thisdie + di.die_length;

              break;
            case TAG_global_subroutine:
            case TAG_subroutine:
              break;
            case TAG_global_subroutine:
            case TAG_subroutine:


@@ -2003,6 +2067,9 @@ process_dies (thisdie, enddie, objfile)
            case TAG_pointer_type:
              read_tag_pointer_type (&di);
              break;
            case TAG_pointer_type:
              read_tag_pointer_type (&di);
              break;

+           case TAG_string_type:
+             read_tag_string_type (&di);
+             break;

            default:
              new_symbol (&di, objfile);
              break;
            default:
              new_symbol (&di, objfile);
              break;


@@ -2125,6 +2192,9 @@ DESCRIPTION
 
        Given pointer to a string of bytes that define a location, compute
        the location and return the value.
 
        Given pointer to a string of bytes that define a location, compute
        the location and return the value.

+       A location description containing no atoms indicates that the
+       object is optimized out. The global optimized_out flag is set for
+       those, the return value is meaningless.

 
        When computing values involving the current value of the frame pointer,
        the value zero is used, which results in a value relative to the frame
 
        When computing values involving the current value of the frame pointer,
        the value zero is used, which results in a value relative to the frame


@@ -2152,7 +2222,6 @@ locval (loc)
   auto long stack[64];
   int stacki;
   char *end;
   auto long stack[64];
   int stacki;
   char *end;

-  long regno;

   int loc_atom_code;
   int loc_value_size;
   
   int loc_atom_code;
   int loc_value_size;
   


@@ -2164,9 +2233,11 @@ locval (loc)
   stack[stacki] = 0;
   isreg = 0;
   offreg = 0;
   stack[stacki] = 0;
   isreg = 0;
   offreg = 0;

+  optimized_out = 1;

   loc_value_size = TARGET_FT_LONG_SIZE (current_objfile);
   while (loc < end)
     {
   loc_value_size = TARGET_FT_LONG_SIZE (current_objfile);
   while (loc < end)
     {

+      optimized_out = 0;

       loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED,
                                      current_objfile);
       loc += SIZEOF_LOC_ATOM_CODE;
       loc_atom_code = target_to_host (loc, SIZEOF_LOC_ATOM_CODE, GET_UNSIGNED,
                                      current_objfile);
       loc += SIZEOF_LOC_ATOM_CODE;


@@ -2178,28 +2249,22 @@ locval (loc)
            break;
          case OP_REG:
            /* push register (number) */
            break;
          case OP_REG:
            /* push register (number) */

-           stack[++stacki] = target_to_host (loc, loc_value_size,
-                                             GET_UNSIGNED, current_objfile);
+           stack[++stacki]
+             = DWARF_REG_TO_REGNUM (target_to_host (loc, loc_value_size,
+                                                    GET_UNSIGNED,
+                                                    current_objfile));

            loc += loc_value_size;
            isreg = 1;
            break;
          case OP_BASEREG:
            /* push value of register (number) */
            loc += loc_value_size;
            isreg = 1;
            break;
          case OP_BASEREG:
            /* push value of register (number) */

-           /* Actually, we compute the value as if register has 0 */
+           /* Actually, we compute the value as if register has 0, so the
+              value ends up being the offset from that register.  */

            offreg = 1;
            offreg = 1;

-           regno = target_to_host (loc, loc_value_size, GET_UNSIGNED,
-                                   current_objfile);
+           basereg = target_to_host (loc, loc_value_size, GET_UNSIGNED,
+                                     current_objfile);

            loc += loc_value_size;
            loc += loc_value_size;

-           if (regno == R_FP)
-             {
-               stack[++stacki] = 0;
-             }
-           else
-             {
-               stack[++stacki] = 0;
-
-               complain (&basereg_not_handled, DIE_ID, DIE_NAME, regno);
-             }
+           stack[++stacki] = 0;

            break;
          case OP_ADDR:
            /* push address (relocated address) */
            break;
          case OP_ADDR:
            /* push address (relocated address) */


@@ -2237,19 +2302,18 @@ LOCAL FUNCTION
 
 SYNOPSIS
 
 
 SYNOPSIS
 

-       static struct symtab *read_ofile_symtab (struct partial_symtab *pst)
+       static void read_ofile_symtab (struct partial_symtab *pst)

 
 DESCRIPTION
 
        When expanding a partial symbol table entry to a full symbol table
        entry, this is the function that gets called to read in the symbols
 
 DESCRIPTION
 
        When expanding a partial symbol table entry to a full symbol table
        entry, this is the function that gets called to read in the symbols

-       for the compilation unit.
-
-       Returns a pointer to the newly constructed symtab (which is now
-       the new first one on the objfile's symtab list).
+       for the compilation unit.  A pointer to the newly constructed symtab,
+       which is now the new first one on the objfile's symtab list, is
+       stashed in the partial symbol table entry.

  */
 
  */
 

-static struct symtab *
+static void

 read_ofile_symtab (pst)
      struct partial_symtab *pst;
 {
 read_ofile_symtab (pst)
      struct partial_symtab *pst;
 {


@@ -2272,7 +2336,7 @@ read_ofile_symtab (pst)
   foffset = DBFOFF(pst) + dbroff;
   base_section_offsets = pst->section_offsets;
   baseaddr = ANOFFSET (pst->section_offsets, 0);
   foffset = DBFOFF(pst) + dbroff;
   base_section_offsets = pst->section_offsets;
   baseaddr = ANOFFSET (pst->section_offsets, 0);

-  if (bfd_seek (abfd, foffset, L_SET) ||
+  if (bfd_seek (abfd, foffset, SEEK_SET) ||

       (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
     {
       free (dbbase);
       (bfd_read (dbbase, dbsize, 1, abfd) != dbsize))
     {
       free (dbbase);


@@ -2288,7 +2352,7 @@ read_ofile_symtab (pst)
   lnbase = NULL;
   if (LNFOFF (pst))
     {
   lnbase = NULL;
   if (LNFOFF (pst))
     {

-      if (bfd_seek (abfd, LNFOFF (pst), L_SET) ||
+      if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||

          (bfd_read ((PTR) lnsizedata, sizeof (lnsizedata), 1, abfd) !=
           sizeof (lnsizedata)))
        {
          (bfd_read ((PTR) lnsizedata, sizeof (lnsizedata), 1, abfd) !=
           sizeof (lnsizedata)))
        {


@@ -2297,7 +2361,7 @@ read_ofile_symtab (pst)
       lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH,
                               GET_UNSIGNED, pst -> objfile);
       lnbase = xmalloc (lnsize);
       lnsize = target_to_host (lnsizedata, SIZEOF_LINETBL_LENGTH,
                               GET_UNSIGNED, pst -> objfile);
       lnbase = xmalloc (lnsize);

-      if (bfd_seek (abfd, LNFOFF (pst), L_SET) ||
+      if (bfd_seek (abfd, LNFOFF (pst), SEEK_SET) ||

          (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
        {
          free (lnbase);
          (bfd_read (lnbase, lnsize, 1, abfd) != lnsize))
        {
          free (lnbase);


@@ -2309,7 +2373,7 @@ read_ofile_symtab (pst)
   process_dies (dbbase, dbbase + dbsize, pst -> objfile);
   do_cleanups (back_to);
   current_objfile = NULL;
   process_dies (dbbase, dbbase + dbsize, pst -> objfile);
   do_cleanups (back_to);
   current_objfile = NULL;

-  return (pst -> objfile -> symtabs);
+  pst -> symtab = pst -> objfile -> symtabs;

 }
 
 /*
 }
 
 /*


@@ -2353,14 +2417,14 @@ psymtab_to_symtab_1 (pst)
                  /* Inform about additional files that need to be read in. */
                  if (info_verbose)
                    {
                  /* Inform about additional files that need to be read in. */
                  if (info_verbose)
                    {

-                     fputs_filtered (" ", stdout);
+                     fputs_filtered (" ", gdb_stdout);

                      wrap_here ("");
                      wrap_here ("");

-                     fputs_filtered ("and ", stdout);
+                     fputs_filtered ("and ", gdb_stdout);

                      wrap_here ("");
                      printf_filtered ("%s...",
                                       pst -> dependencies[i] -> filename);
                      wrap_here ("");
                      wrap_here ("");
                      printf_filtered ("%s...",
                                       pst -> dependencies[i] -> filename);
                      wrap_here ("");

-                     fflush (stdout);          /* Flush output */
+                     gdb_flush (gdb_stdout);           /* Flush output */

                    }
                  psymtab_to_symtab_1 (pst -> dependencies[i]);
                }
                    }
                  psymtab_to_symtab_1 (pst -> dependencies[i]);
                }


@@ -2369,12 +2433,12 @@ psymtab_to_symtab_1 (pst)
            {
              buildsym_init ();
              old_chain = make_cleanup (really_free_pendings, 0);
            {
              buildsym_init ();
              old_chain = make_cleanup (really_free_pendings, 0);

-             pst -> symtab = read_ofile_symtab (pst);
+             read_ofile_symtab (pst);

              if (info_verbose)
                {
                  printf_filtered ("%d DIE's, sorting...", diecount);
                  wrap_here ("");
              if (info_verbose)
                {
                  printf_filtered ("%d DIE's, sorting...", diecount);
                  wrap_here ("");

-                 fflush (stdout);
+                 gdb_flush (gdb_stdout);

                }
              sort_symtab_syms (pst -> symtab);
              do_cleanups (old_chain);
                }
              sort_symtab_syms (pst -> symtab);
              do_cleanups (old_chain);


@@ -2424,7 +2488,7 @@ dwarf_psymtab_to_symtab (pst)
                {
                  printf_filtered ("Reading in symbols for %s...",
                                   pst -> filename);
                {
                  printf_filtered ("Reading in symbols for %s...",
                                   pst -> filename);

-                 fflush (stdout);
+                 gdb_flush (gdb_stdout);

                }
              
              psymtab_to_symtab_1 (pst);
                }
              
              psymtab_to_symtab_1 (pst);


@@ -2442,7 +2506,7 @@ dwarf_psymtab_to_symtab (pst)
              if (info_verbose)
                {
                  printf_filtered ("done.\n");
              if (info_verbose)
                {
                  printf_filtered ("done.\n");

-                 fflush (stdout);
+                 gdb_flush (gdb_stdout);

                }
            }
        }
                }
            }
        }


@@ -2451,54 +2515,6 @@ dwarf_psymtab_to_symtab (pst)
 
 /*
 
 
 /*
 

-LOCAL FUNCTION
-
-       init_psymbol_list -- initialize storage for partial symbols
-
-SYNOPSIS
-
-       static void init_psymbol_list (struct objfile *objfile, int total_symbols)
-
-DESCRIPTION
-
-       Initializes storage for all of the partial symbols that will be
-       created by dwarf_build_psymtabs and subsidiaries.
- */
-
-static void
-init_psymbol_list (objfile, total_symbols)
-     struct objfile *objfile;
-     int total_symbols;
-{
-  /* Free any previously allocated psymbol lists.  */
-  
-  if (objfile -> global_psymbols.list)
-    {
-      mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
-    }
-  if (objfile -> static_psymbols.list)
-    {
-      mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
-    }
-  
-  /* Current best guess is that there are approximately a twentieth
-     of the total symbols (in a debugging file) are global or static
-     oriented symbols */
-  
-  objfile -> global_psymbols.size = total_symbols / 10;
-  objfile -> static_psymbols.size = total_symbols / 10;
-  objfile -> global_psymbols.next =
-    objfile -> global_psymbols.list = (struct partial_symbol *)
-      xmmalloc (objfile -> md, objfile -> global_psymbols.size
-                            * sizeof (struct partial_symbol));
-  objfile -> static_psymbols.next =
-    objfile -> static_psymbols.list = (struct partial_symbol *)
-      xmmalloc (objfile -> md, objfile -> static_psymbols.size
-                            * sizeof (struct partial_symbol));
-}
-
-/*
-

 LOCAL FUNCTION
 
        add_enum_psymbol -- add enumeration members to partial symbol table
 LOCAL FUNCTION
 
        add_enum_psymbol -- add enumeration members to partial symbol table


@@ -2536,8 +2552,9 @@ add_enum_psymbol (dip, objfile)
       while (scan < listend)
        {
          scan += TARGET_FT_LONG_SIZE (objfile);
       while (scan < listend)
        {
          scan += TARGET_FT_LONG_SIZE (objfile);

-         ADD_PSYMBOL_TO_LIST (scan, strlen (scan), VAR_NAMESPACE, LOC_CONST,
-                              objfile -> static_psymbols, 0);
+         add_psymbol_to_list (scan, strlen (scan), VAR_NAMESPACE, LOC_CONST,
+                              &objfile -> static_psymbols, 0, 0, cu_language,
+                              objfile);

          scan += strlen (scan) + 1;
        }
     }
          scan += strlen (scan) + 1;
        }
     }


@@ -2568,54 +2585,53 @@ add_partial_symbol (dip, objfile)
   switch (dip -> die_tag)
     {
     case TAG_global_subroutine:
   switch (dip -> die_tag)
     {
     case TAG_global_subroutine:

-      record_minimal_symbol (dip -> at_name, dip -> at_low_pc, mst_text,
-                           objfile);
-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
-                          VAR_NAMESPACE, LOC_BLOCK,
-                          objfile -> global_psymbols,
-                          dip -> at_low_pc);
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),
+                               VAR_NAMESPACE, LOC_BLOCK,
+                               &objfile -> global_psymbols,
+                               0, dip -> at_low_pc, cu_language, objfile);

       break;
     case TAG_global_variable:
       break;
     case TAG_global_variable:

-      record_minimal_symbol (dip -> at_name, locval (dip -> at_location),
-                           mst_data, objfile);
-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),

                           VAR_NAMESPACE, LOC_STATIC,
                           VAR_NAMESPACE, LOC_STATIC,

-                          objfile -> global_psymbols,
-                          0);
+                          &objfile -> global_psymbols,
+                          0, 0, cu_language, objfile);

       break;
     case TAG_subroutine:
       break;
     case TAG_subroutine:

-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
-                          VAR_NAMESPACE, LOC_BLOCK,
-                          objfile -> static_psymbols,
-                          dip -> at_low_pc);
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),
+                               VAR_NAMESPACE, LOC_BLOCK,
+                               &objfile -> static_psymbols,
+                               0, dip -> at_low_pc, cu_language, objfile);

       break;
     case TAG_local_variable:
       break;
     case TAG_local_variable:

-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),

                           VAR_NAMESPACE, LOC_STATIC,
                           VAR_NAMESPACE, LOC_STATIC,

-                          objfile -> static_psymbols,
-                          0);
+                          &objfile -> static_psymbols,
+                          0, 0, cu_language, objfile);

       break;
     case TAG_typedef:
       break;
     case TAG_typedef:

-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),

                           VAR_NAMESPACE, LOC_TYPEDEF,
                           VAR_NAMESPACE, LOC_TYPEDEF,

-                          objfile -> static_psymbols,
-                          0);
+                          &objfile -> static_psymbols,
+                          0, 0, cu_language, objfile);

       break;
     case TAG_class_type:
     case TAG_structure_type:
     case TAG_union_type:
     case TAG_enumeration_type:
       break;
     case TAG_class_type:
     case TAG_structure_type:
     case TAG_union_type:
     case TAG_enumeration_type:

-      ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
+      /* Do not add opaque aggregate definitions to the psymtab.  */
+      if (!dip -> has_at_byte_size)
+       break;
+      add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),

                           STRUCT_NAMESPACE, LOC_TYPEDEF,
                           STRUCT_NAMESPACE, LOC_TYPEDEF,

-                          objfile -> static_psymbols,
-                          0);
+                          &objfile -> static_psymbols,
+                          0, 0, cu_language, objfile);

       if (cu_language == language_cplus)
        {
          /* For C++, these implicitly act as typedefs as well. */
       if (cu_language == language_cplus)
        {
          /* For C++, these implicitly act as typedefs as well. */

-         ADD_PSYMBOL_TO_LIST (dip -> at_name, strlen (dip -> at_name),
+         add_psymbol_to_list (dip -> at_name, strlen (dip -> at_name),

                               VAR_NAMESPACE, LOC_TYPEDEF,
                               VAR_NAMESPACE, LOC_TYPEDEF,

-                              objfile -> static_psymbols,
-                              0);
+                              &objfile -> static_psymbols,
+                              0, 0, cu_language, objfile);

        }
       break;
     }
        }
       break;
     }


@@ -2915,6 +2931,7 @@ new_symbol (dip, objfile)
     {
       sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack,
                                             sizeof (struct symbol));
     {
       sym = (struct symbol *) obstack_alloc (&objfile -> symbol_obstack,
                                             sizeof (struct symbol));

+      OBJSTAT (objfile, n_syms++);

       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_NAME (sym) = create_name (dip -> at_name,
                                       &objfile->symbol_obstack);
       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_NAME (sym) = create_name (dip -> at_name,
                                       &objfile->symbol_obstack);


@@ -2922,16 +2939,26 @@ new_symbol (dip, objfile)
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_TYPE (sym) = decode_die_type (dip);
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       SYMBOL_CLASS (sym) = LOC_STATIC;
       SYMBOL_TYPE (sym) = decode_die_type (dip);

+
+      /* If this symbol is from a C++ compilation, then attempt to cache the
+        demangled form for future reference.  This is a typical time versus
+        space tradeoff, that was decided in favor of time because it sped up
+        C++ symbol lookups by a factor of about 20. */
+
+      SYMBOL_LANGUAGE (sym) = cu_language;
+      SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile -> symbol_obstack);

       switch (dip -> die_tag)
        {
        case TAG_label:
       switch (dip -> die_tag)
        {
        case TAG_label:

-         SYMBOL_VALUE (sym) = dip -> at_low_pc;
+         SYMBOL_VALUE_ADDRESS (sym) = dip -> at_low_pc;

          SYMBOL_CLASS (sym) = LOC_LABEL;
          break;
        case TAG_global_subroutine:
        case TAG_subroutine:
          SYMBOL_CLASS (sym) = LOC_LABEL;
          break;
        case TAG_global_subroutine:
        case TAG_subroutine:

-         SYMBOL_VALUE (sym) = dip -> at_low_pc;
+         SYMBOL_VALUE_ADDRESS (sym) = dip -> at_low_pc;

          SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
          SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));

+         if (dip -> at_prototyped)
+           TYPE_FLAGS (SYMBOL_TYPE (sym)) |= TYPE_FLAG_PROTOTYPED;

          SYMBOL_CLASS (sym) = LOC_BLOCK;
          if (dip -> die_tag == TAG_global_subroutine)
            {
          SYMBOL_CLASS (sym) = LOC_BLOCK;
          if (dip -> die_tag == TAG_global_subroutine)
            {


@@ -2956,13 +2983,18 @@ new_symbol (dip, objfile)
            {
              SYMBOL_VALUE (sym) = locval (dip -> at_location);
              add_symbol_to_list (sym, list_in_scope);
            {
              SYMBOL_VALUE (sym) = locval (dip -> at_location);
              add_symbol_to_list (sym, list_in_scope);

-             if (isreg)
+             if (optimized_out)
+               {
+                 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
+               }
+             else if (isreg)

                {
                  SYMBOL_CLASS (sym) = LOC_REGISTER;
                }
              else if (offreg)
                {
                {
                  SYMBOL_CLASS (sym) = LOC_REGISTER;
                }
              else if (offreg)
                {

-                 SYMBOL_CLASS (sym) = LOC_LOCAL;
+                 SYMBOL_CLASS (sym) = LOC_BASEREG;
+                 SYMBOL_BASEREG (sym) = basereg;

                }
              else
                {
                }
              else
                {


@@ -2981,6 +3013,11 @@ new_symbol (dip, objfile)
            {
              SYMBOL_CLASS (sym) = LOC_REGPARM;
            }
            {
              SYMBOL_CLASS (sym) = LOC_REGPARM;
            }

+         else if (offreg)
+           {
+             SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
+             SYMBOL_BASEREG (sym) = basereg;
+           }

          else
            {
              SYMBOL_CLASS (sym) = LOC_ARG;
          else
            {
              SYMBOL_CLASS (sym) = LOC_ARG;


@@ -3047,9 +3084,11 @@ synthesize_typedef (dip, objfile, type)
     {
       sym = (struct symbol *)
        obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));
     {
       sym = (struct symbol *)
        obstack_alloc (&objfile -> symbol_obstack, sizeof (struct symbol));

+      OBJSTAT (objfile, n_syms++);

       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_NAME (sym) = create_name (dip -> at_name,
                                       &objfile->symbol_obstack);
       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_NAME (sym) = create_name (dip -> at_name,
                                       &objfile->symbol_obstack);

+      SYMBOL_INIT_LANGUAGE_SPECIFIC (sym, cu_language);

       SYMBOL_TYPE (sym) = type;
       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
       SYMBOL_TYPE (sym) = type;
       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
       SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;


@@ -3753,16 +3792,18 @@ NOTES
        use it as signed data, then we need to explicitly sign extend the
        result until the bfd library is able to do this for us.
 
        use it as signed data, then we need to explicitly sign extend the
        result until the bfd library is able to do this for us.
 

+       FIXME: Would a 32 bit target ever need an 8 byte result?
+

  */
 
  */
 

-static unsigned long
+static CORE_ADDR

 target_to_host (from, nbytes, signextend, objfile)
      char *from;
      int nbytes;
      int signextend;           /* FIXME:  Unused */
      struct objfile *objfile;
 {
 target_to_host (from, nbytes, signextend, objfile)
      char *from;
      int nbytes;
      int signextend;           /* FIXME:  Unused */
      struct objfile *objfile;
 {

-  unsigned long rtnval;
+  CORE_ADDR rtnval;

 
   switch (nbytes)
     {
 
   switch (nbytes)
     {