/* Read hp debug symbols and convert to internal format, for GDB.
- Copyright 1993 Free Software Foundation, Inc.
+ Copyright 1993, 1996 Free Software Foundation, Inc.
This file is part of GDB.
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.
Written by the Center for Software Science at the University of Utah
and by Cygnus Support. */
#include "defs.h"
#include "bfd.h"
-#include <string.h>
-#include "hpux-symtab.h"
+#include "gdb_string.h"
+#include "hp-symtab.h"
#include "syms.h"
#include "symtab.h"
#include "symfile.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;
+ {
+ /* The contents of each of the debug sections (there are 4 of them). */
+ char *gntt;
+ char *lntt;
+ char *slt;
+ char *vt;
- /* 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;
+ /* We keep the size of the $VT$ section for range checking. */
+ unsigned int vt_size;
- /* To keep track of all the types we've processed. */
- struct type **type_vector;
- int type_vector_length;
+ /* 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;
- /* Keeps track of the beginning of a range of source lines. */
- SLTPOINTER sl_index;
+ /* To keep track of all the types we've processed. */
+ struct type **type_vector;
+ int type_vector_length;
- /* Some state variables we'll need. */
- int within_function;
+ /* Keeps track of the beginning of a range of source lines. */
+ sltpointer sl_index;
- /* Keep track of the current function's address. We may need to look
- up something based on this address. */
- unsigned int current_function_value;
+ /* 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) \
} \
else \
*NAMEP = (SYM)->dsfile.name + VT (OBJFILE)
+\f
+/* We put a pointer to this structure in the read_symtab_private field
+ of the psymtab. */
-/* 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.
+struct symloc
+ {
+ /* The offset within the file symbol table of first local symbol for
+ this file. */
+
+ int ldsymoff;
- For hpuxread this structure contains the offset within the file symbol table
- of first local symbol for this file, and 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).
+ /* 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. */
- 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))
-
-struct symloc
-{
- int ldsymoff;
- int ldsymlen;
-};
-
+\f
/* FIXME: Shouldn't this stuff be in a .h file somewhere? */
/* Nonzero means give verbose info on gdb action. */
extern int info_verbose;
extern struct complaint string_table_offset_complaint;
extern struct complaint lbrac_unmatched_complaint;
extern struct complaint lbrac_mismatch_complaint;
-
\f
-void hpread_symfile_init PARAMS ((struct objfile *));
-static struct type *hpread_alloc_type
- PARAMS ((DNTTPOINTER, struct objfile *));
+void hpread_symfile_init (struct objfile *);
-static struct type **hpread_lookup_type
- PARAMS ((DNTTPOINTER, 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
- PARAMS ((DNTTPOINTER, union dnttentry *, struct objfile *));
+ (dnttpointer, union dnttentry *, struct objfile *);
static struct type *hpread_read_set_type
- PARAMS ((DNTTPOINTER, union dnttentry *, struct objfile *));
+ (dnttpointer, union dnttentry *, struct objfile *);
static struct type *hpread_read_subrange_type
- PARAMS ((DNTTPOINTER, union dnttentry *, struct objfile *));
+ (dnttpointer, union dnttentry *, struct objfile *);
static struct type *hpread_read_struct_type
- PARAMS ((DNTTPOINTER, union dnttentry *, struct objfile *));
+ (dnttpointer, union dnttentry *, struct objfile *);
-void hpread_build_psymtabs
- PARAMS ((struct objfile *, struct section_offsets *, int));
+void hpread_build_psymtabs (struct objfile *, int);
-void hpread_symfile_finish PARAMS ((struct objfile *));
+void hpread_symfile_finish (struct objfile *);
static struct partial_symtab *hpread_start_psymtab
- PARAMS ((struct objfile *, struct section_offsets *, char *, CORE_ADDR, int,
- struct partial_symbol *, struct partial_symbol *));
+ (struct objfile *, char *, CORE_ADDR, int,
+ struct partial_symbol **, struct partial_symbol **);
static struct partial_symtab *hpread_end_psymtab
- PARAMS ((struct partial_symtab *, char **, int, int, CORE_ADDR,
- struct partial_symtab **, int));
+ (struct partial_symtab *, char **, int, int, CORE_ADDR,
+ struct partial_symtab **, int);
static struct symtab *hpread_expand_symtab
- PARAMS ((struct objfile *, int, int, CORE_ADDR, int,
- struct section_offsets *, char *));
+ (struct objfile *, int, int, CORE_ADDR, int,
+ struct section_offsets *, char *);
static void hpread_process_one_debug_symbol
- PARAMS ((union dnttentry *, char *, struct section_offsets *,
- struct objfile *, CORE_ADDR, int, char *, int));
+ (union dnttentry *, char *, struct section_offsets *,
+ struct objfile *, CORE_ADDR, int, char *, int);
-static SLTPOINTER hpread_record_lines
- PARAMS ((struct subfile *, SLTPOINTER, SLTPOINTER, struct objfile *));
+static sltpointer hpread_record_lines
+ (struct subfile *, sltpointer, sltpointer, struct objfile *, CORE_ADDR);
static struct type *hpread_read_function_type
- PARAMS ((DNTTPOINTER, union dnttentry *, struct objfile *));
-
-static struct type * hpread_type_lookup
- PARAMS ((DNTTPOINTER, struct objfile *));
+ (dnttpointer, union dnttentry *, struct objfile *);
-static unsigned long hpread_get_depth
- PARAMS ((SLTPOINTER, struct objfile *));
+static struct type *hpread_type_lookup (dnttpointer, struct objfile *);
-static unsigned long hpread_get_line
- PARAMS ((SLTPOINTER, struct objfile *));
+static unsigned long hpread_get_depth (sltpointer, struct objfile *);
-static ADDRESS hpread_get_location
- PARAMS ((SLTPOINTER, struct objfile *));
+static unsigned long hpread_get_line (sltpointer, struct objfile *);
-static int hpread_type_translate PARAMS ((DNTTPOINTER));
-static unsigned long hpread_get_textlow PARAMS ((int, int, struct objfile *));
-static union dnttentry *hpread_get_gntt PARAMS ((int, struct objfile *));
-static union dnttentry *hpread_get_lntt PARAMS ((int, struct objfile *));
-static union sltentry *hpread_get_slt PARAMS ((int, struct objfile *));
-static void hpread_psymtab_to_symtab PARAMS ((struct partial_symtab *));
-static void hpread_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
-static int hpread_has_name PARAMS ((KINDTYPE));
+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);
\f
+
/* 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.
+ 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
FIXME, there should be a cleaner peephole into the BFD environment here. */
void
-hpread_symfile_init (objfile)
- struct objfile *objfile;
+hpread_symfile_init (struct objfile *objfile)
{
asection *vt_section, *slt_section, *lntt_section, *gntt_section;
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));
+ 0, bfd_section_size (objfile->obfd, gntt_section));
GNTT_SYMCOUNT (objfile)
- = bfd_section_size (objfile->obfd, gntt_section) / DNTTBLOCKSIZE;
+ = 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. */
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));
+ 0, bfd_section_size (objfile->obfd, lntt_section));
LNTT_SYMCOUNT (objfile)
- = bfd_section_size (objfile->obfd, lntt_section) / DNTTBLOCKSIZE;
+ = 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. */
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));
+ 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. */
We assume hpread_symfile_init has been called to initialize the
symbol reader's private data structures.
- SECTION_OFFSETS contains offsets relative to which the symbols in the
- various sections are (depending where the sections were actually loaded).
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 (objfile, section_offsets, mainline)
- struct objfile *objfile;
- struct section_offsets *section_offsets;
- int mainline;
+hpread_build_psymtabs (struct objfile *objfile, int mainline)
{
char *namestring;
int past_first_source_file = 0;
int dependencies_used, dependencies_allocated;
/* Just in case the stabs reader left turds lying around. */
- pending_blocks = 0;
+ free_pending_blocks ();
make_cleanup (really_free_pendings, 0);
pst = (struct partial_symtab *) 0;
(struct partial_symtab **) alloca (dependencies_allocated *
sizeof (struct partial_symtab *));
- old_chain = make_cleanup (free_objfile, objfile);
+ old_chain = make_cleanup_free_objfile (objfile);
last_source_file = 0;
everything else is ignored. */
switch (dn_bufp->dblock.kind)
{
- case K_SRCFILE:
+ case DNTT_TYPE_SRCFILE:
{
/* A source file of some kind. Note this may simply
be an included file. */
if (pst && past_first_source_file)
{
- texthigh += ANOFFSET (section_offsets, SECT_OFF_TEXT);
hpread_end_psymtab (pst, psymtab_include_list,
includes_used,
- hp_symnum * DNTTBLOCKSIZE, texthigh,
+ (hp_symnum
+ * sizeof (struct dntt_type_block)),
+ texthigh,
dependency_list, dependencies_used);
pst = (struct partial_symtab *) 0;
includes_used = 0;
past_first_source_file = 1;
valu = hpread_get_textlow (i, hp_symnum, objfile);
- valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
- pst = hpread_start_psymtab (objfile, section_offsets,
+ valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+ pst = hpread_start_psymtab (objfile,
namestring, valu,
- hp_symnum * DNTTBLOCKSIZE,
+ (hp_symnum
+ * sizeof (struct dntt_type_block)),
objfile->global_psymbols.next,
objfile->static_psymbols.next);
texthigh = valu;
continue;
}
- case K_MODULE:
+ case DNTT_TYPE_MODULE:
/* A source file. It's still unclear to me what the
- real difference between a K_SRCFILE and K_MODULE
- is supposed to be. */
+ 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 (section_offsets, SECT_OFF_TEXT);
+ valu += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
if (!pst)
{
- pst = hpread_start_psymtab (objfile, section_offsets,
+ pst = hpread_start_psymtab (objfile,
namestring, valu,
- hp_symnum * DNTTBLOCKSIZE,
+ (hp_symnum
+ * sizeof (struct dntt_type_block)),
objfile->global_psymbols.next,
objfile->static_psymbols.next);
texthigh = valu;
have_name = 0;
}
continue;
- case K_FUNCTION:
- case K_ENTRY:
- /* The beginning of a function. K_ENTRY may also denote
- a secondary entry point. */
+ 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 (section_offsets, SECT_OFF_TEXT);
- if (dn_bufp->dfunc.hiaddr > texthigh)
- texthigh = dn_bufp->dfunc.hiaddr;
+ ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
SET_NAMESTRING (dn_bufp, &namestring, objfile);
- ADD_PSYMBOL_TO_LIST (namestring, strlen (namestring),
+ add_psymbol_to_list (namestring, strlen (namestring),
VAR_NAMESPACE, LOC_BLOCK,
- objfile->static_psymbols, valu,
- language_unknown, objfile);
+ &objfile->static_psymbols, valu,
+ 0, language_unknown, objfile);
within_function = 1;
continue;
- case K_BEGIN:
- case K_END:
+ 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 == K_MODULE)
+ and file blocks right now. */
+ if (dn_bufp->dend.endkind == DNTT_TYPE_MODULE)
{
- texthigh += ANOFFSET (section_offsets, SECT_OFF_TEXT);
hpread_end_psymtab (pst, psymtab_include_list, includes_used,
- hp_symnum * DNTTBLOCKSIZE, texthigh,
+ (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 == K_FUNCTION)
+ if (dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION)
within_function = 0;
continue;
- case K_SVAR:
- case K_DVAR:
- case K_TYPEDEF:
- case K_TAGDEF:
+ 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;
- enum namespace namespace;
+ namespace_enum namespace;
/* Don't add locals to the partial symbol table. */
if (within_function
- && (dn_bufp->dblock.kind == K_SVAR
- || dn_bufp->dblock.kind == K_DVAR))
+ && (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 == K_TAGDEF)
+ 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 == K_SVAR)
+ if (dn_bufp->dblock.kind == DNTT_TYPE_SVAR)
storage = LOC_STATIC;
- else if (dn_bufp->dblock.kind == K_DVAR
+ else if (dn_bufp->dblock.kind == DNTT_TYPE_DVAR
&& dn_bufp->ddvar.regvar)
storage = LOC_REGISTER;
- else if (dn_bufp->dblock.kind == K_DVAR)
+ 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, section_offsets,
+ pst = hpread_start_psymtab (objfile,
"globals", 0,
- hp_symnum * DNTTBLOCKSIZE,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
+ (hp_symnum
+ * sizeof (struct dntt_type_block)),
+ objfile->global_psymbols.next,
+ objfile->static_psymbols.next);
}
- if (dn_bufp->dsvar.public)
+ if (dn_bufp->dsvar.global)
{
- ADD_PSYMBOL_TO_LIST (namestring, strlen (namestring),
+ add_psymbol_to_list (namestring, strlen (namestring),
namespace, storage,
- objfile->global_psymbols,
+ &objfile->global_psymbols,
dn_bufp->dsvar.location,
- language_unknown, objfile);
+ 0, language_unknown, objfile);
}
else
{
- ADD_PSYMBOL_TO_LIST (namestring, strlen (namestring),
+ add_psymbol_to_list (namestring, strlen (namestring),
namespace, storage,
- objfile->static_psymbols,
+ &objfile->static_psymbols,
dn_bufp->dsvar.location,
- language_unknown, objfile);
+ 0, language_unknown, objfile);
}
continue;
}
- case K_MEMENUM:
- case K_CONST:
+ 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, section_offsets,
+ pst = hpread_start_psymtab (objfile,
"globals", 0,
- hp_symnum * DNTTBLOCKSIZE,
+ (hp_symnum
+ * sizeof (struct dntt_type_block)),
objfile->global_psymbols.next,
objfile->static_psymbols.next);
}
- ADD_PSYMBOL_TO_LIST (namestring, strlen (namestring),
+ add_psymbol_to_list (namestring, strlen (namestring),
VAR_NAMESPACE, LOC_CONST,
- objfile->static_psymbols, 0,
- language_unknown, objfile);
+ &objfile->static_psymbols, 0,
+ 0, language_unknown, objfile);
continue;
default:
continue;
if (pst)
{
hpread_end_psymtab (pst, psymtab_include_list, includes_used,
- hp_symnum * DNTTBLOCKSIZE, 0,
- dependency_list, dependencies_used);
+ hp_symnum * sizeof (struct dntt_type_block),
+ 0, dependency_list, dependencies_used);
}
discard_cleanups (old_chain);
objfile struct from the global list of known objfiles. */
void
-hpread_symfile_finish (objfile)
- struct objfile *objfile;
+hpread_symfile_finish (struct objfile *objfile)
{
if (objfile->sym_private != NULL)
{
/* Various small functions to get entries in the debug symbol sections. */
static union dnttentry *
-hpread_get_lntt (index, objfile)
- int index;
- struct objfile *objfile;
+hpread_get_lntt (int index, struct objfile *objfile)
{
- return (union dnttentry *)&(LNTT (objfile)[index * DNTTBLOCKSIZE]);
+ return (union dnttentry *)
+ &(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
}
static union dnttentry *
-hpread_get_gntt (index, objfile)
- int index;
- struct objfile *objfile;
+hpread_get_gntt (int index, struct objfile *objfile)
{
- return (union dnttentry *)&(GNTT (objfile)[index * DNTTBLOCKSIZE]);
+ return (union dnttentry *)
+ &(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
}
static union sltentry *
-hpread_get_slt (index, objfile)
- int index;
- struct objfile *objfile;
+hpread_get_slt (int index, struct objfile *objfile)
{
- return (union sltentry *)&(SLT (objfile)[index * SLTBLOCKSIZE]);
+ 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 K_MODULE or K_SRCFILE symbol we must infer it from
- the existance of K_FUNCTION symbols. */
+ 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 (global, index, objfile)
- int global;
- int index;
- struct objfile *objfile;
+hpread_get_textlow (int global, int index, struct objfile *objfile)
{
union dnttentry *dn_bufp;
struct minimal_symbol *msymbol;
- /* Look for a K_FUNCTION symbol. */
+ /* 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 != K_FUNCTION
- && dn_bufp->dblock.kind != K_END);
+ }
+ while (dn_bufp->dblock.kind != DNTT_TYPE_FUNCTION
+ && dn_bufp->dblock.kind != DNTT_TYPE_END);
- /* Avoid going past a K_END when looking for a K_FUNCTION. This
+ /* 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 == K_END)
+ 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),
+ msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL,
objfile);
if (msymbol)
return SYMBOL_VALUE_ADDRESS (msymbol);
/* Get the nesting depth for the source line identified by INDEX. */
static unsigned long
-hpread_get_depth (index, objfile)
- SLTPOINTER index;
- struct objfile *objfile;
+hpread_get_depth (sltpointer index, struct objfile *objfile)
{
union sltentry *sl_bufp;
/* Get the source line number the the line identified by INDEX. */
static unsigned long
-hpread_get_line (index, objfile)
- SLTPOINTER index;
- struct objfile *objfile;
+hpread_get_line (sltpointer index, struct objfile *objfile)
{
union sltentry *sl_bufp;
return sl_bufp->snorm.line;
}
-static ADDRESS
-hpread_get_location (index, objfile)
- SLTPOINTER index;
- struct objfile *objfile;
+static CORE_ADDR
+hpread_get_location (sltpointer index, struct objfile *objfile)
{
union sltentry *sl_bufp;
int i;
it, else return 0. */
static int
-hpread_has_name (kind)
- KINDTYPE kind;
+hpread_has_name (enum dntt_entry_type kind)
{
switch (kind)
{
- case K_SRCFILE:
- case K_MODULE:
- case K_FUNCTION:
- case K_ENTRY:
- case K_IMPORT:
- case K_LABEL:
- case K_FPARAM:
- case K_SVAR:
- case K_DVAR:
- case K_CONST:
- case K_TYPEDEF:
- case K_TAGDEF:
- case K_MEMENUM:
- case K_FIELD:
- case K_SA:
+ case DNTT_TYPE_SRCFILE:
+ case DNTT_TYPE_MODULE:
+ case DNTT_TYPE_FUNCTION:
+ case DNTT_TYPE_ENTRY:
+ case DNTT_TYPE_IMPORT:
+ case DNTT_TYPE_LABEL:
+ case DNTT_TYPE_FPARAM:
+ case DNTT_TYPE_SVAR:
+ case DNTT_TYPE_DVAR:
+ case DNTT_TYPE_CONST:
+ case DNTT_TYPE_TYPEDEF:
+ case DNTT_TYPE_TAGDEF:
+ case DNTT_TYPE_MEMENUM:
+ case DNTT_TYPE_FIELD:
+ case DNTT_TYPE_SA:
return 1;
- case K_BEGIN:
- case K_END:
- case K_WITH:
- case K_COMMON:
- case K_POINTER:
- case K_ENUM:
- case K_SET:
- case K_SUBRANGE:
- case K_ARRAY:
- case K_STRUCT:
- case K_UNION:
- case K_VARIANT:
- case K_FILE:
- case K_FUNCTYPE:
- case K_COBSTRUCT:
- case K_XREF:
- case K_MACRO:
+ case DNTT_TYPE_BEGIN:
+ case DNTT_TYPE_END:
+ case DNTT_TYPE_WITH:
+ case DNTT_TYPE_COMMON:
+ case DNTT_TYPE_POINTER:
+ case DNTT_TYPE_ENUM:
+ case DNTT_TYPE_SET:
+ case DNTT_TYPE_SUBRANGE:
+ case DNTT_TYPE_ARRAY:
+ case DNTT_TYPE_STRUCT:
+ case DNTT_TYPE_UNION:
+ case DNTT_TYPE_VARIANT:
+ case DNTT_TYPE_FILE:
+ case DNTT_TYPE_FUNCTYPE:
+ case DNTT_TYPE_COBSTRUCT:
+ case DNTT_TYPE_XREF:
+ case DNTT_TYPE_MACRO:
default:
return 0;
}
(normal). */
static struct partial_symtab *
-hpread_start_psymtab (objfile, section_offsets,
- filename, textlow, ldsymoff, global_syms, static_syms)
- struct objfile *objfile;
- struct section_offsets *section_offsets;
- char *filename;
- CORE_ADDR textlow;
- int ldsymoff;
- struct partial_symbol *global_syms;
- struct partial_symbol *static_syms;
+hpread_start_psymtab (struct objfile *objfile, char *filename,
+ CORE_ADDR textlow, int ldsymoff,
+ struct partial_symbol **global_syms,
+ struct partial_symbol **static_syms)
{
struct partial_symtab *result =
start_psymtab_common (objfile, section_offsets,
FIXME: List variables and peculiarities of same. */
static struct partial_symtab *
-hpread_end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
- capping_text, dependency_list, number_dependencies)
- struct partial_symtab *pst;
- char **include_list;
- int num_includes;
- int capping_symbol_offset;
- CORE_ADDR capping_text;
- struct partial_symtab **dependency_list;
- int number_dependencies;
+hpread_end_psymtab (struct partial_symtab *pst, char **include_list,
+ int num_includes, int capping_symbol_offset,
+ CORE_ADDR capping_text,
+ struct partial_symtab **dependency_list,
+ int number_dependencies)
{
int i;
- struct objfile *objfile = pst -> objfile;
+ struct objfile *objfile = pst->objfile;
if (capping_symbol_offset != -1)
- LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
+ LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
pst->texthigh = capping_text;
pst->n_global_syms =
{
pst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->psymbol_obstack,
- number_dependencies * sizeof (struct partial_symtab *));
+ number_dependencies * sizeof (struct partial_symtab *));
memcpy (pst->dependencies, dependency_list,
- number_dependencies * sizeof (struct partial_symtab *));
+ number_dependencies * sizeof (struct partial_symtab *));
}
else
pst->dependencies = 0;
for (i = 0; i < num_includes; i++)
{
struct partial_symtab *subpst =
- allocate_psymtab (include_list[i], objfile);
+ allocate_psymtab (include_list[i], objfile);
subpst->section_offsets = pst->section_offsets;
subpst->read_symtab_private =
- (char *) obstack_alloc (&objfile->psymbol_obstack,
- sizeof (struct symloc));
- LDSYMOFF(subpst) =
- LDSYMLEN(subpst) =
- subpst->textlow =
- subpst->texthigh = 0;
+ (char *) obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (struct symloc));
+ LDSYMOFF (subpst) =
+ LDSYMLEN (subpst) =
+ subpst->textlow =
+ subpst->texthigh = 0;
/* We could save slight bits of space by only making one of these,
- shared by the entire set of include files. FIXME-someday. */
+ shared by the entire set of include files. FIXME-someday. */
subpst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct partial_symtab *));
subpst->globals_offset =
subpst->n_global_syms =
- subpst->statics_offset =
- subpst->n_static_syms = 0;
+ subpst->statics_offset =
+ subpst->n_static_syms = 0;
subpst->readin = 0;
subpst->symtab = 0;
&& pst->n_static_syms == 0)
{
/* Throw away this psymtab, it's empty. We can't deallocate it, since
- it is on the obstack, but we can forget to chain it on the list. */
+ it is on the obstack, but we can forget to chain it on the 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. But this check
- is wrong, in that a psymtab with N_SLINE entries but nothing else
- is not empty, but we don't realize that. Fixing that without slowing
- things down might be tricky. */
- struct partial_symtab *prev_pst;
-
- /* First, snip it out of the psymtab chain */
-
- if (pst->objfile->psymtabs == pst)
- pst->objfile->psymtabs = pst->next;
- else
- for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
- if (prev_pst->next == pst)
- prev_pst->next = pst->next;
+ any symbols in them. There can be a lot of them. But this check
+ is wrong, in that a psymtab with N_SLINE entries but nothing else
+ is not empty, but we don't realize that. Fixing that without slowing
+ things down might be tricky. */
- /* Next, put it on a free list for recycling */
-
- pst->next = pst->objfile->free_psymtabs;
- pst->objfile->free_psymtabs = pst;
+ discard_psymtab (pst);
/* Indicate that psymtab was thrown away. */
- pst = (struct partial_symtab *)NULL;
+ pst = (struct partial_symtab *) NULL;
}
return pst;
}
table. */
static void
-hpread_psymtab_to_symtab_1 (pst)
- struct partial_symtab *pst;
+hpread_psymtab_to_symtab_1 (struct partial_symtab *pst)
{
struct cleanup *old_chain;
int i;
/* Inform about additional files that need to be read in. */
if (info_verbose)
{
- fputs_filtered (" ", stdout);
+ fputs_filtered (" ", gdb_stdout);
wrap_here ("");
- fputs_filtered ("and ", stdout);
+ fputs_filtered ("and ", gdb_stdout);
wrap_here ("");
printf_filtered ("%s...", pst->dependencies[i]->filename);
wrap_here (""); /* Flush output */
- fflush (stdout);
+ gdb_flush (gdb_stdout);
}
hpread_psymtab_to_symtab_1 (pst->dependencies[i]);
}
Be verbose about it if the user wants that. */
static void
-hpread_psymtab_to_symtab (pst)
- struct partial_symtab *pst;
+hpread_psymtab_to_symtab (struct partial_symtab *pst)
{
/* Get out quick if given junk. */
if (!pst)
if (info_verbose)
{
printf_filtered ("Reading in symbols for %s...", pst->filename);
- fflush (stdout);
+ gdb_flush (gdb_stdout);
}
hpread_psymtab_to_symtab_1 (pst);
SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
static struct symtab *
-hpread_expand_symtab (objfile, sym_offset, sym_size, text_offset, text_size,
- section_offsets, filename)
- struct objfile *objfile;
- int sym_offset;
- int sym_size;
- CORE_ADDR text_offset;
- int text_size;
- struct section_offsets *section_offsets;
- char *filename;
+hpread_expand_symtab (struct objfile *objfile, int sym_offset, int sym_size,
+ CORE_ADDR text_offset, int text_size,
+ struct section_offsets *section_offsets, char *filename)
{
char *namestring;
union dnttentry *dn_bufp;
unsigned max_symnum;
- int sym_index = sym_offset / DNTTBLOCKSIZE;
+ int sym_index = sym_offset / sizeof (struct dntt_type_block);
current_objfile = objfile;
subfile_stack = 0;
last_source_file = 0;
dn_bufp = hpread_get_lntt (sym_index, objfile);
- if (!((dn_bufp->dblock.kind == (unsigned char) K_SRCFILE) ||
- (dn_bufp->dblock.kind == (unsigned char) K_MODULE)))
- start_symtab ("globals", NULL, 0);
+ if (!((dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_SRCFILE) ||
+ (dn_bufp->dblock.kind == (unsigned char) DNTT_TYPE_MODULE)))
+ {
+ start_symtab ("globals", NULL, 0);
+ record_debugformat ("HP");
+ }
- max_symnum = sym_size / DNTTBLOCKSIZE;
+ max_symnum = sym_size / sizeof (struct dntt_type_block);
/* Read in and process each debug symbol within the specified range. */
for (symnum = 0;
current_objfile = NULL;
- return end_symtab (text_offset + text_size, 0, 0, objfile, 0);
+ return end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
}
\f
/* Convert basic types from HP debug format into GDB internal format. */
static int
-hpread_type_translate (typep)
- DNTTPOINTER typep;
+hpread_type_translate (dnttpointer typep)
{
if (!typep.dntti.immediate)
abort ();
switch (typep.dntti.type)
{
- case T_BOOLEAN:
- case T_BOOLEAN_S300_COMPAT:
- case T_BOOLEAN_VAX_COMPAT:
+ case HP_TYPE_BOOLEAN:
+ case HP_TYPE_BOOLEAN_S300_COMPAT:
+ case HP_TYPE_BOOLEAN_VAX_COMPAT:
return FT_BOOLEAN;
/* Ugh. No way to distinguish between signed and unsigned chars. */
- case T_CHAR:
- case T_WIDE_CHAR:
+ case HP_TYPE_CHAR:
+ case HP_TYPE_WIDE_CHAR:
return FT_CHAR;
- case T_INT:
+ case HP_TYPE_INT:
if (typep.dntti.bitlength <= 8)
return FT_CHAR;
if (typep.dntti.bitlength <= 16)
if (typep.dntti.bitlength <= 32)
return FT_INTEGER;
return FT_LONG_LONG;
- case T_LONG:
+ case HP_TYPE_LONG:
return FT_LONG;
- case T_UNS_LONG:
+ case HP_TYPE_UNSIGNED_LONG:
if (typep.dntti.bitlength <= 8)
return FT_UNSIGNED_CHAR;
if (typep.dntti.bitlength <= 16)
if (typep.dntti.bitlength <= 32)
return FT_UNSIGNED_LONG;
return FT_UNSIGNED_LONG_LONG;
- case T_UNS_INT:
+ case HP_TYPE_UNSIGNED_INT:
if (typep.dntti.bitlength <= 8)
return FT_UNSIGNED_CHAR;
if (typep.dntti.bitlength <= 16)
if (typep.dntti.bitlength <= 32)
return FT_UNSIGNED_INTEGER;
return FT_UNSIGNED_LONG_LONG;
- case T_REAL:
- case T_REAL_3000:
- case T_DOUBLE:
+ case HP_TYPE_REAL:
+ case HP_TYPE_REAL_3000:
+ case HP_TYPE_DOUBLE:
if (typep.dntti.bitlength == 64)
return FT_DBL_PREC_FLOAT;
if (typep.dntti.bitlength == 128)
return FT_EXT_PREC_FLOAT;
return FT_FLOAT;
- case T_COMPLEX:
- case T_COMPLEXS3000:
+ case HP_TYPE_COMPLEX:
+ case HP_TYPE_COMPLEXS3000:
if (typep.dntti.bitlength == 128)
return FT_DBL_PREC_COMPLEX;
if (typep.dntti.bitlength == 192)
return FT_EXT_PREC_COMPLEX;
return FT_COMPLEX;
- case T_STRING200:
- case T_LONGSTRING200:
- case T_FTN_STRING_SPEC:
- case T_MOD_STRING_SPEC:
- case T_MOD_STRING_3000:
- case T_FTN_STRING_S300_COMPAT:
- case T_FTN_STRING_VAX_COMPAT:
+ case HP_TYPE_STRING200:
+ case HP_TYPE_LONGSTRING200:
+ case HP_TYPE_FTN_STRING_SPEC:
+ case HP_TYPE_MOD_STRING_SPEC:
+ case HP_TYPE_MOD_STRING_3000:
+ case HP_TYPE_FTN_STRING_S300_COMPAT:
+ case HP_TYPE_FTN_STRING_VAX_COMPAT:
return FT_STRING;
default:
abort ();
/* Return the type associated with the index found in HP_TYPE. */
static struct type **
-hpread_lookup_type (hp_type, objfile)
- DNTTPOINTER hp_type;
- struct objfile *objfile;
+hpread_lookup_type (dnttpointer hp_type, struct objfile *objfile)
{
unsigned old_len;
int index = hp_type.dnttp.index;
{
TYPE_VECTOR_LENGTH (objfile) = 100;
TYPE_VECTOR (objfile) = (struct type **)
- malloc (TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *));
+ xmmalloc (objfile->md,
+ TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *));
}
while (index >= TYPE_VECTOR_LENGTH (objfile))
TYPE_VECTOR_LENGTH (objfile) *= 2;
TYPE_VECTOR (objfile) = (struct type **)
- xrealloc ((char *) TYPE_VECTOR (objfile),
- (TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
+ xmrealloc (objfile->md,
+ (char *) TYPE_VECTOR (objfile),
+ (TYPE_VECTOR_LENGTH (objfile) * sizeof (struct type *)));
memset (&TYPE_VECTOR (objfile)[old_len], 0,
(TYPE_VECTOR_LENGTH (objfile) - old_len) *
sizeof (struct type *));
have it lying around. */
static struct type *
-hpread_alloc_type (hp_type, objfile)
- DNTTPOINTER hp_type;
- struct objfile *objfile;
+hpread_alloc_type (dnttpointer hp_type, struct objfile *objfile)
{
struct type **type_addr;
/* Read a native enumerated type and return it in GDB internal form. */
static struct type *
-hpread_read_enum_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_enum_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct type *type;
struct pending **symlist, *osyms, *syms;
int o_nsyms, nsyms = 0;
- DNTTPOINTER mem;
+ dnttpointer mem;
union dnttentry *memp;
char *name;
long n;
sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = name;
+ SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
+ &objfile->symbol_obstack);
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_VALUE (sym) = memp->dmember.value;
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
- TYPE_FIELD_VALUE (type, n) = 0;
TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
TYPE_FIELD_BITSIZE (type, n) = 0;
}
/* Read and internalize a native function debug symbol. */
static struct type *
-hpread_read_function_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_function_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct type *type, *type1;
struct pending **symlist, *osyms, *syms;
int o_nsyms, nsyms = 0;
- DNTTPOINTER param;
+ dnttpointer param;
union dnttentry *paramp;
char *name;
long n;
sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
(void) memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = name;
+ SYMBOL_NAME (sym) = obsavestring (name, strlen (name),
+ &objfile->symbol_obstack);
/* Figure out where it lives. */
if (paramp->dfparam.regparam)
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
if (paramp->dfparam.copyparam)
{
- SYMBOL_VALUE (sym) = paramp->dfparam.location ;
+ SYMBOL_VALUE (sym) = paramp->dfparam.location;
#ifdef HPREAD_ADJUST_STACK_ADDRESS
SYMBOL_VALUE (sym)
+= HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
/* Read in and internalize a structure definition. */
static struct type *
-hpread_read_struct_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_struct_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct nextfield
{
struct nextfield *list = 0;
struct nextfield *new;
int n, nfields = 0;
- DNTTPOINTER field;
+ dnttpointer field;
union dnttentry *fieldp;
/* Is it something we've already dealt with? */
type = hpread_alloc_type (hp_type, objfile);
if ((TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
(TYPE_CODE (type) == TYPE_CODE_UNION))
- return type;
+ return type;
/* Get the basic type correct. */
- if (dn_bufp->dblock.kind == K_STRUCT)
+ if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
{
TYPE_CODE (type) = TYPE_CODE_STRUCT;
TYPE_LENGTH (type) = dn_bufp->dstruct.bitlength / 8;
}
- else if (dn_bufp->dblock.kind == K_UNION)
+ else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
{
TYPE_CODE (type) = TYPE_CODE_UNION;
TYPE_LENGTH (type) = dn_bufp->dunion.bitlength / 8;
list = new;
list->field.name = VT (objfile) + fieldp->dfield.name;
- list->field.bitpos = fieldp->dfield.bitoffset;
+ FIELD_BITPOS (list->field) = fieldp->dfield.bitoffset;
if (fieldp->dfield.bitlength % 8)
- list->field.bitsize = fieldp->dfield.bitlength;
+ FIELD_BITSIZE (list->field) = fieldp->dfield.bitlength;
else
- list->field.bitsize = 0;
+ FIELD_BITSIZE (list->field) = 0;
nfields++;
field = fieldp->dfield.nextfield;
- list->field.type = hpread_type_lookup (fieldp->dfield.type, objfile);
+ FIELD_TYPE (list->field) = hpread_type_lookup (fieldp->dfield.type,
+ objfile);
}
TYPE_NFIELDS (type) = nfields;
/* Read in and internalize a set debug symbol. */
static struct type *
-hpread_read_set_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_set_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct type *type;
/* Read in and internalize an array debug symbol. */
static struct type *
-hpread_read_array_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_array_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct type *type;
union dnttentry save;
else if (dn_bufp->darray.arraylength == 0x7fffffff)
{
/* The HP debug format represents char foo[]; as an array with
- length 0x7fffffff. Internally GDB wants to represent this
- as a pointer. Ugh. */
- TYPE_CODE (type) = TYPE_CODE_PTR;
- TYPE_LENGTH (type) = 4;
+ length 0x7fffffff. Internally GDB wants to represent this
+ as an array of length zero. */
+ TYPE_LENGTH (type) = 0;
}
else
TYPE_LENGTH (type) = dn_bufp->darray.arraylength / 8;
/* Read in and internalize a subrange debug symbol. */
static struct type *
-hpread_read_subrange_type (hp_type, dn_bufp, objfile)
- DNTTPOINTER hp_type;
- union dnttentry *dn_bufp;
- struct objfile *objfile;
+hpread_read_subrange_type (dnttpointer hp_type, union dnttentry *dn_bufp,
+ struct objfile *objfile)
{
struct type *type;
TYPE_CODE (type) = TYPE_CODE_RANGE;
TYPE_LENGTH (type) = dn_bufp->dsubr.bitlength / 8;
TYPE_NFIELDS (type) = 2;
- TYPE_FIELDS (type) = (struct field *) obstack_alloc
- (&objfile->type_obstack, 2 * sizeof (struct field));
+ TYPE_FIELDS (type)
+ = (struct field *) obstack_alloc (&objfile->type_obstack,
+ 2 * sizeof (struct field));
if (dn_bufp->dsubr.dyn_low)
TYPE_FIELD_BITPOS (type, 0) = 0;
}
static struct type *
-hpread_type_lookup (hp_type, objfile)
- DNTTPOINTER hp_type;
- struct objfile *objfile;
+hpread_type_lookup (dnttpointer hp_type, struct objfile *objfile)
{
union dnttentry *dn_bufp;
switch (dn_bufp->dblock.kind)
{
- case K_SRCFILE:
- case K_MODULE:
- case K_FUNCTION:
- case K_ENTRY:
- case K_BEGIN:
- case K_END:
- case K_IMPORT:
- case K_LABEL:
- case K_WITH:
- case K_COMMON:
- case K_FPARAM:
- case K_SVAR:
- case K_DVAR:
- case K_CONST:
+ case DNTT_TYPE_SRCFILE:
+ case DNTT_TYPE_MODULE:
+ case DNTT_TYPE_FUNCTION:
+ case DNTT_TYPE_ENTRY:
+ case DNTT_TYPE_BEGIN:
+ case DNTT_TYPE_END:
+ case DNTT_TYPE_IMPORT:
+ case DNTT_TYPE_LABEL:
+ case DNTT_TYPE_WITH:
+ case DNTT_TYPE_COMMON:
+ case DNTT_TYPE_FPARAM:
+ case DNTT_TYPE_SVAR:
+ case DNTT_TYPE_DVAR:
+ case DNTT_TYPE_CONST:
/* Opps. Something went very wrong. */
return lookup_fundamental_type (objfile, FT_VOID);
- case K_TYPEDEF:
+ case DNTT_TYPE_TYPEDEF:
{
struct type *structtype = hpread_type_lookup (dn_bufp->dtype.type,
objfile);
TYPE_CPLUS_SPECIFIC (structtype)
= (struct cplus_struct_type *) &cplus_struct_default;
- TYPE_NAME (structtype) = suffix;
+ TYPE_NAME (structtype) = suffix;
return structtype;
}
- case K_TAGDEF:
+ case DNTT_TYPE_TAGDEF:
{
/* Just a little different from above. We have to tack on
an identifier of some kind (struct, union, enum, etc). */
else
abort ();
- if (dn_bufp->dblock.kind == K_STRUCT)
+ if (dn_bufp->dblock.kind == DNTT_TYPE_STRUCT)
prefix = "struct ";
- else if (dn_bufp->dblock.kind == K_UNION)
+ else if (dn_bufp->dblock.kind == DNTT_TYPE_UNION)
prefix = "union ";
else
prefix = "enum ";
return structtype;
}
- case K_POINTER:
+ case DNTT_TYPE_POINTER:
return lookup_pointer_type (hpread_type_lookup (dn_bufp->dptr.pointsto,
objfile));
- case K_ENUM:
+ case DNTT_TYPE_ENUM:
return hpread_read_enum_type (hp_type, dn_bufp, objfile);
- case K_MEMENUM:
+ case DNTT_TYPE_MEMENUM:
return lookup_fundamental_type (objfile, FT_VOID);
- case K_SET:
+ case DNTT_TYPE_SET:
return hpread_read_set_type (hp_type, dn_bufp, objfile);
- case K_SUBRANGE:
+ case DNTT_TYPE_SUBRANGE:
return hpread_read_subrange_type (hp_type, dn_bufp, objfile);
- case K_ARRAY:
+ case DNTT_TYPE_ARRAY:
return hpread_read_array_type (hp_type, dn_bufp, objfile);
- case K_STRUCT:
- case K_UNION:
+ case DNTT_TYPE_STRUCT:
+ case DNTT_TYPE_UNION:
return hpread_read_struct_type (hp_type, dn_bufp, objfile);
- case K_FIELD:
+ case DNTT_TYPE_FIELD:
return hpread_type_lookup (dn_bufp->dfield.type, objfile);
- case K_VARIANT:
- case K_FILE:
+ case DNTT_TYPE_VARIANT:
+ case DNTT_TYPE_FILE:
return lookup_fundamental_type (objfile, FT_VOID);
- case K_FUNCTYPE:
+ case DNTT_TYPE_FUNCTYPE:
return lookup_function_type (hpread_type_lookup (dn_bufp->dfunctype.retval,
objfile));
- case K_COBSTRUCT:
- case K_XREF:
- case K_SA:
- case K_MACRO:
+ case DNTT_TYPE_COBSTRUCT:
+ case DNTT_TYPE_XREF:
+ case DNTT_TYPE_SA:
+ case DNTT_TYPE_MACRO:
default:
return lookup_fundamental_type (objfile, FT_VOID);
}
}
-static SLTPOINTER
-hpread_record_lines (subfile, s_idx, e_idx, objfile)
- struct subfile *subfile;
- SLTPOINTER s_idx, e_idx;
- struct objfile *objfile;
+static sltpointer
+hpread_record_lines (struct subfile *subfile, sltpointer s_idx,
+ sltpointer e_idx, struct objfile *objfile,
+ CORE_ADDR offset)
{
union sltentry *sl_bufp;
/* Only record "normal" entries in the SLT. */
if (sl_bufp->snorm.sltdesc == SLT_NORMAL
|| sl_bufp->snorm.sltdesc == SLT_EXIT)
- record_line (subfile, sl_bufp->snorm.line, sl_bufp->snorm.address);
+ record_line (subfile, sl_bufp->snorm.line,
+ sl_bufp->snorm.address + offset);
s_idx++;
}
return e_idx;
/* Internalize one native debug symbol. */
static void
-hpread_process_one_debug_symbol (dn_bufp, name, section_offsets, objfile,
- text_offset, text_size, filename, index)
- union dnttentry *dn_bufp;
- char *name;
- struct section_offsets *section_offsets;
- struct objfile *objfile;
- CORE_ADDR text_offset;
- int text_size;
- char *filename;
- int index;
+hpread_process_one_debug_symbol (union dnttentry *dn_bufp, char *name,
+ struct section_offsets *section_offsets,
+ struct objfile *objfile, CORE_ADDR text_offset,
+ int text_size, char *filename, int index)
{
unsigned long desc;
int type;
CORE_ADDR valu;
- int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
+ int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
union dnttentry *dn_temp;
- DNTTPOINTER hp_type;
+ dnttpointer hp_type;
struct symbol *sym;
struct context_stack *new;
sym = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (sym) = name;
+ SYMBOL_NAME (sym) = obsavestring (name, strlen (name), &objfile->symbol_obstack);
SYMBOL_LANGUAGE (sym) = language_auto;
SYMBOL_INIT_DEMANGLED_NAME (sym, &objfile->symbol_obstack);
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
switch (type)
{
- case K_SRCFILE:
+ case DNTT_TYPE_SRCFILE:
/* This type of symbol indicates from which source file or include file
the following data comes. If there are no modules it also may
indicate the start of a new source file, in which case we must
finish the symbol table of the previous source file
(if any) and start accumulating a new symbol table. */
- valu = text_offset + offset; /* Relocate for dynamic loading */
+ valu = text_offset;
if (!last_source_file)
- start_symtab (name, NULL, valu);
-
- SL_INDEX (objfile) = hpread_record_lines (current_subfile,
- SL_INDEX (objfile),
- dn_bufp->dsfile.address,
- objfile);
+ {
+ start_symtab (name, NULL, valu);
+ record_debugformat ("HP");
+ SL_INDEX (objfile) = dn_bufp->dsfile.address;
+ }
+ else
+ {
+ SL_INDEX (objfile) = hpread_record_lines (current_subfile,
+ SL_INDEX (objfile),
+ dn_bufp->dsfile.address,
+ objfile, offset);
+ }
start_subfile (name, NULL);
break;
-
- case K_MODULE:
- /* No need to do anything with these K_MODULE symbols anymore. */
+
+ case DNTT_TYPE_MODULE:
+ /* No need to do anything with these DNTT_TYPE_MODULE symbols anymore. */
break;
- case K_FUNCTION:
- case K_ENTRY:
+ case DNTT_TYPE_FUNCTION:
+ case DNTT_TYPE_ENTRY:
/* A function or secondary entry point. */
valu = dn_bufp->dfunc.lowaddr + offset;
SL_INDEX (objfile) = hpread_record_lines (current_subfile,
SL_INDEX (objfile),
dn_bufp->dfunc.address,
- objfile);
-
+ objfile, offset);
+
WITHIN_FUNCTION (objfile) = 1;
CURRENT_FUNCTION_VALUE (objfile) = valu;
SYMBOL_CLASS (sym) = LOC_BLOCK;
SYMBOL_TYPE (sym) = hpread_read_function_type (hp_type, dn_bufp, objfile);
- if (dn_bufp->dfunc.public)
+ if (dn_bufp->dfunc.global)
add_symbol_to_list (sym, &global_symbols);
else
add_symbol_to_list (sym, &file_symbols);
new->name = sym;
/* Search forward to the next scope beginning. */
- while (dn_bufp->dblock.kind != K_BEGIN)
+ while (dn_bufp->dblock.kind != DNTT_TYPE_BEGIN)
{
dn_bufp = hpread_get_lntt (++index, objfile);
if (dn_bufp->dblock.extension)
SL_INDEX (objfile) = hpread_record_lines (current_subfile,
SL_INDEX (objfile),
dn_bufp->dbegin.address,
- objfile);
+ objfile, offset);
SYMBOL_LINE (sym) = hpread_get_line (dn_bufp->dbegin.address, objfile);
record_line (current_subfile, SYMBOL_LINE (sym), valu);
break;
- case K_BEGIN:
+ case DNTT_TYPE_BEGIN:
/* Begin a new scope. */
SL_INDEX (objfile) = hpread_record_lines (current_subfile,
SL_INDEX (objfile),
dn_bufp->dbegin.address,
- objfile);
+ objfile, offset);
valu = hpread_get_location (dn_bufp->dbegin.address, objfile);
valu += offset; /* Relocate for dynamic loading */
desc = hpread_get_depth (dn_bufp->dbegin.address, objfile);
new = push_context (desc, valu);
break;
- case K_END:
+ case DNTT_TYPE_END:
/* End a scope. */
SL_INDEX (objfile) = hpread_record_lines (current_subfile,
SL_INDEX (objfile),
dn_bufp->dend.address + 1,
- objfile);
+ objfile, offset);
switch (dn_bufp->dend.endkind)
{
- case K_MODULE:
+ case DNTT_TYPE_MODULE:
/* Ending a module ends the symbol table for that module. */
valu = text_offset + text_size + offset;
- (void) end_symtab (valu, 0, 0, objfile, 0);
+ (void) end_symtab (valu, objfile, SECT_OFF_TEXT (objfile));
break;
- case K_FUNCTION:
+ case DNTT_TYPE_FUNCTION:
/* Ending a function, well, ends the function's scope. */
dn_temp = hpread_get_lntt (dn_bufp->dend.beginscope.dnttp.index,
objfile);
new->start_addr, valu, objfile);
WITHIN_FUNCTION (objfile) = 0;
break;
- case K_BEGIN:
+ case DNTT_TYPE_BEGIN:
/* Just ending a local scope. */
valu = hpread_get_location (dn_bufp->dend.address, objfile);
/* Why in the hell is this needed? */
break;
}
break;
- case K_LABEL:
+ case DNTT_TYPE_LABEL:
SYMBOL_NAMESPACE (sym) = LABEL_NAMESPACE;
break;
- case K_FPARAM:
+ case DNTT_TYPE_FPARAM:
/* Function parameters. */
if (dn_bufp->dfparam.regparam)
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dfparam.type, objfile);
add_symbol_to_list (sym, &local_symbols);
break;
- case K_SVAR:
+ case DNTT_TYPE_SVAR:
/* Static variables. */
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = dn_bufp->dsvar.location;
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dsvar.type, objfile);
- if (dn_bufp->dsvar.public)
+ if (dn_bufp->dsvar.global)
add_symbol_to_list (sym, &global_symbols);
else if (WITHIN_FUNCTION (objfile))
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
- case K_DVAR:
+ case DNTT_TYPE_DVAR:
/* Dynamic variables. */
if (dn_bufp->ddvar.regvar)
SYMBOL_CLASS (sym) = LOC_REGISTER;
+= HPREAD_ADJUST_STACK_ADDRESS (CURRENT_FUNCTION_VALUE (objfile));
#endif
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->ddvar.type, objfile);
- if (dn_bufp->ddvar.public)
+ if (dn_bufp->ddvar.global)
add_symbol_to_list (sym, &global_symbols);
else if (WITHIN_FUNCTION (objfile))
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
- case K_CONST:
+ case DNTT_TYPE_CONST:
/* A constant (pascal?). */
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_VALUE (sym) = dn_bufp->dconst.location;
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dconst.type, objfile);
- if (dn_bufp->dconst.public)
+ if (dn_bufp->dconst.global)
add_symbol_to_list (sym, &global_symbols);
else if (WITHIN_FUNCTION (objfile))
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
- case K_TYPEDEF:
+ case DNTT_TYPE_TYPEDEF:
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
- if (dn_bufp->dtype.public)
+ if (dn_bufp->dtype.global)
add_symbol_to_list (sym, &global_symbols);
else if (WITHIN_FUNCTION (objfile))
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
- case K_TAGDEF:
+ case DNTT_TYPE_TAGDEF:
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
SYMBOL_TYPE (sym) = hpread_type_lookup (dn_bufp->dtype.type, objfile);
TYPE_NAME (sym->type) = SYMBOL_NAME (sym);
TYPE_TAG_NAME (sym->type) = SYMBOL_NAME (sym);
- if (dn_bufp->dtype.public)
+ if (dn_bufp->dtype.global)
add_symbol_to_list (sym, &global_symbols);
else if (WITHIN_FUNCTION (objfile))
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
- case K_POINTER:
+ case DNTT_TYPE_POINTER:
SYMBOL_TYPE (sym) = lookup_pointer_type (hpread_type_lookup
(dn_bufp->dptr.pointsto,
objfile));
add_symbol_to_list (sym, &file_symbols);
break;
- case K_ENUM:
+ case DNTT_TYPE_ENUM:
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
SYMBOL_TYPE (sym) = hpread_read_enum_type (hp_type, dn_bufp, objfile);
add_symbol_to_list (sym, &file_symbols);
break;
- case K_MEMENUM:
+ case DNTT_TYPE_MEMENUM:
break;
- case K_SET:
+ case DNTT_TYPE_SET:
SYMBOL_TYPE (sym) = hpread_read_set_type (hp_type, dn_bufp, objfile);
add_symbol_to_list (sym, &file_symbols);
break;
- case K_SUBRANGE:
+ case DNTT_TYPE_SUBRANGE:
SYMBOL_TYPE (sym) = hpread_read_subrange_type (hp_type, dn_bufp,
objfile);
add_symbol_to_list (sym, &file_symbols);
break;
- case K_ARRAY:
+ case DNTT_TYPE_ARRAY:
SYMBOL_TYPE (sym) = hpread_read_array_type (hp_type, dn_bufp, objfile);
add_symbol_to_list (sym, &file_symbols);
break;
- case K_STRUCT:
- case K_UNION:
+ case DNTT_TYPE_STRUCT:
+ case DNTT_TYPE_UNION:
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
SYMBOL_TYPE (sym) = hpread_read_struct_type (hp_type, dn_bufp, objfile);
add_symbol_to_list (sym, &file_symbols);