Subversion Repositories or1k

/* Read hp debug symbols and convert to internal format, for GDB.

   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001

   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.

   Written by the Center for Software Science at the University of Utah

   and by Cygnus Support.  */

#include "defs.h"

#include "bfd.h"

#include "gdb_string.h"

#include "hp-symtab.h"

#include "syms.h"

#include "symtab.h"

#include "symfile.h"

#include "objfiles.h"

#include "buildsym.h"

#include "complaints.h"

#include "gdb-stabs.h"

#include "gdbtypes.h"

#include "demangle.h"

/* Private information attached to an objfile which we use to find

   and internalize the HP C debug symbols within that objfile.  */

struct hpread_symfile_info

  {

    /* The contents of each of the debug sections (there are 4 of them).  */

    char *gntt;

    char *lntt;

    char *slt;

    char *vt;

    /* We keep the size of the $VT$ section for range checking.  */

    unsigned int vt_size;

    /* Some routines still need to know the number of symbols in the

       main debug sections ($LNTT$ and $GNTT$). */

    unsigned int lntt_symcount;

    unsigned int gntt_symcount;

    /* To keep track of all the types we've processed.  */

    struct type **type_vector;

    int type_vector_length;

    /* Keeps track of the beginning of a range of source lines.  */

    sltpointer sl_index;

    /* Some state variables we'll need.  */

    int within_function;

    /* Keep track of the current function's address.  We may need to look

       up something based on this address.  */

    unsigned int current_function_value;

  };

/* Accessor macros to get at the fields.  */

#define HPUX_SYMFILE_INFO(o) \

  ((struct hpread_symfile_info *)((o)->sym_private))

#define GNTT(o)                 (HPUX_SYMFILE_INFO(o)->gntt)

#define LNTT(o)                 (HPUX_SYMFILE_INFO(o)->lntt)

#define SLT(o)                  (HPUX_SYMFILE_INFO(o)->slt)

#define VT(o)                   (HPUX_SYMFILE_INFO(o)->vt)

#define VT_SIZE(o)              (HPUX_SYMFILE_INFO(o)->vt_size)

#define LNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->lntt_symcount)

#define GNTT_SYMCOUNT(o)        (HPUX_SYMFILE_INFO(o)->gntt_symcount)

#define TYPE_VECTOR(o)          (HPUX_SYMFILE_INFO(o)->type_vector)

#define TYPE_VECTOR_LENGTH(o)   (HPUX_SYMFILE_INFO(o)->type_vector_length)

#define SL_INDEX(o)             (HPUX_SYMFILE_INFO(o)->sl_index)

#define WITHIN_FUNCTION(o)      (HPUX_SYMFILE_INFO(o)->within_function)

#define CURRENT_FUNCTION_VALUE(o) (HPUX_SYMFILE_INFO(o)->current_function_value)

/* Given the native debug symbol SYM, set NAMEP to the name associated

   with the debug symbol.  Note we may be called with a debug symbol which

   has no associated name, in that case we return an empty string.

   Also note we "know" that the name for any symbol is always in the

   same place.  Hence we don't have to conditionalize on the symbol type.  */

#define SET_NAMESTRING(SYM, NAMEP, OBJFILE) \

  if (! hpread_has_name ((SYM)->dblock.kind)) \

    *NAMEP = ""; \

  else if (((unsigned)(SYM)->dsfile.name) >= VT_SIZE (OBJFILE)) \

    { \

      complain (&string_table_offset_complaint, (char *) symnum); \

      *NAMEP = ""; \

    } \

  else \

    *NAMEP = (SYM)->dsfile.name + VT (OBJFILE)

/* We put a pointer to this structure in the read_symtab_private field

   of the psymtab.  */

struct symloc

  {

    /* The offset within the file symbol table of first local symbol for

       this file.  */

    int ldsymoff;

    /* Length (in bytes) of the section of the symbol table devoted to

       this file's symbols (actually, the section bracketed may contain

       more than just this file's symbols).  If ldsymlen is 0, the only

       reason for this thing's existence is the dependency list.

       Nothing else will happen when it is read in.  */

    int ldsymlen;

  };

#define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)

#define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)

#define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))

/* FIXME: Shouldn't this stuff be in a .h file somewhere?  */

/* Nonzero means give verbose info on gdb action.  */

extern int info_verbose;

/* Complaints about the symbols we have encountered.  */

extern struct complaint string_table_offset_complaint;

extern struct complaint lbrac_unmatched_complaint;

extern struct complaint lbrac_mismatch_complaint;

void hpread_symfile_init (struct objfile *);

static struct type *hpread_read_array_type (dnttpointer, union dnttentry *,

                                            struct objfile *);

static struct type *hpread_alloc_type (dnttpointer, struct objfile *);

static struct type **hpread_lookup_type (dnttpointer, struct objfile *);

static struct type *hpread_read_enum_type

  (dnttpointer, union dnttentry *, struct objfile *);

static struct type *hpread_read_set_type

  (dnttpointer, union dnttentry *, struct objfile *);

static struct type *hpread_read_subrange_type

  (dnttpointer, union dnttentry *, struct objfile *);

static struct type *hpread_read_struct_type

  (dnttpointer, union dnttentry *, struct objfile *);

void hpread_build_psymtabs (struct objfile *, int);

void hpread_symfile_finish (struct objfile *);

static struct partial_symtab *hpread_start_psymtab

  (struct objfile *, char *, CORE_ADDR, int,

   struct partial_symbol **, struct partial_symbol **);

static struct partial_symtab *hpread_end_psymtab

  (struct partial_symtab *, char **, int, int, CORE_ADDR,

   struct partial_symtab **, int);

static struct symtab *hpread_expand_symtab

  (struct objfile *, int, int, CORE_ADDR, int,

   struct section_offsets *, char *);

static void hpread_process_one_debug_symbol

  (union dnttentry *, char *, struct section_offsets *,

   struct objfile *, CORE_ADDR, int, char *, int);

static sltpointer hpread_record_lines

  (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);

static struct type *hpread_read_function_type

  (dnttpointer, union dnttentry *, struct objfile *);

static struct type *hpread_type_lookup (dnttpointer, struct objfile *);

static unsigned long hpread_get_depth (sltpointer, struct objfile *);

static unsigned long hpread_get_line (sltpointer, struct objfile *);

static CORE_ADDR hpread_get_location (sltpointer, struct objfile *);

static int hpread_type_translate (dnttpointer);

static unsigned long hpread_get_textlow (int, int, struct objfile *);

static union dnttentry *hpread_get_gntt (int, struct objfile *);

static union dnttentry *hpread_get_lntt (int, struct objfile *);

static union sltentry *hpread_get_slt (int, struct objfile *);

static void hpread_psymtab_to_symtab (struct partial_symtab *);

static void hpread_psymtab_to_symtab_1 (struct partial_symtab *);

static int hpread_has_name (enum dntt_entry_type);

/* Initialization for reading native HP C debug symbols from OBJFILE.

   It's only purpose in life is to set up the symbol reader's private

   per-objfile data structures, and read in the raw contents of the debug

   sections (attaching pointers to the debug info into the private data

   structures).

   Since BFD doesn't know how to read debug symbols in a format-independent

   way (and may never do so...), we have to do it ourselves.  Note we may

   be called on a file without native HP C debugging symbols.

   FIXME, there should be a cleaner peephole into the BFD environment here.  */

void

hpread_symfile_init (struct objfile *objfile)

{

  asection *vt_section, *slt_section, *lntt_section, *gntt_section;

  /* Allocate struct to keep track of the symfile */

  objfile->sym_private = (PTR)

    xmmalloc (objfile->md, sizeof (struct hpread_symfile_info));

  memset (objfile->sym_private, 0, sizeof (struct hpread_symfile_info));

  /* We haven't read in any types yet.  */

  TYPE_VECTOR (objfile) = 0;

  /* Read in data from the $GNTT$ subspace.  */

  gntt_section = bfd_get_section_by_name (objfile->obfd, "$GNTT$");

  if (!gntt_section)

    return;

  GNTT (objfile)

    = obstack_alloc (&objfile->symbol_obstack,

                     bfd_section_size (objfile->obfd, gntt_section));

  bfd_get_section_contents (objfile->obfd, gntt_section, GNTT (objfile),

                         0, bfd_section_size (objfile->obfd, gntt_section));

  GNTT_SYMCOUNT (objfile)

    = bfd_section_size (objfile->obfd, gntt_section)

    / sizeof (struct dntt_type_block);

  /* Read in data from the $LNTT$ subspace.   Also keep track of the number

     of LNTT symbols.  */

  lntt_section = bfd_get_section_by_name (objfile->obfd, "$LNTT$");

  if (!lntt_section)

    return;

  LNTT (objfile)

    = obstack_alloc (&objfile->symbol_obstack,

                     bfd_section_size (objfile->obfd, lntt_section));

  bfd_get_section_contents (objfile->obfd, lntt_section, LNTT (objfile),

                         0, bfd_section_size (objfile->obfd, lntt_section));

  LNTT_SYMCOUNT (objfile)

    = bfd_section_size (objfile->obfd, lntt_section)

    / sizeof (struct dntt_type_block);

  /* Read in data from the $SLT$ subspace.  $SLT$ contains information

     on source line numbers.  */

  slt_section = bfd_get_section_by_name (objfile->obfd, "$SLT$");

  if (!slt_section)

    return;

  SLT (objfile) =

    obstack_alloc (&objfile->symbol_obstack,

                   bfd_section_size (objfile->obfd, slt_section));

  bfd_get_section_contents (objfile->obfd, slt_section, SLT (objfile),

                          0, bfd_section_size (objfile->obfd, slt_section));

  /* Read in data from the $VT$ subspace.  $VT$ contains things like

     names and constants.  Keep track of the number of symbols in the VT.  */

  vt_section = bfd_get_section_by_name (objfile->obfd, "$VT$");

  if (!vt_section)

    return;

  VT_SIZE (objfile) = bfd_section_size (objfile->obfd, vt_section);

  VT (objfile) =

    (char *) obstack_alloc (&objfile->symbol_obstack,

                            VT_SIZE (objfile));

  bfd_get_section_contents (objfile->obfd, vt_section, VT (objfile),

                            0, VT_SIZE (objfile));

}

/* Scan and build partial symbols for a symbol file.

   The minimal symbol table (either SOM or HP a.out) has already been

   read in; all we need to do is setup partial symbols based on the

   native debugging information.

   We assume hpread_symfile_init has been called to initialize the

   symbol reader's private data structures.

   MAINLINE is true if we are reading the main symbol

   table (as opposed to a shared lib or dynamically loaded file).  */

void

hpread_build_psymtabs (struct objfile *objfile, int mainline)

{

  char *namestring;

  int past_first_source_file = 0;

  struct cleanup *old_chain;

  int hp_symnum, symcount, i;

  union dnttentry *dn_bufp;

  unsigned long valu;

  char *p;

  int texthigh = 0;

  int have_name = 0;

  /* Current partial symtab */

  struct partial_symtab *pst;

  /* List of current psymtab's include files */

  char **psymtab_include_list;

  int includes_allocated;

  int includes_used;

  /* Index within current psymtab dependency list */

  struct partial_symtab **dependency_list;

  int dependencies_used, dependencies_allocated;

  /* Just in case the stabs reader left turds lying around.  */

  free_pending_blocks ();

  make_cleanup (really_free_pendings, 0);

  pst = (struct partial_symtab *) 0;

  /* We shouldn't use alloca, instead use malloc/free.  Doing so avoids

     a number of problems with cross compilation and creating useless holes

     in the stack when we have to allocate new entries.  FIXME.  */

  includes_allocated = 30;

  includes_used = 0;

  psymtab_include_list = (char **) alloca (includes_allocated *

                                           sizeof (char *));

  dependencies_allocated = 30;

  dependencies_used = 0;

  dependency_list =

    (struct partial_symtab **) alloca (dependencies_allocated *

                                       sizeof (struct partial_symtab *));

  old_chain = make_cleanup_free_objfile (objfile);

  last_source_file = 0;

  /* Make two passes, one ofr the GNTT symbols, the other for the

     LNTT symbols.  */

  for (i = 0; i < 1; i++)

    {

      int within_function = 0;

      if (i)

        symcount = GNTT_SYMCOUNT (objfile);

      else

        symcount = LNTT_SYMCOUNT (objfile);

      for (hp_symnum = 0; hp_symnum < symcount; hp_symnum++)

        {

          QUIT;

          if (i)

            dn_bufp = hpread_get_gntt (hp_symnum, objfile);

          else

            dn_bufp = hpread_get_lntt (hp_symnum, objfile);

          if (dn_bufp->dblock.extension)

            continue;

          /* Only handle things which are necessary for minimal symbols.

             everything else is ignored.  */

          switch (dn_bufp->dblock.kind)

            {

            case DNTT_TYPE_SRCFILE:

              {

                /* A source file of some kind.  Note this may simply

                   be an included file.  */

                SET_NAMESTRING (dn_bufp, &namestring, objfile);

                /* Check if this is the source file we are already working

                   with.  */

                if (pst && !strcmp (namestring, pst->filename))

                  continue;

                /* Check if this is an include file, if so check if we have

                   already seen it.  Add it to the include list */

                p = strrchr (namestring, '.');

                if (!strcmp (p, ".h"))

                  {

                    int j, found;

                    found = 0;

                    for (j = 0; j < includes_used; j++)

                      if (!strcmp (namestring, psymtab_include_list[j]))

                        {

                          found = 1;

                          break;

                        }

                    if (found)

                      continue;

                    /* Add it to the list of includes seen so far and

                       allocate more include space if necessary.  */

                    psymtab_include_list[includes_used++] = namestring;

                    if (includes_used >= includes_allocated)

                      {

                        char **orig = psymtab_include_list;

                        psymtab_include_list = (char **)

                          alloca ((includes_allocated *= 2) *

                                  sizeof (char *));

                        memcpy ((PTR) psymtab_include_list, (PTR) orig,

                                includes_used * sizeof (char *));

                      }

                    continue;

                  }

                if (pst)

                  {

                    if (!have_name)

                      {

                        pst->filename = (char *)

                          obstack_alloc (&pst->objfile->psymbol_obstack,

                                         strlen (namestring) + 1);

                        strcpy (pst->filename, namestring);

                        have_name = 1;

                        continue;

                      }

                    continue;

                  }

                /* This is a bonafide new source file.

                   End the current partial symtab and start a new one.  */

                if (pst && past_first_source_file)

                  {

                    hpread_end_psymtab (pst, psymtab_include_list,

                                        includes_used,

                                        (hp_symnum

                                         * sizeof (struct dntt_type_block)),

                                        texthigh,

                                        dependency_list, dependencies_used);

                    pst = (struct partial_symtab *) 0;

                    includes_used = 0;

                    dependencies_used = 0;

                  }

                else

                  past_first_source_file = 1;

                valu = hpread_get_textlow (i, hp_symnum, objfile);

                valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));

                pst = hpread_start_psymtab (objfile,

                                            namestring, valu,

                                            (hp_symnum

                                         * sizeof (struct dntt_type_block)),

                                            objfile->global_psymbols.next,

                                            objfile->static_psymbols.next);

                texthigh = valu;

                have_name = 1;

                continue;

              }

            case DNTT_TYPE_MODULE:

              /* A source file.  It's still unclear to me what the

                 real difference between a DNTT_TYPE_SRCFILE and DNTT_TYPE_MODULE

                 is supposed to be.  */

              SET_NAMESTRING (dn_bufp, &namestring, objfile);

              valu = hpread_get_textlow (i, hp_symnum, objfile);

              valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));

              if (!pst)

                {

                  pst = hpread_start_psymtab (objfile,

                                              namestring, valu,

                                              (hp_symnum

                                         * sizeof (struct dntt_type_block)),

                                              objfile->global_psymbols.next,

                                              objfile->static_psymbols.next);

                  texthigh = valu;

                  have_name = 0;

                }

              continue;

            case DNTT_TYPE_FUNCTION:

            case DNTT_TYPE_ENTRY:

              /* The beginning of a function.  DNTT_TYPE_ENTRY may also denote

                 a secondary entry point.  */

              valu = dn_bufp->dfunc.hiaddr + ANOFFSET (objfile->section_offsets,

                                                       SECT_OFF_TEXT (objfile));

              if (valu > texthigh)

                texthigh = valu;

              valu = dn_bufp->dfunc.lowaddr +

                ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));

              SET_NAMESTRING (dn_bufp, &namestring, objfile);

              add_psymbol_to_list (namestring, strlen (namestring),

                                   VAR_NAMESPACE, LOC_BLOCK,

                                   &objfile->static_psymbols, valu,

                                   0, language_unknown, objfile);

              within_function = 1;

              continue;

            case DNTT_TYPE_BEGIN:

            case DNTT_TYPE_END:

              /* Scope block begin/end.  We only care about function

                 and file blocks right now.  */

              if (dn_bufp->dend.endkind == DNTT_TYPE_MODULE)

                {

                  hpread_end_psymtab (pst, psymtab_include_list, includes_used,

                                      (hp_symnum

                                       * sizeof (struct dntt_type_block)),

                                      texthigh,

                                      dependency_list, dependencies_used);

                  pst = (struct partial_symtab *) 0;

                  includes_used = 0;

                  dependencies_used = 0;

                  have_name = 0;

                }

              if (dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION)

                within_function = 0;

              continue;

            case DNTT_TYPE_SVAR:

            case DNTT_TYPE_DVAR:

            case DNTT_TYPE_TYPEDEF:

            case DNTT_TYPE_TAGDEF:

              {

                /* Variables, typedefs an the like.  */

                enum address_class storage;

                namespace_enum namespace;

                /* Don't add locals to the partial symbol table.  */

                if (within_function

                    && (dn_bufp->dblock.kind == DNTT_TYPE_SVAR

                        || dn_bufp->dblock.kind == DNTT_TYPE_DVAR))

                  continue;

                /* TAGDEFs go into the structure namespace.  */

                if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF)

                  namespace = STRUCT_NAMESPACE;

                else

                  namespace = VAR_NAMESPACE;

                /* What kind of "storage" does this use?  */

                if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR)

                  storage = LOC_STATIC;

                else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR

                         && dn_bufp->ddvar.regvar)

                  storage = LOC_REGISTER;

                else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR)

                  storage = LOC_LOCAL;

                else

                  storage = LOC_UNDEF;

                SET_NAMESTRING (dn_bufp, &namestring, objfile);

                if (!pst)

                  {

                    pst = hpread_start_psymtab (objfile,

                                                "globals", 0,

                                                (hp_symnum

                                         * sizeof (struct dntt_type_block)),

                                              objfile->global_psymbols.next,

                                             objfile->static_psymbols.next);

                  }

                if (dn_bufp->dsvar.global)

                  {

                    add_psymbol_to_list (namestring, strlen (namestring),

                                         namespace, storage,

                                         &objfile->global_psymbols,

                                         dn_bufp->dsvar.location,

                                         0, language_unknown, objfile);

                  }

                else

                  {

                    add_psymbol_to_list (namestring, strlen (namestring),

                                         namespace, storage,

                                         &objfile->static_psymbols,

                                         dn_bufp->dsvar.location,

                                         0, language_unknown, objfile);

                  }

                continue;

              }

            case DNTT_TYPE_MEMENUM:

            case DNTT_TYPE_CONST:

              /* Constants and members of enumerated types.  */

              SET_NAMESTRING (dn_bufp, &namestring, objfile);

              if (!pst)

                {

                  pst = hpread_start_psymtab (objfile,

                                              "globals", 0,

                                              (hp_symnum

                                         * sizeof (struct dntt_type_block)),

                                              objfile->global_psymbols.next,

                                              objfile->static_psymbols.next);

                }

              add_psymbol_to_list (namestring, strlen (namestring),

                                   VAR_NAMESPACE, LOC_CONST,

                                   &objfile->static_psymbols, 0,

                                   0, language_unknown, objfile);

              continue;

            default:

              continue;

            }

        }

    }

  /* End any pending partial symbol table.  */

  if (pst)

    {

      hpread_end_psymtab (pst, psymtab_include_list, includes_used,

                          hp_symnum * sizeof (struct dntt_type_block),

                          0, dependency_list, dependencies_used);

    }

  discard_cleanups (old_chain);

}

/* Perform any local cleanups required when we are done with a particular

   objfile.  I.E, we are in the process of discarding all symbol information

   for an objfile, freeing up all memory held for it, and unlinking the

   objfile struct from the global list of known objfiles. */

void

hpread_symfile_finish (struct objfile *objfile)

{

  if (objfile->sym_private != NULL)

    {

      mfree (objfile->md, objfile->sym_private);

    }

}

/* The remaining functions are all for internal use only.  */

/* Various small functions to get entries in the debug symbol sections.  */

static union dnttentry *

hpread_get_lntt (int index, struct objfile *objfile)

{

  return (union dnttentry *)

    &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);

}

static union dnttentry *

hpread_get_gntt (int index, struct objfile *objfile)

{

  return (union dnttentry *)

    &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);

}

static union sltentry *

hpread_get_slt (int index, struct objfile *objfile)

{

  return (union sltentry *) &(SLT (objfile)[index * sizeof (union sltentry)]);

}

/* Get the low address associated with some symbol (typically the start

   of a particular source file or module).  Since that information is not

   stored as part of the DNTT_TYPE_MODULE or DNTT_TYPE_SRCFILE symbol we

   must infer it from the existence of DNTT_TYPE_FUNCTION symbols.  */

static unsigned long

hpread_get_textlow (int global, int index, struct objfile *objfile)

{

  union dnttentry *dn_bufp;

  struct minimal_symbol *msymbol;

  /* Look for a DNTT_TYPE_FUNCTION symbol.  */

  do

    {

      if (global)

        dn_bufp = hpread_get_gntt (index++, objfile);

      else

        dn_bufp = hpread_get_lntt (index++, objfile);

    }

  while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION

         && dn_bufp->dblock.kind != DNTT_TYPE_END);

  /* Avoid going past a DNTT_TYPE_END when looking for a DNTT_TYPE_FUNCTION.  This

     might happen when a sourcefile has no functions.  */

  if (dn_bufp->dblock.kind == DNTT_TYPE_END)

    return 0;

  /* The minimal symbols are typically more accurate for some reason.  */

  msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL,

                                   objfile);