mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
2426 lines
87 KiB
C
2426 lines
87 KiB
C
/* Read hp debug symbols and convert to internal format, for GDB.
|
||
Copyright 1993, 1996 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. */
|
||
|
||
/* Common include file for hp_symtab_read.c and hp_psymtab_read.c.
|
||
* This has nested includes of a bunch of stuff.
|
||
*/
|
||
#include "hpread.h"
|
||
#include "demangle.h"
|
||
|
||
/* To generate dumping code, uncomment this define. The dumping
|
||
* itself is controlled by routine-local statics called "dumping".
|
||
*/
|
||
/* #define DUMPING 1 */
|
||
|
||
/* To use the quick look-up tables, uncomment this define.
|
||
*/
|
||
#define QUICK_LOOK_UP 0
|
||
|
||
/* To call PXDB to process un-processed files, uncomment this define.
|
||
*/
|
||
#define USE_PXDB 1
|
||
|
||
/* Forward procedure declarations */
|
||
|
||
void hpread_symfile_init
|
||
PARAMS ((struct objfile *));
|
||
|
||
void hpread_build_psymtabs
|
||
PARAMS ((struct objfile *, struct section_offsets *, int));
|
||
|
||
void hpread_symfile_finish
|
||
PARAMS ((struct objfile *));
|
||
|
||
static union dnttentry *hpread_get_gntt
|
||
PARAMS ((int, struct objfile *));
|
||
|
||
static unsigned long hpread_get_textlow
|
||
PARAMS ((int, int, struct objfile *, int));
|
||
|
||
static struct partial_symtab *hpread_start_psymtab
|
||
PARAMS ((struct objfile *, struct section_offsets *, 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));
|
||
|
||
/* End of forward routine declarations */
|
||
|
||
#ifdef USE_PXDB
|
||
|
||
/**************************************************
|
||
*
|
||
* NOTE use of system files! May not be portable.
|
||
*/
|
||
|
||
#define PXDB_SVR4 "/opt/langtools/bin/pxdb"
|
||
#define PXDB_BSD "/usr/bin/pxdb"
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
|
||
/* check for the existance of a file, given its full pathname */
|
||
int
|
||
file_exists (filename)
|
||
char *filename;
|
||
{
|
||
if (filename)
|
||
return (access (filename, F_OK) == 0);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Translate from the "hp_language" enumeration in hp-symtab.h
|
||
used in the debug info to gdb's generic enumeration in defs.h. */
|
||
static enum language
|
||
trans_lang (in_lang)
|
||
enum hp_language in_lang;
|
||
{
|
||
if (in_lang == HP_LANGUAGE_C)
|
||
return language_c;
|
||
|
||
else if (in_lang == HP_LANGUAGE_CPLUSPLUS)
|
||
return language_cplus;
|
||
|
||
else if (in_lang == HP_LANGUAGE_F77)
|
||
return language_fortran;
|
||
|
||
else return language_unknown;
|
||
}
|
||
|
||
static char main_string[] = "main";
|
||
|
||
|
||
/* Call PXDB to process our file.
|
||
|
||
Approach copied from DDE's "dbgk_run_pxdb". Note: we
|
||
don't check for BSD location of pxdb, nor for existance
|
||
of pxdb itself, etc.
|
||
|
||
NOTE: uses system function and string functions directly.
|
||
|
||
Return value: 1 if ok, 0 if not */
|
||
int
|
||
hpread_call_pxdb (file_name)
|
||
char *file_name;
|
||
{
|
||
char *p;
|
||
int status;
|
||
int retval;
|
||
|
||
if (file_exists (PXDB_SVR4))
|
||
{
|
||
p = malloc (strlen (PXDB_SVR4) + strlen (file_name) + 2);
|
||
strcpy (p, PXDB_SVR4);
|
||
strcat (p, " ");
|
||
strcat (p, file_name);
|
||
|
||
warning ("File not processed by pxdb--about to process now.\n");
|
||
status = system (p);
|
||
|
||
retval = (status == 0);
|
||
}
|
||
else
|
||
{
|
||
warning ("pxdb not found at standard location: /opt/langtools/bin\ngdb will not be able to debug %s.\nPlease install pxdb at the above location and then restart gdb.\nYou can also run pxdb on %s with the command\n\"pxdb %s\" and then restart gdb.", file_name, file_name, file_name);
|
||
|
||
retval = 0;
|
||
}
|
||
return retval;
|
||
} /* hpread_call_pxdb */
|
||
|
||
|
||
/* Return 1 if the file turns out to need pre-processing
|
||
by PXDB, and we have thus called PXDB to do this processing
|
||
and the file therefore needs to be re-loaded. Otherwise
|
||
return 0. */
|
||
int
|
||
hpread_pxdb_needed (sym_bfd)
|
||
bfd *sym_bfd;
|
||
{
|
||
asection *pinfo_section, *debug_section, *header_section;
|
||
unsigned int do_pxdb;
|
||
char *buf;
|
||
bfd_size_type header_section_size;
|
||
|
||
unsigned long tmp;
|
||
unsigned int pxdbed;
|
||
|
||
header_section = bfd_get_section_by_name (sym_bfd, "$HEADER$");
|
||
if (!header_section)
|
||
{
|
||
return 0; /* No header at all, can't recover... */
|
||
}
|
||
|
||
debug_section = bfd_get_section_by_name (sym_bfd, "$DEBUG$");
|
||
pinfo_section = bfd_get_section_by_name (sym_bfd, "$PINFO$");
|
||
|
||
if (pinfo_section && !debug_section)
|
||
{
|
||
/* Debug info with DOC, has different header format. */
|
||
/* this only happens if the file was pxdbed and compiled optimized
|
||
otherwise the PINFO section is not there. */
|
||
header_section_size = bfd_section_size (objfile->obfd, header_section);
|
||
|
||
if (header_section_size == (bfd_size_type)sizeof (DOC_info_PXDB_header))
|
||
{
|
||
buf = alloca (sizeof (DOC_info_PXDB_header));
|
||
|
||
if (!bfd_get_section_contents (sym_bfd,
|
||
header_section,
|
||
buf, 0,
|
||
header_section_size))
|
||
error ("bfd_get_section_contents\n");
|
||
|
||
tmp = bfd_get_32 (sym_bfd, (bfd_byte *)(buf + sizeof (int)*4));
|
||
pxdbed = (tmp >> 31) & 0x1;
|
||
|
||
if (!pxdbed) error ("file debug header info invalid\n");
|
||
do_pxdb = 0;
|
||
}
|
||
|
||
else error ("invalid $HEADER$ size in executable \n");
|
||
}
|
||
|
||
else {
|
||
|
||
/* this can be three different cases:
|
||
1. pxdbed and not doc
|
||
- DEBUG and HEADER sections are there
|
||
- header is PXDB_header type
|
||
- pxdbed flag is set to 1
|
||
|
||
2. not pxdbed and doc
|
||
- DEBUG and HEADER sections are there
|
||
- header is DOC_info_header type
|
||
- pxdbed flag is set to 0
|
||
|
||
3. not pxdbed and not doc
|
||
- DEBUG and HEADER sections are there
|
||
- header is XDB_header type
|
||
- pxdbed flag is set to 0
|
||
|
||
NOTE: the pxdbed flag is meaningful also in the not
|
||
already pxdb processed version of the header,
|
||
because in case on non-already processed by pxdb files
|
||
that same bit in the header would be always zero.
|
||
Why? Because the bit is the leftmost bit of a word
|
||
which contains a 'length' which is always a positive value
|
||
so that bit is never set to 1 (otherwise it would be negative)
|
||
|
||
Given the above, we have two choices : either we ignore the
|
||
size of the header itself and just look at the pxdbed field,
|
||
or we check the size and then we (for safety and paranoia related
|
||
issues) check the bit.
|
||
The first solution is used by DDE, the second by PXDB itself.
|
||
I am using the second one here, because I already wrote it,
|
||
and it is the end of a long day.
|
||
Also, using the first approach would still involve size issues
|
||
because we need to read in the contents of the header section, and
|
||
give the correct amount of stuff we want to read to the
|
||
get_bfd_section_contents function. */
|
||
|
||
/* decide which case depending on the size of the header section.
|
||
The size is as defined in hp-symtab.h */
|
||
|
||
header_section_size = bfd_section_size (objfile->obfd, header_section);
|
||
|
||
if (header_section_size == (bfd_size_type)sizeof (PXDB_header)) /* pxdb and not doc*/
|
||
{
|
||
|
||
buf = alloca (sizeof(PXDB_header));
|
||
if (!bfd_get_section_contents (sym_bfd,
|
||
header_section,
|
||
buf, 0,
|
||
header_section_size))
|
||
error ("bfd_get_section_contents\n");
|
||
|
||
tmp = bfd_get_32 (sym_bfd, (bfd_byte *)(buf + sizeof(int)*3));
|
||
pxdbed = (tmp >> 31) & 0x1;
|
||
|
||
if (pxdbed)
|
||
do_pxdb = 0;
|
||
else error ("file debug header invalid\n");
|
||
}
|
||
else /*not pxdbed and doc OR not pxdbed and non doc*/
|
||
do_pxdb = 1;
|
||
}
|
||
|
||
if (do_pxdb)
|
||
{
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
return 0;
|
||
}
|
||
} /* hpread_pxdb_needed */
|
||
|
||
#endif
|
||
|
||
#ifdef QUICK_LOOK_UP
|
||
|
||
/********************
|
||
*
|
||
* This flag can be set to zero to use the old
|
||
* style psymtab (build from a scan of the LNTT)
|
||
* or to one to try to use the quick look-up
|
||
* tables.
|
||
*/
|
||
int psym_new_style = 1;
|
||
|
||
|
||
|
||
/* Code to handle quick lookup-tables follows */
|
||
|
||
|
||
/* Some useful macros */
|
||
#define VALID_FILE(i) ((i) < pxdb_header_p->fd_entries)
|
||
#define VALID_MODULE(i) ((i) < pxdb_header_p->md_entries)
|
||
#define VALID_PROC(i) ((i) < pxdb_header_p->pd_entries)
|
||
#define VALID_CLASS(i) ((i) < pxdb_header_p->cd_entries)
|
||
|
||
#define FILE_START(i) (qFD[i].adrStart)
|
||
#define MODULE_START(i) (qMD[i].adrStart)
|
||
#define PROC_START(i) (qPD[i].adrStart)
|
||
|
||
#define FILE_END(i) (qFD[i].adrEnd)
|
||
#define MODULE_END(i) (qMD[i].adrEnd)
|
||
#define PROC_END(i) (qPD[i].adrEnd)
|
||
|
||
#define FILE_ISYM(i) (qFD[i].isym)
|
||
#define MODULE_ISYM(i) (qMD[i].isym)
|
||
#define PROC_ISYM(i) (qPD[i].isym)
|
||
|
||
#define VALID_CURR_FILE (curr_fd < pxdb_header_p->fd_entries)
|
||
#define VALID_CURR_MODULE (curr_md < pxdb_header_p->md_entries)
|
||
#define VALID_CURR_PROC (curr_pd < pxdb_header_p->pd_entries)
|
||
#define VALID_CURR_CLASS (curr_cd < pxdb_header_p->cd_entries)
|
||
|
||
#define CURR_FILE_START (qFD[curr_fd].adrStart)
|
||
#define CURR_MODULE_START (qMD[curr_md].adrStart)
|
||
#define CURR_PROC_START (qPD[curr_pd].adrStart)
|
||
|
||
#define CURR_FILE_END (qFD[curr_fd].adrEnd)
|
||
#define CURR_MODULE_END (qMD[curr_md].adrEnd)
|
||
#define CURR_PROC_END (qPD[curr_pd].adrEnd)
|
||
|
||
#define CURR_FILE_ISYM (qFD[curr_fd].isym)
|
||
#define CURR_MODULE_ISYM (qMD[curr_md].isym)
|
||
#define CURR_PROC_ISYM (qPD[curr_pd].isym)
|
||
|
||
#define TELL_OBJFILE \
|
||
do { \
|
||
if( !told_objfile ) { \
|
||
told_objfile = 1; \
|
||
warning ("\nIn object file \"%s\":\n", \
|
||
objfile->name); \
|
||
} \
|
||
} while (0)
|
||
|
||
|
||
|
||
/* Keeping track of the start/end symbol table (LNTT) indices of
|
||
psymtabs created so far */
|
||
|
||
typedef struct {
|
||
int start;
|
||
int end;
|
||
} pst_syms_struct;
|
||
|
||
static pst_syms_struct * pst_syms_array = 0;
|
||
|
||
static pst_syms_count = 0;
|
||
static pst_syms_size = 0;
|
||
|
||
/* used by the TELL_OBJFILE macro */
|
||
static boolean told_objfile = 0;
|
||
|
||
/* Set up psymtab symbol index stuff */
|
||
static void
|
||
init_pst_syms ()
|
||
{
|
||
pst_syms_count = 0;
|
||
pst_syms_size = 20;
|
||
pst_syms_array = (pst_syms_struct *) xmalloc (20 * sizeof (pst_syms_struct));
|
||
}
|
||
|
||
/* Clean up psymtab symbol index stuff */
|
||
static void
|
||
clear_pst_syms ()
|
||
{
|
||
pst_syms_count = 0;
|
||
pst_syms_size = 0;
|
||
free (pst_syms_array);
|
||
pst_syms_array = 0;
|
||
}
|
||
|
||
/* Add information about latest psymtab to symbol index table */
|
||
static void
|
||
record_pst_syms (start_sym, end_sym)
|
||
int start_sym;
|
||
int end_sym;
|
||
{
|
||
if (++pst_syms_count > pst_syms_size)
|
||
{
|
||
pst_syms_array = (pst_syms_struct *) xrealloc (pst_syms_array,
|
||
2 * pst_syms_size * sizeof (pst_syms_struct));
|
||
pst_syms_size *= 2;
|
||
}
|
||
pst_syms_array[pst_syms_count - 1].start = start_sym;
|
||
pst_syms_array[pst_syms_count - 1].end = end_sym;
|
||
}
|
||
|
||
/* Find a suitable symbol table index which can serve as the upper
|
||
bound of a psymtab that starts at INDEX
|
||
|
||
This scans backwards in the psymtab symbol index table to find a
|
||
"hole" in which the given index can fit. This is a heuristic!!
|
||
We don't search the entire table to check for multiple holes,
|
||
we don't care about overlaps, etc.
|
||
|
||
Return 0 => not found */
|
||
|
||
static int
|
||
find_next_pst_start (index)
|
||
int index;
|
||
{
|
||
int i;
|
||
|
||
for (i = pst_syms_count - 1; i >= 0; i--)
|
||
if (pst_syms_array[i].end <= index)
|
||
return (i == pst_syms_count - 1) ? 0 : pst_syms_array[i+1].start - 1;
|
||
|
||
if (pst_syms_array[0].start > index)
|
||
return pst_syms_array[0].start - 1;
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/* Utility functions to find the ending symbol index for a psymtab */
|
||
|
||
/* Find the next file entry that begins beyond INDEX, and return
|
||
its starting symbol index - 1.
|
||
QFD is the file table, CURR_FD is the file entry from where to start,
|
||
PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
|
||
|
||
Return 0 => not found */
|
||
|
||
static int
|
||
find_next_file_isym (index, qFD, curr_fd, pxdb_header_p)
|
||
int index;
|
||
quick_file_entry *qFD;
|
||
int curr_fd;
|
||
PXDB_header_ptr pxdb_header_p;
|
||
{
|
||
while (VALID_CURR_FILE) {
|
||
if (CURR_FILE_ISYM >= index)
|
||
return CURR_FILE_ISYM - 1;
|
||
curr_fd++;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Find the next procedure entry that begins beyond INDEX, and return
|
||
its starting symbol index - 1.
|
||
QPD is the procedure table, CURR_PD is the proc entry from where to start,
|
||
PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
|
||
|
||
Return 0 => not found */
|
||
|
||
static int
|
||
find_next_proc_isym (index, qPD, curr_pd, pxdb_header_p)
|
||
int index;
|
||
quick_procedure_entry *qPD;
|
||
int curr_pd;
|
||
PXDB_header_ptr pxdb_header_p;
|
||
{
|
||
while (VALID_CURR_PROC) {
|
||
if (CURR_PROC_ISYM >= index)
|
||
return CURR_PROC_ISYM - 1;
|
||
curr_pd++;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Find the next module entry that begins beyond INDEX, and return
|
||
its starting symbol index - 1.
|
||
QMD is the module table, CURR_MD is the modue entry from where to start,
|
||
PXDB_HEADER_P as in hpread_quick_traverse (to allow macros to work).
|
||
|
||
Return 0 => not found */
|
||
|
||
static int
|
||
find_next_module_isym (index, qMD, curr_md, pxdb_header_p)
|
||
int index;
|
||
quick_module_entry *qMD;
|
||
int curr_md;
|
||
PXDB_header_ptr pxdb_header_p;
|
||
{
|
||
while (VALID_CURR_MODULE) {
|
||
if (CURR_MODULE_ISYM >= index)
|
||
return CURR_MODULE_ISYM - 1;
|
||
curr_md++;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* Scan and record partial symbols for all functions starting from index
|
||
pointed to by CURR_PD_P, and between code addresses START_ADR and END_ADR.
|
||
Other parameters are explained in comments below. */
|
||
|
||
/* This used to be inline in hpread_quick_traverse, but now that we do essentially the
|
||
same thing for two different cases (modules and module-less files), it's better
|
||
organized in a separate routine, although it does take lots of arguments. pai/1997-10-08 */
|
||
|
||
static int
|
||
scan_procs (curr_pd_p, qPD, max_procs, start_adr, end_adr, pst, vt_bits, objfile, section_offsets)
|
||
int * curr_pd_p; /* pointer to current proc index */
|
||
quick_procedure_entry * qPD; /* the procedure quick lookup table */
|
||
int max_procs; /* number of entries in proc. table */
|
||
CORE_ADDR start_adr; /* beginning of code range for current psymtab */
|
||
CORE_ADDR end_adr; /* end of code range for current psymtab */
|
||
struct partial_symtab * pst; /* current psymtab */
|
||
char * vt_bits; /* strings table of SOM debug space */
|
||
struct objfile * objfile; /* current object file */
|
||
struct section_offsets * section_offsets; /* not really used for HP-UX currently */
|
||
{
|
||
union dnttentry *dn_bufp;
|
||
int symbol_count = 0; /* Total number of symbols in this psymtab */
|
||
int curr_pd = *curr_pd_p; /* Convenience variable -- avoid dereferencing pointer all the time */
|
||
|
||
#ifdef DUMPING
|
||
/* Turn this on for lots of debugging information in this routine */
|
||
static int dumping = 0;
|
||
#endif
|
||
|
||
#ifdef DUMPING
|
||
if (dumping) {
|
||
printf ("Scan_procs called, addresses %x to %x, proc %x\n", start_adr, end_adr, curr_pd);
|
||
}
|
||
#endif
|
||
|
||
while((CURR_PROC_START <= end_adr) && (curr_pd < max_procs)) {
|
||
|
||
char *rtn_name; /* mangled name */
|
||
char *rtn_dem_name; /* qualified demangled name */
|
||
char *class_name;
|
||
int class;
|
||
|
||
if ((trans_lang ((enum hp_language) qPD[curr_pd].language) == language_cplus) &&
|
||
vt_bits[ (long) qPD[curr_pd].sbAlias]) /* not a null string */
|
||
{
|
||
/* Get mangled name for the procedure, and demangle it */
|
||
rtn_name = &vt_bits[ (long)qPD[curr_pd].sbAlias ];
|
||
rtn_dem_name = cplus_demangle (rtn_name, DMGL_ANSI | DMGL_PARAMS);
|
||
}
|
||
else
|
||
{
|
||
rtn_name = &vt_bits[ (long)qPD[curr_pd].sbProc ];
|
||
rtn_dem_name = NULL;
|
||
}
|
||
|
||
/* Hack to get around HP C/C++ compilers' insistence on providing
|
||
* "_MAIN_" as an alternate name for "main" */
|
||
if ((strcmp (rtn_name, "_MAIN_") == 0) &&
|
||
(strcmp (&vt_bits[ (long)qPD[curr_pd].sbProc ], "main") == 0))
|
||
rtn_dem_name = rtn_name = main_string;
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "..add %s (demangled %s), index %x to this psymtab\n", rtn_name, rtn_dem_name, curr_pd);
|
||
}
|
||
#endif
|
||
|
||
/* Check for module-spanning routines.
|
||
*/
|
||
if(CURR_PROC_END > end_adr ) {
|
||
TELL_OBJFILE;
|
||
warning ("Procedure \"%s\" [0x%x] spans file or module boundaries.", rtn_name, curr_pd);
|
||
}
|
||
|
||
/* I asked for this in the hope it would fix bug CHFts22228, but
|
||
* later decided it's not the right fix. I'm leaving the code
|
||
* commented out for now in case we decide we actually want to do this.
|
||
* - RT
|
||
*/
|
||
#if 0
|
||
/* Check this routine--if it's a class member function,
|
||
* add the class to the psymtab. We only need to add
|
||
* the class once in each module, so check.
|
||
*/
|
||
if( qPD[curr_pd].member ) {
|
||
|
||
class = qPD[curr_pd].icd;
|
||
if( ! B_TST( class_entered, class)) { /* pai: (temp) class_entered not a parameter */
|
||
|
||
class_name = &vt_bits[ (long)qCD[class].sbClass ];
|
||
|
||
/* Add to both the struct and var namespace */
|
||
|
||
add_psymbol_to_list (
|
||
class_name,
|
||
strlen( class_name ),
|
||
STRUCT_NAMESPACE,
|
||
LOC_UNDEF, /* "I have no storage" */
|
||
&objfile->global_psymbols, /* assume classname is global */
|
||
0, 0,
|
||
trans_lang ((enum hp_language) qPD[curr_pd].language),
|
||
objfile );
|
||
|
||
add_psymbol_to_list (
|
||
class_name,
|
||
strlen( class_name ),
|
||
VAR_NAMESPACE,
|
||
LOC_UNDEF, /* "I have no storage" */
|
||
&objfile->global_psymbols, /* assume classname is global */
|
||
0, 0,
|
||
trans_lang ((enum hp_language) qPD[curr_pd].language),
|
||
objfile );
|
||
|
||
B_SET( class_entered, class ); /* pai: (temp) class_entered not a parameter */
|
||
symbol_count++;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/* Add this routine symbol to the list in the objfile. */
|
||
/* Unfortunately we have to go to the LNTT to determine the
|
||
* correct list to put it on. An alternative (which the
|
||
* code used to do) would be to not check and always throw
|
||
* it on the "static" list. But if we go that route, then
|
||
* symbol_lookup() needs to be tweaked a bit to account
|
||
* for the fact that the function might not be found on
|
||
* the correct list in the psymtab. - RT
|
||
*/
|
||
dn_bufp = hpread_get_lntt (qPD[curr_pd].isym, objfile);
|
||
if (dn_bufp->dfunc.global)
|
||
add_psymbol_with_dem_name_to_list (
|
||
rtn_name,
|
||
strlen( rtn_name ),
|
||
rtn_dem_name,
|
||
strlen( rtn_dem_name ),
|
||
VAR_NAMESPACE,
|
||
LOC_BLOCK, /* "I am a routine" */
|
||
&objfile->global_psymbols,
|
||
( qPD[curr_pd].adrStart + /* Starting address of rtn */
|
||
ANOFFSET (section_offsets, SECT_OFF_TEXT)),
|
||
0, /* core addr?? */
|
||
trans_lang ((enum hp_language) qPD[curr_pd].language),
|
||
objfile );
|
||
else
|
||
add_psymbol_with_dem_name_to_list (
|
||
rtn_name,
|
||
strlen( rtn_name ),
|
||
rtn_dem_name,
|
||
strlen( rtn_dem_name ),
|
||
VAR_NAMESPACE,
|
||
LOC_BLOCK, /* "I am a routine" */
|
||
&objfile->static_psymbols,
|
||
( qPD[curr_pd].adrStart + /* Starting address of rtn */
|
||
ANOFFSET (section_offsets, SECT_OFF_TEXT)),
|
||
0, /* core addr?? */
|
||
trans_lang ((enum hp_language) qPD[curr_pd].language),
|
||
objfile );
|
||
|
||
symbol_count++;
|
||
*curr_pd_p = ++curr_pd; /* bump up count & reflect in caller */
|
||
} /* loop over procedures */
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
if( symbol_count == 0 )
|
||
printf( "Scan_procs: no symbols found!\n");
|
||
}
|
||
#endif
|
||
|
||
return symbol_count;
|
||
}
|
||
|
||
|
||
/* Traverse the quick look-up tables, building a set of psymtabs.
|
||
*
|
||
* This constructs a psymtab for modules and files in the quick lookup
|
||
* tables.
|
||
*
|
||
* Mostly, modules correspond to compilation units, so we try to
|
||
* create psymtabs that correspond to modules; however, in some cases
|
||
* a file can result in a compiled object which does not have a module
|
||
* entry for it, so in such cases we create a psymtab for the file.
|
||
*/
|
||
|
||
int
|
||
hpread_quick_traverse(
|
||
objfile, /* The object file descriptor */
|
||
section_offsets, /* ?? Null for HP */
|
||
gntt_bits, /* GNTT entries, loaded in from the file */
|
||
vt_bits, /* VT (string) entries ditto. */
|
||
pxdb_header_p ) /* Pointer to pxdb header ditto */
|
||
|
||
struct objfile *objfile;
|
||
struct section_offsets *section_offsets;
|
||
char *gntt_bits;
|
||
char *vt_bits;
|
||
PXDB_header_ptr pxdb_header_p;
|
||
{
|
||
struct partial_symtab *pst;
|
||
|
||
char *addr;
|
||
|
||
quick_procedure_entry *qPD;
|
||
quick_file_entry *qFD;
|
||
quick_module_entry *qMD;
|
||
quick_class_entry *qCD;
|
||
|
||
int idx;
|
||
int i;
|
||
CORE_ADDR start_adr; /* current psymtab's starting code addr */
|
||
CORE_ADDR end_adr; /* current psymtab's ending code addr */
|
||
CORE_ADDR next_mod_adr; /* next module's starting code addr */
|
||
int curr_pd; /* current procedure */
|
||
int curr_fd; /* current file */
|
||
int curr_md; /* current module */
|
||
int start_sym; /* current psymtab's starting symbol index */
|
||
int end_sym; /* current psymtab's ending symbol index */
|
||
int max_LNTT_sym_index;
|
||
int syms_in_pst;
|
||
B_TYPE *class_entered;
|
||
|
||
struct partial_symbol **global_syms; /* We'll be filling in the "global" */
|
||
struct partial_symbol **static_syms; /* and "static" tables in the objfile */
|
||
/* as we go, so we need a pair of */
|
||
/* current pointers. */
|
||
|
||
#ifdef DUMPING
|
||
/* Turn this on for lots of debugging information in this routine.
|
||
You get a blow-by-blow account of quick lookup table reading */
|
||
static int dumping = 0;
|
||
#endif
|
||
|
||
pst = (struct partial_symtab *) 0;
|
||
|
||
/* Clear out some globals */
|
||
init_pst_syms ();
|
||
told_objfile = 0;
|
||
|
||
/* Demangling style -- if EDG style already set, don't change it,
|
||
as HP style causes some problems with the KAI EDG compiler */
|
||
if (current_demangling_style != edg_demangling) {
|
||
/* Otherwise, ensure that we are using HP style demangling */
|
||
set_demangling_style (HP_DEMANGLING_STYLE_STRING);
|
||
}
|
||
|
||
/* First we need to find the starting points of the quick
|
||
* look-up tables in the GNTT. */
|
||
|
||
addr = gntt_bits;
|
||
|
||
qPD = (quick_procedure_entry_ptr) addr;
|
||
addr += pxdb_header_p->pd_entries * sizeof( quick_procedure_entry );
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "\n Printing routines as we see them\n" );
|
||
for( i = 0; VALID_PROC (i); i++ ){
|
||
idx = (long) qPD[i].sbProc;
|
||
printf( "%s %x..%x\n", &vt_bits[idx],
|
||
(int) PROC_START (i),
|
||
(int) PROC_END (i) );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
qFD = (quick_file_entry_ptr) addr;
|
||
addr += pxdb_header_p->fd_entries * sizeof( quick_file_entry);
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "\n Printing files as we see them\n" );
|
||
for( i = 0; VALID_FILE (i); i++ ){
|
||
idx = (long) qFD[i].sbFile;
|
||
printf( "%s %x..%x\n", &vt_bits[idx],
|
||
(int) FILE_START(i),
|
||
(int) FILE_END(i) );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
qMD = (quick_module_entry_ptr) addr;
|
||
addr += pxdb_header_p->md_entries * sizeof( quick_module_entry );
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "\n Printing modules as we see them\n" );
|
||
for( i = 0; i < pxdb_header_p->md_entries; i++ ){
|
||
idx = (long) qMD[i].sbMod;
|
||
printf( "%s\n", &vt_bits[idx] );
|
||
}
|
||
}
|
||
#endif
|
||
|
||
qCD = (quick_class_entry_ptr) addr;
|
||
addr += pxdb_header_p->cd_entries * sizeof( quick_class_entry );
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "\n Printing classes as we see them\n" );
|
||
for( i = 0; VALID_CLASS (i); i++ ){
|
||
idx = (long) qCD[i].sbClass;
|
||
printf( "%s\n", &vt_bits[idx] );
|
||
}
|
||
|
||
printf( "\n Done with dump, on to build!\n" );
|
||
}
|
||
#endif
|
||
|
||
/* We need this index only while hp-symtab-read.c expects
|
||
* a byte offset to the end of the LNTT entries for a given
|
||
* psymtab. Thus the need for it should go away someday.
|
||
*
|
||
* When it goes away, then we won't have any need to load the
|
||
* LNTT from the objfile at psymtab-time, and start-up will be
|
||
* faster. To make that work, we'll need some way to create
|
||
* a null pst for the "globals" pseudo-module.
|
||
*/
|
||
max_LNTT_sym_index = LNTT_SYMCOUNT (objfile);
|
||
|
||
/* Scan the module descriptors and make a psymtab for each.
|
||
*
|
||
* We know the MDs, FDs and the PDs are in order by starting
|
||
* address. We use that fact to traverse all three arrays in
|
||
* parallel, knowing when the next PD is in a new file
|
||
* and we need to create a new psymtab.
|
||
*/
|
||
curr_pd = 0; /* Current procedure entry */
|
||
curr_fd = 0; /* Current file entry */
|
||
curr_md = 0; /* Current module entry */
|
||
|
||
start_adr = 0; /* Current psymtab code range */
|
||
end_adr = 0;
|
||
|
||
start_sym = 0; /* Current psymtab symbol range */
|
||
end_sym = 0;
|
||
|
||
syms_in_pst = 0; /* Symbol count for psymtab */
|
||
|
||
/* Psts actually just have pointers into the objfile's
|
||
* symbol table, not their own symbol tables.
|
||
*/
|
||
global_syms = objfile -> global_psymbols.list;
|
||
static_syms = objfile -> static_psymbols.list;
|
||
|
||
#if 0 /* pai: (temp) we don't need this any more */
|
||
/* elz: if the first module we see in the table is for
|
||
end.c, then return immediately with false. This happens
|
||
for F77 programs, for which there is no MODULE information
|
||
produced in the debug info.
|
||
Returning false from this function will make the caller
|
||
(build_psymbols) scan the table from the beginning and
|
||
not use the quick lookup tables.
|
||
F90 has modules so this poses no porblem.
|
||
*/
|
||
if (!strcmp (&vt_bits[(long)qMD[0].sbMod], "end.c"))
|
||
return 0;
|
||
#endif
|
||
|
||
/* First skip over pseudo-entries with address 0. These represent inlined
|
||
routines and abstract (uninstantiated) template routines.
|
||
FIXME: These should be read in and available -- even if we can't set
|
||
breakpoints, etc., there's some information that can be presented
|
||
to the user. pai/1997-10-08 */
|
||
|
||
while (VALID_CURR_PROC && (CURR_PROC_START == 0))
|
||
curr_pd++;
|
||
|
||
/* Loop over files, modules, and procedures in code address order. Each
|
||
time we enter an iteration of this loop, curr_pd points to the first
|
||
unprocessed procedure, curr_fd points to the first unprocessed file, and
|
||
curr_md to the first unprocessed module. Each iteration of this loop
|
||
updates these as required -- any or all of them may be bumpd up
|
||
each time around. When we exit this loop, we are done with all files
|
||
and modules in the tables -- there may still be some procedures, however.
|
||
|
||
Note: This code used to loop only over module entries, under the assumption
|
||
that files can occur via inclusions and are thus unreliable, while a
|
||
compiled object always corresponds to a module. With CTTI in the HP aCC
|
||
compiler, it turns out that compiled objects may have only files and no
|
||
modules; so we have to loop over files and modules, creating psymtabs for
|
||
either as appropriate. Unfortunately there are some problems (notably:
|
||
1. the lack of "SRC_FILE_END" entries in the LNTT, 2. the lack of pointers
|
||
to the ending symbol indices of a module or a file) which make it quite hard
|
||
to do this correctly. Currently it uses a bunch of heuristics to start and
|
||
end psymtabs; they seem to work well with most objects generated by aCC, but
|
||
who knows when that will change... */
|
||
|
||
while (VALID_CURR_FILE || VALID_CURR_MODULE) {
|
||
|
||
char *mod_name_string;
|
||
char *full_name_string;
|
||
|
||
/* First check for modules like "version.c", which have no code
|
||
* in them but still have qMD entries. They also have no qFD or
|
||
* qPD entries. Their start address is -1 and their end address
|
||
* is 0. */
|
||
if(VALID_CURR_MODULE && (CURR_MODULE_START == -1) && (CURR_MODULE_END == NULL)) {
|
||
|
||
mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
|
||
|
||
#ifdef DUMPING
|
||
if( dumping )
|
||
printf( "Module with data only %s\n", mod_name_string );
|
||
#endif
|
||
|
||
/* We'll skip the rest (it makes error-checking easier), and
|
||
* just make an empty pst. Right now empty psts are not put
|
||
* in the pst chain, so all this is for naught, but later it
|
||
* might help. */
|
||
|
||
pst = hpread_start_psymtab( objfile,
|
||
section_offsets, /* ?? */
|
||
mod_name_string,
|
||
CURR_MODULE_START, /* Low text address: bogus! */
|
||
(CURR_MODULE_ISYM * sizeof (struct dntt_type_block)),
|
||
/* ldsymoff */
|
||
global_syms,
|
||
static_syms );
|
||
|
||
pst = hpread_end_psymtab (
|
||
pst,
|
||
NULL, /* psymtab_include_list */
|
||
0, /* includes_used */
|
||
end_sym * sizeof (struct dntt_type_block),
|
||
/* byte index in LNTT of end */
|
||
/* = capping symbol offset */
|
||
/* = LDSYMOFF of nextfile */
|
||
NULL, /* text high */
|
||
NULL, /* dependency_list */
|
||
0 ); /* dependencies_used */
|
||
|
||
global_syms = objfile->global_psymbols.next;
|
||
static_syms = objfile->static_psymbols.next;
|
||
|
||
curr_md++;
|
||
}
|
||
else if (VALID_CURR_MODULE &&
|
||
((CURR_MODULE_START == 0) || (CURR_MODULE_START == -1) ||
|
||
(CURR_MODULE_END == 0) || (CURR_MODULE_END == -1))) {
|
||
TELL_OBJFILE;
|
||
warning ("Module \"%s\" [0x%x] has non-standard addresses. It starts at 0x%x, ends at 0x%x, and will be skipped.",
|
||
mod_name_string, curr_md, start_adr, end_adr);
|
||
/* On to next module */
|
||
curr_md ++;
|
||
}
|
||
else {
|
||
/* First check if we are looking at a file with code in it
|
||
that does not overlap the current module's code range */
|
||
|
||
if (VALID_CURR_FILE ? (VALID_CURR_MODULE ? (CURR_FILE_END < CURR_MODULE_START) : 1) : 0) {
|
||
|
||
/* Looking at file not corresponding to any module,
|
||
create a psymtab for it */
|
||
full_name_string = &vt_bits[(long) qFD[curr_fd].sbFile];
|
||
start_adr = CURR_FILE_START;
|
||
end_adr = CURR_FILE_END;
|
||
start_sym = CURR_FILE_ISYM;
|
||
|
||
/* Check if there are any procedures not handled until now, that
|
||
begin before the start address of this file, and if so, adjust
|
||
this module's start address to include them. This handles routines that
|
||
are in between file or module ranges for some reason (probably
|
||
indicates a compiler bug */
|
||
|
||
if (CURR_PROC_START < start_adr) {
|
||
TELL_OBJFILE;
|
||
warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
|
||
&vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
|
||
start_adr = CURR_PROC_START;
|
||
if (CURR_PROC_ISYM < start_sym)
|
||
start_sym = CURR_PROC_ISYM;
|
||
}
|
||
|
||
/* Sometimes (compiler bug -- COBOL) the module end address is higher
|
||
than the start address of the next module, so check for that and
|
||
adjust accordingly */
|
||
|
||
if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) {
|
||
TELL_OBJFILE;
|
||
warning("File \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
|
||
full_name_string, curr_fd);
|
||
end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
|
||
}
|
||
if (VALID_MODULE (curr_md) && (CURR_MODULE_START <= end_adr)) {
|
||
TELL_OBJFILE;
|
||
warning("File \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
|
||
full_name_string, curr_fd);
|
||
end_adr = CURR_MODULE_START - 1; /* Is -4 (or -8 for 64-bit) better? */
|
||
}
|
||
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "Make new psymtab for file %s (%x to %x).\n",
|
||
full_name_string, start_adr, end_adr );
|
||
}
|
||
#endif
|
||
/* Create the basic psymtab, connecting it in the list
|
||
* for this objfile and pointing its symbol entries
|
||
* to the current end of the symbol areas in the objfile.
|
||
*
|
||
* The "ldsymoff" parameter is the byte offset in the LNTT
|
||
* of the first symbol in this file. Some day we should
|
||
* turn this into an index (fix in hp-symtab-read.c as well).
|
||
* And it's not even the right byte offset, as we're using
|
||
* the size of a union! FIXME! */
|
||
pst = hpread_start_psymtab( objfile,
|
||
section_offsets, /* ?? */
|
||
full_name_string,
|
||
start_adr, /* Low text address */
|
||
(start_sym * sizeof (struct dntt_type_block)),
|
||
/* ldsymoff */
|
||
global_syms,
|
||
static_syms );
|
||
|
||
/* Set up to only enter each class referenced in this module once. */
|
||
class_entered = malloc( B_BYTES( pxdb_header_p->cd_entries ));
|
||
B_CLRALL( class_entered, pxdb_header_p->cd_entries );
|
||
|
||
/* Scan the procedure descriptors for procedures in the current
|
||
* file, based on the starting addresses. */
|
||
|
||
syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
|
||
start_adr, end_adr,
|
||
pst, vt_bits, objfile, section_offsets);
|
||
|
||
/* Get ending symbol offset */
|
||
|
||
end_sym = 0;
|
||
/* First check for starting index before previous psymtab */
|
||
if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) {
|
||
end_sym = find_next_pst_start (start_sym);
|
||
}
|
||
/* Look for next start index of a file or module, or procedure */
|
||
if (!end_sym) {
|
||
int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
|
||
int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md, pxdb_header_p);
|
||
int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
|
||
|
||
if (next_file_isym && next_module_isym) {
|
||
/* pick lower of next file or module start index */
|
||
end_sym = min (next_file_isym, next_module_isym);
|
||
}
|
||
else {
|
||
/* one of them is zero, pick the other */
|
||
end_sym = max (next_file_isym, next_module_isym);
|
||
}
|
||
|
||
/* As a precaution, check next procedure index too */
|
||
if (!end_sym)
|
||
end_sym = next_proc_isym;
|
||
else
|
||
end_sym = min (end_sym, next_proc_isym);
|
||
}
|
||
|
||
/* Couldn't find procedure, file, or module, use globals as default */
|
||
if (!end_sym)
|
||
end_sym = pxdb_header_p->globals;
|
||
|
||
#ifdef DUMPING
|
||
if (dumping) {
|
||
printf ("File psymtab indices: %x to %x\n", start_sym, end_sym);
|
||
}
|
||
#endif
|
||
|
||
pst = hpread_end_psymtab (
|
||
pst,
|
||
NULL, /* psymtab_include_list */
|
||
0, /* includes_used */
|
||
end_sym * sizeof (struct dntt_type_block),
|
||
/* byte index in LNTT of end */
|
||
/* = capping symbol offset */
|
||
/* = LDSYMOFF of nextfile */
|
||
end_adr, /* text high */
|
||
NULL, /* dependency_list */
|
||
0 ); /* dependencies_used */
|
||
|
||
record_pst_syms (start_sym, end_sym);
|
||
|
||
if( NULL == pst )
|
||
warning ("No symbols in psymtab for file \"%s\" [0x%x].", full_name_string, curr_fd);
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "Made new psymtab for file %s (%x to %x), sym %x to %x.\n",
|
||
full_name_string, start_adr, end_adr, CURR_FILE_ISYM, end_sym);
|
||
}
|
||
#endif
|
||
/* Prepare for the next psymtab.
|
||
*/
|
||
global_syms = objfile->global_psymbols.next;
|
||
static_syms = objfile->static_psymbols.next;
|
||
free( class_entered );
|
||
|
||
curr_fd++;
|
||
} /* Psymtab for file */
|
||
else {
|
||
/* We have a module for which we create a psymtab */
|
||
|
||
mod_name_string = &vt_bits[(long) qMD[curr_md].sbMod];
|
||
|
||
/* We will include the code ranges of any files that happen to
|
||
overlap with this module */
|
||
|
||
/* So, first pick the lower of the file's and module's start addresses */
|
||
start_adr = CURR_MODULE_START;
|
||
if (VALID_CURR_FILE) {
|
||
if (CURR_FILE_START < CURR_MODULE_START) {
|
||
TELL_OBJFILE;
|
||
warning ("File \"%s\" [0x%x] crosses beginning of module \"%s\".",
|
||
&vt_bits[ (long) qFD[curr_fd].sbFile],
|
||
curr_fd, mod_name_string);
|
||
|
||
start_adr = CURR_FILE_START;
|
||
}
|
||
}
|
||
|
||
/* Also pick the lower of the file's and the module's start symbol indices */
|
||
start_sym = CURR_MODULE_ISYM;
|
||
if (VALID_CURR_FILE && (CURR_FILE_ISYM < CURR_MODULE_ISYM))
|
||
start_sym = CURR_FILE_ISYM;
|
||
|
||
/* For the end address, we scan through the files till we find one
|
||
that overlaps the current module but ends beyond it; if no such file exists we
|
||
simply use the module's start address. (Note, if file entries themselves overlap
|
||
we take the longest overlapping extension beyond the end of the module...)
|
||
We assume that modules never overlap. */
|
||
|
||
end_adr = CURR_MODULE_END;
|
||
|
||
if (VALID_CURR_FILE) {
|
||
while (VALID_CURR_FILE && (CURR_FILE_START < end_adr)) {
|
||
|
||
#ifdef DUMPING
|
||
if( dumping )
|
||
printf( "Maybe skipping file %s which overlaps with module %s\n",
|
||
&vt_bits[ (long) qFD[ curr_fd ].sbFile], mod_name_string );
|
||
#endif
|
||
if (CURR_FILE_END > end_adr) {
|
||
TELL_OBJFILE;
|
||
warning ("File \"%s\" [0x%x] crosses end of module \"%s\".",
|
||
&vt_bits[ (long) qFD[curr_fd].sbFile],
|
||
curr_fd, mod_name_string);
|
||
end_adr = CURR_FILE_END;
|
||
}
|
||
curr_fd++;
|
||
}
|
||
curr_fd--; /* back up after going too far */
|
||
}
|
||
|
||
/* Sometimes (compiler bug -- COBOL) the module end address is higher
|
||
than the start address of the next module, so check for that and
|
||
adjust accordingly */
|
||
|
||
if (VALID_MODULE (curr_md + 1) && (MODULE_START (curr_md + 1) <= end_adr)) {
|
||
TELL_OBJFILE;
|
||
warning ("Module \"%s\" [0x%x] has ending address after starting address of next module; adjusting ending address down.",
|
||
mod_name_string, curr_md);
|
||
end_adr = MODULE_START (curr_md + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
|
||
}
|
||
if (VALID_FILE (curr_fd + 1) && (FILE_START (curr_fd + 1) <= end_adr)) {
|
||
TELL_OBJFILE;
|
||
warning ("Module \"%s\" [0x%x] has ending address after starting address of next file; adjusting ending address down.",
|
||
mod_name_string, curr_md);
|
||
end_adr = FILE_START (curr_fd + 1) - 1; /* Is -4 (or -8 for 64-bit) better? */
|
||
}
|
||
|
||
/* Use one file to get the full name for the module. This
|
||
* situation can arise if there is executable code in a #include
|
||
* file. Each file with code in it gets a qFD. Files which don't
|
||
* contribute code don't get a qFD, even if they include files
|
||
* which do, e.g.:
|
||
*
|
||
* body.c: rtn.h:
|
||
* int x; int main() {
|
||
* #include "rtn.h" return x;
|
||
* }
|
||
*
|
||
* There will a qFD for "rtn.h",and a qMD for "body.c",
|
||
* but no qMD for "rtn.h" or qFD for "body.c"!
|
||
*
|
||
* We pick the name of the last file to overlap with this
|
||
* module. C convention is to put include files first. In a
|
||
* perfect world, we could check names and use the file whose full
|
||
* path name ends with the module name. */
|
||
|
||
if (VALID_CURR_FILE)
|
||
full_name_string = &vt_bits[ (long) qFD[curr_fd].sbFile ];
|
||
else
|
||
full_name_string = mod_name_string;
|
||
|
||
/* Check if there are any procedures not handled until now, that
|
||
begin before the start address we have now, and if so, adjust
|
||
this psymtab's start address to include them. This handles routines that
|
||
are in between file or module ranges for some reason (probably
|
||
indicates a compiler bug */
|
||
|
||
if (CURR_PROC_START < start_adr) {
|
||
TELL_OBJFILE;
|
||
warning ("Found procedure \"%s\" [0x%x] that is not in any file or module.",
|
||
&vt_bits[(long) qPD[curr_pd].sbProc], curr_pd);
|
||
start_adr = CURR_PROC_START;
|
||
if (CURR_PROC_ISYM < start_sym)
|
||
start_sym = CURR_PROC_ISYM;
|
||
}
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "Make new psymtab for module %s (%x to %x), using file %s\n",
|
||
mod_name_string, start_adr, end_adr, full_name_string);
|
||
}
|
||
#endif
|
||
/* Create the basic psymtab, connecting it in the list
|
||
* for this objfile and pointing its symbol entries
|
||
* to the current end of the symbol areas in the objfile.
|
||
*
|
||
* The "ldsymoff" parameter is the byte offset in the LNTT
|
||
* of the first symbol in this file. Some day we should
|
||
* turn this into an index (fix in hp-symtab-read.c as well).
|
||
* And it's not even the right byte offset, as we're using
|
||
* the size of a union! FIXME! */
|
||
pst = hpread_start_psymtab( objfile,
|
||
section_offsets, /* ?? */
|
||
full_name_string,
|
||
start_adr, /* Low text address */
|
||
(start_sym * sizeof (struct dntt_type_block)),
|
||
/* ldsymoff */
|
||
global_syms,
|
||
static_syms );
|
||
|
||
/* Set up to only enter each class referenced in this module once. */
|
||
class_entered = malloc( B_BYTES( pxdb_header_p->cd_entries ));
|
||
B_CLRALL( class_entered, pxdb_header_p->cd_entries );
|
||
|
||
/* Scan the procedure descriptors for procedures in the current
|
||
* module, based on the starting addresses. */
|
||
|
||
syms_in_pst = scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
|
||
start_adr, end_adr,
|
||
pst, vt_bits, objfile, section_offsets);
|
||
|
||
/* Get ending symbol offset */
|
||
|
||
end_sym = 0;
|
||
/* First check for starting index before previous psymtab */
|
||
if (pst_syms_count && start_sym < pst_syms_array[pst_syms_count - 1].end) {
|
||
end_sym = find_next_pst_start (start_sym);
|
||
}
|
||
/* Look for next start index of a file or module, or procedure */
|
||
if (!end_sym) {
|
||
int next_file_isym = find_next_file_isym (start_sym, qFD, curr_fd + 1, pxdb_header_p);
|
||
int next_module_isym = find_next_module_isym (start_sym, qMD, curr_md + 1, pxdb_header_p);
|
||
int next_proc_isym = find_next_proc_isym (start_sym, qPD, curr_pd, pxdb_header_p);
|
||
|
||
if (next_file_isym && next_module_isym) {
|
||
/* pick lower of next file or module start index */
|
||
end_sym = min (next_file_isym, next_module_isym);
|
||
}
|
||
else {
|
||
/* one of them is zero, pick the other */
|
||
end_sym = max (next_file_isym, next_module_isym);
|
||
}
|
||
|
||
/* As a precaution, check next procedure index too */
|
||
if (!end_sym)
|
||
end_sym = next_proc_isym;
|
||
else
|
||
end_sym = min (end_sym, next_proc_isym);
|
||
}
|
||
|
||
/* Couldn't find procedure, file, or module, use globals as default */
|
||
if (!end_sym)
|
||
end_sym = pxdb_header_p->globals;
|
||
|
||
#ifdef DUMPING
|
||
if (dumping) {
|
||
printf ("Module psymtab indices: %x to %x\n", start_sym, end_sym);
|
||
}
|
||
#endif
|
||
|
||
pst = hpread_end_psymtab (
|
||
pst,
|
||
NULL, /* psymtab_include_list */
|
||
0, /* includes_used */
|
||
end_sym * sizeof (struct dntt_type_block),
|
||
/* byte index in LNTT of end */
|
||
/* = capping symbol offset */
|
||
/* = LDSYMOFF of nextfile */
|
||
end_adr, /* text high */
|
||
NULL, /* dependency_list */
|
||
0 ); /* dependencies_used */
|
||
|
||
record_pst_syms (start_sym, end_sym);
|
||
|
||
if( NULL == pst )
|
||
warning ("No symbols in psymtab for module \"%s\" [0x%x].", mod_name_string, curr_md);
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "Made new psymtab for module %s (%x to %x), sym %x to %x.\n",
|
||
mod_name_string, start_adr, end_adr, CURR_MODULE_ISYM, end_sym);
|
||
}
|
||
#endif
|
||
|
||
/* Prepare for the next psymtab.
|
||
*/
|
||
global_syms = objfile->global_psymbols.next;
|
||
static_syms = objfile->static_psymbols.next;
|
||
free( class_entered );
|
||
|
||
curr_md++;
|
||
curr_fd++;
|
||
} /* psymtab for module */
|
||
} /* psymtab for non-bogus file or module */
|
||
} /* End of while loop over all files & modules */
|
||
|
||
/* There may be some routines after all files and modules -- these will get
|
||
inserted in a separate new module of their own */
|
||
if (VALID_CURR_PROC) {
|
||
start_adr = CURR_PROC_START;
|
||
end_adr = qPD[pxdb_header_p->pd_entries -1].adrEnd;
|
||
TELL_OBJFILE;
|
||
warning ("Found functions beyond end of all files and modules [0x%x].", curr_pd);
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "Orphan functions at end, PD %d and beyond (%x to %x)\n",
|
||
curr_pd, start_adr, end_adr);
|
||
}
|
||
#endif
|
||
pst = hpread_start_psymtab( objfile,
|
||
section_offsets, /* ?? */
|
||
"orphans",
|
||
start_adr, /* Low text address */
|
||
(CURR_PROC_ISYM * sizeof (struct dntt_type_block)),
|
||
/* ldsymoff */
|
||
global_syms,
|
||
static_syms );
|
||
|
||
scan_procs (&curr_pd, qPD, pxdb_header_p->pd_entries,
|
||
start_adr, end_adr,
|
||
pst, vt_bits, objfile, section_offsets);
|
||
|
||
pst = hpread_end_psymtab (pst,
|
||
NULL, /* psymtab_include_list */
|
||
0, /* includes_used */
|
||
pxdb_header_p->globals * sizeof (struct dntt_type_block),
|
||
/* byte index in LNTT of end */
|
||
/* = capping symbol offset */
|
||
/* = LDSYMOFF of nextfile */
|
||
end_adr, /* text high */
|
||
NULL, /* dependency_list */
|
||
0); /* dependencies_used */
|
||
}
|
||
|
||
|
||
#ifdef NEVER_NEVER
|
||
/* Now build psts for non-module things (in the tail of
|
||
* the LNTT, after the last END MODULE entry).
|
||
*
|
||
* If null psts were kept on the chain, this would be
|
||
* a solution. FIXME
|
||
*/
|
||
pst = hpread_start_psymtab( objfile,
|
||
section_offsets,
|
||
"globals",
|
||
0,
|
||
(pxdb_header_p->globals
|
||
* sizeof (struct dntt_type_block)),
|
||
objfile->global_psymbols.next,
|
||
objfile->static_psymbols.next);
|
||
hpread_end_psymtab( pst,
|
||
NULL, 0,
|
||
(max_LNTT_sym_index * sizeof (struct dntt_type_block)),
|
||
0,
|
||
NULL, 0 );
|
||
#endif
|
||
|
||
clear_pst_syms ();
|
||
|
||
return 1;
|
||
|
||
} /* End of hpread_quick_traverse. */
|
||
|
||
|
||
/* Get appropriate header, based on pxdb type.
|
||
Return value: 1 if ok, 0 if not */
|
||
int
|
||
hpread_get_header( objfile, pxdb_header_p )
|
||
struct objfile *objfile;
|
||
PXDB_header_ptr pxdb_header_p;
|
||
{
|
||
asection *pinfo_section, *debug_section, *header_section;
|
||
|
||
#ifdef DUMPING
|
||
/* Turn on for debugging information
|
||
*/
|
||
static int dumping = 0;
|
||
#endif
|
||
|
||
header_section = bfd_get_section_by_name (objfile->obfd, "$HEADER$");
|
||
if( !header_section ) {
|
||
/* We don't have either PINFO or DEBUG sections. But
|
||
* stuff like "libc.sl" has no debug info. There's no
|
||
* need to warn the user of this, as it may be ok. The
|
||
* caller will figure it out and issue any needed
|
||
* messages.
|
||
*/
|
||
#ifdef DUMPING
|
||
if( dumping )
|
||
printf( "==No debug info at all for %s.\n", objfile->name );
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* We would like either a $DEBUG$ or $PINFO$ section.
|
||
* Once we know which, we can understand the header
|
||
* data (which we have defined to suit the more common
|
||
* $DEBUG$ case).
|
||
*/
|
||
debug_section = bfd_get_section_by_name (objfile->obfd, "$DEBUG$" );
|
||
pinfo_section = bfd_get_section_by_name (objfile->obfd, "$PINFO$" );
|
||
if( debug_section ) {
|
||
/* The expected case: normal pxdb header.
|
||
*/
|
||
bfd_get_section_contents( objfile->obfd, header_section,
|
||
pxdb_header_p, 0, sizeof( PXDB_header ));
|
||
|
||
if( !pxdb_header_p->pxdbed ) {
|
||
/* This shouldn't happen if we check in "symfile.c".
|
||
*/
|
||
return 0;
|
||
} /* DEBUG section */
|
||
}
|
||
|
||
else if( pinfo_section ) {
|
||
/* The DOC case; we need to translate this into a
|
||
* regular header.
|
||
*/
|
||
DOC_info_PXDB_header doc_header;
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf( "==OOps, PINFO, let's try to handle this, %s.\n", objfile->name );
|
||
}
|
||
#endif
|
||
|
||
bfd_get_section_contents( objfile->obfd,
|
||
header_section,
|
||
&doc_header, 0,
|
||
sizeof( DOC_info_PXDB_header ));
|
||
|
||
if( !doc_header.pxdbed ) {
|
||
/* This shouldn't happen if we check in "symfile.c".
|
||
*/
|
||
warning ("File \"%s\" not processed by pxdb!", objfile->name);
|
||
return 0;
|
||
}
|
||
|
||
/* Copy relevent fields to standard header passed in.
|
||
*/
|
||
pxdb_header_p->pd_entries = doc_header.pd_entries;
|
||
pxdb_header_p->fd_entries = doc_header.fd_entries;
|
||
pxdb_header_p->md_entries = doc_header.md_entries;
|
||
pxdb_header_p->pxdbed = doc_header.pxdbed;
|
||
pxdb_header_p->bighdr = doc_header.bighdr;
|
||
pxdb_header_p->sa_header = doc_header.sa_header;
|
||
pxdb_header_p->inlined = doc_header.inlined;
|
||
pxdb_header_p->globals = doc_header.globals;
|
||
pxdb_header_p->time = doc_header.time;
|
||
pxdb_header_p->pg_entries = doc_header.pg_entries;
|
||
pxdb_header_p->functions = doc_header.functions;
|
||
pxdb_header_p->files = doc_header.files;
|
||
pxdb_header_p->cd_entries = doc_header.cd_entries;
|
||
pxdb_header_p->aa_entries = doc_header.aa_entries;
|
||
pxdb_header_p->oi_entries = doc_header.oi_entries;
|
||
pxdb_header_p->version = doc_header.version;
|
||
} /* PINFO section */
|
||
|
||
else
|
||
{
|
||
#ifdef DUMPING
|
||
if( dumping )
|
||
printf( "==No debug info at all for %s.\n", objfile->name );
|
||
#endif
|
||
|
||
return 0;
|
||
|
||
}
|
||
|
||
return 1;
|
||
} /* End of hpread_get_header */
|
||
#endif /* QUICK_LOOK_UP */
|
||
|
||
|
||
/* Initialization for reading native HP C debug symbols from OBJFILE.
|
||
|
||
Its 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 (objfile)
|
||
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.
|
||
*
|
||
* FIXME: this could be moved into the psymtab-to-symtab expansion
|
||
* code, and save startup time. At the moment this data is
|
||
* still used, though. We'd need a way to tell hp-symtab-read.c
|
||
* whether or not to load the LNTT.
|
||
*/
|
||
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.
|
||
*
|
||
* Note that the minimal table is produced by the linker, and has
|
||
* only global routines in it; the psymtab is based on compiler-
|
||
* generated debug information and has non-global
|
||
* routines in it as well as files and class information.
|
||
*
|
||
* 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;
|
||
{
|
||
|
||
#ifdef DUMPING
|
||
/* Turn this on to get debugging output.
|
||
*/
|
||
static int dumping = 0;
|
||
#endif
|
||
|
||
char *namestring;
|
||
int past_first_source_file = 0;
|
||
struct cleanup *old_chain;
|
||
|
||
int hp_symnum, symcount, i;
|
||
int scan_start;
|
||
|
||
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;
|
||
|
||
#ifdef QUICK_LOOK_UP
|
||
{
|
||
/* Begin code for new-style loading of quick look-up tables.
|
||
*/
|
||
|
||
/* elz: this checks whether the file has beeen processed by pxdb.
|
||
If not we would like to try to read the psymbols in
|
||
anyway, but it turns out to be not so easy. So this could
|
||
actually be commented out, but I leave it in, just in case
|
||
we decide to add support for non-pxdb-ed stuff in the future.
|
||
*/
|
||
bfd *abfd;
|
||
abfd = symfile_bfd_open (objfile->name);
|
||
if (!hpread_pxdb_needed(abfd))
|
||
{
|
||
if ( psym_new_style ) {
|
||
PXDB_header pxdb_header;
|
||
int found_modules_in_program;
|
||
|
||
if( hpread_get_header( objfile, &pxdb_header )) {
|
||
/* Build a minimal table. No types, no global variables,
|
||
* no include files....
|
||
*/
|
||
#ifdef DUMPING
|
||
if( dumping )
|
||
printf( "\nNew method for %s\n", objfile->name );
|
||
#endif
|
||
|
||
/* elz: quick_traverse returns true if it found
|
||
some modules in the main source file, other
|
||
than those in end.c
|
||
In C and C++, all the files have MODULES entries
|
||
in the LNTT, and the quick table traverse is all
|
||
based on finding these MODULES entries. Without
|
||
those it cannot work.
|
||
It happens that F77 programs don't have MODULES
|
||
so the quick traverse gets confused. F90 programs
|
||
have modules, and the quick method still works.
|
||
So, if modules (other than those in end.c) are
|
||
not found we give up on the quick table stuff,
|
||
and fall back on the slower method
|
||
*/
|
||
found_modules_in_program = hpread_quick_traverse(
|
||
objfile,
|
||
section_offsets,
|
||
GNTT( objfile ),
|
||
VT(objfile),
|
||
&pxdb_header );
|
||
|
||
discard_cleanups (old_chain);
|
||
|
||
/* Set up to scan the global section of the LNTT.
|
||
*
|
||
* This field is not always correct: if there are
|
||
* no globals, it will point to the last record in
|
||
* the regular LNTT, which is usually an END MODULE.
|
||
*
|
||
* Since it might happen that there could be a file
|
||
* with just one global record, there's no way to
|
||
* tell other than by looking at the record, so that's
|
||
* done below.
|
||
*/
|
||
if (found_modules_in_program)
|
||
scan_start = pxdb_header.globals;
|
||
else
|
||
scan_start = 0;
|
||
}
|
||
|
||
#ifdef DUMPING
|
||
else {
|
||
if( dumping )
|
||
printf( "\nGoing on to old method for %s\n", objfile->name );
|
||
}
|
||
#endif
|
||
|
||
} /* End of new method code */
|
||
} /* end of if pxdb exists */
|
||
/*
|
||
* elz: if pxdb does not exists on the system, then scan the whole debug info
|
||
* Actually this will never be reached because we error out in case there
|
||
* is no pxdb on the system. It turns out that the debug info cannot be
|
||
* handled the same way as after bxdb has been run, and gdb gets very
|
||
* very confused. Ileave this in anyway, in case one day we want to
|
||
* support non pxdb-ed files.
|
||
*/
|
||
else scan_start = 0;
|
||
|
||
bfd_close(abfd); /*close the bfd we opened to check for pxdb*/
|
||
|
||
} /*end of ifdef QUICK_LOOK_UP*/
|
||
#else
|
||
scan_start = 0; /* if we don't want quick lookup tables start
|
||
from the beginning */
|
||
#endif
|
||
|
||
/* Make two passes, one over the GNTT symbols, the other for the
|
||
* LNTT symbols.
|
||
*
|
||
* JB comment: above isn't true--they only make one pass, over
|
||
* the LNTT.
|
||
*/
|
||
for (i = 0; i < 1; i++)
|
||
{
|
||
int within_function = 0;
|
||
|
||
if (i)
|
||
symcount = GNTT_SYMCOUNT (objfile);
|
||
else
|
||
symcount = LNTT_SYMCOUNT (objfile);
|
||
|
||
|
||
for (hp_symnum = scan_start; 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:
|
||
{
|
||
#ifdef QUICK_LOOK_UP
|
||
if (scan_start == hp_symnum
|
||
&& symcount == hp_symnum + 1) {
|
||
/*
|
||
* If there are NO globals in an executable,
|
||
* PXDB's index to the globals will point to
|
||
* the last record in the file, which
|
||
* could be this record. (this happened for F77 libraries)
|
||
* ignore it and be done!
|
||
*/
|
||
continue;
|
||
}
|
||
#endif
|
||
|
||
/* 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, symcount);
|
||
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
||
pst = hpread_start_psymtab (objfile, section_offsets,
|
||
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. */
|
||
|
||
/* First end the previous psymtab */
|
||
if (pst) {
|
||
hpread_end_psymtab (pst, psymtab_include_list, includes_used,
|
||
((hp_symnum - 1)
|
||
* sizeof (struct dntt_type_block)),
|
||
texthigh,
|
||
dependency_list, dependencies_used);
|
||
pst = (struct partial_symtab *) 0;
|
||
includes_used = 0;
|
||
dependencies_used = 0;
|
||
have_name = 0;
|
||
}
|
||
|
||
/* Now begin a new module and a new psymtab for it */
|
||
SET_NAMESTRING (dn_bufp, &namestring, objfile);
|
||
valu = hpread_get_textlow (i, hp_symnum, objfile, symcount);
|
||
valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
||
if (!pst) {
|
||
pst = hpread_start_psymtab (objfile, section_offsets,
|
||
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 (section_offsets,
|
||
SECT_OFF_TEXT);
|
||
if (valu > texthigh)
|
||
texthigh = valu;
|
||
valu = dn_bufp->dfunc.lowaddr +
|
||
ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
||
SET_NAMESTRING (dn_bufp, &namestring, objfile);
|
||
if (dn_bufp->dfunc.global)
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
VAR_NAMESPACE, LOC_BLOCK,
|
||
&objfile->global_psymbols, valu,
|
||
0, language_unknown, objfile);
|
||
else
|
||
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_DOC_FUNCTION:
|
||
valu = dn_bufp->ddocfunc.hiaddr + ANOFFSET (section_offsets,
|
||
SECT_OFF_TEXT);
|
||
if (valu > texthigh)
|
||
texthigh = valu;
|
||
valu = dn_bufp->ddocfunc.lowaddr +
|
||
ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
||
SET_NAMESTRING (dn_bufp, &namestring, objfile);
|
||
if (dn_bufp->ddocfunc.global)
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
VAR_NAMESPACE, LOC_BLOCK,
|
||
&objfile->global_psymbols, valu,
|
||
0, language_unknown, objfile);
|
||
else
|
||
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:
|
||
/* We don't check MODULE end here, because there can be
|
||
symbols beyond the module end which properly belong to the
|
||
current psymtab -- so we wait till the next MODULE start */
|
||
|
||
|
||
#ifdef QUICK_LOOK_UP
|
||
if (scan_start == hp_symnum
|
||
&& symcount == hp_symnum + 1) {
|
||
/*
|
||
* If there are NO globals in an executable,
|
||
* PXDB's index to the globals will point to
|
||
* the last record in the file, which is
|
||
* probably an END MODULE, i.e. this record.
|
||
* ignore it and be done!
|
||
*/
|
||
continue;
|
||
}
|
||
#endif
|
||
/* Scope block begin/end. We only care about function
|
||
and file blocks right now. */
|
||
|
||
if ((dn_bufp->dend.endkind == DNTT_TYPE_FUNCTION) ||
|
||
(dn_bufp->dend.endkind == DNTT_TYPE_DOC_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, section_offsets,
|
||
"globals", 0,
|
||
(hp_symnum
|
||
* sizeof (struct dntt_type_block)),
|
||
objfile->global_psymbols.next,
|
||
objfile->static_psymbols.next);
|
||
}
|
||
|
||
/* Compute address of the data symbol */
|
||
valu = dn_bufp->dsvar.location;
|
||
/* Relocate in case it's in a shared library */
|
||
if (storage == LOC_STATIC)
|
||
valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
|
||
|
||
/* Luckily, dvar, svar, typedef, and tagdef all
|
||
* have their "global" bit in the same place, so it works
|
||
* (though it's bad programming practice) to reference
|
||
* "dsvar.global" even though we may be looking at
|
||
* any of the above four types.
|
||
*/
|
||
if (dn_bufp->dsvar.global)
|
||
{
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
namespace, storage,
|
||
&objfile->global_psymbols,
|
||
valu,
|
||
0, language_unknown, objfile);
|
||
}
|
||
else
|
||
{
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
namespace, storage,
|
||
&objfile->static_psymbols,
|
||
valu,
|
||
0, language_unknown, objfile);
|
||
}
|
||
|
||
/* For TAGDEF's, the above code added the tagname to the
|
||
* struct namespace. This will cause tag "t" to be found
|
||
* on a reference of the form "(struct t) x". But for
|
||
* C++ classes, "t" will also be a typename, which we
|
||
* want to find on a reference of the form "ptype t".
|
||
* Therefore, we also add "t" to the var namespace.
|
||
* Do the same for enum's due to the way aCC generates
|
||
* debug info for these (see more extended comment
|
||
* in hp-symtab-read.c).
|
||
* We do the same for templates, so that "ptype t"
|
||
* where "t" is a template also works.
|
||
*/
|
||
if (dn_bufp->dblock.kind == DNTT_TYPE_TAGDEF &&
|
||
dn_bufp->dtype.type.dnttp.index < LNTT_SYMCOUNT (objfile)) {
|
||
int global = dn_bufp->dtag.global;
|
||
/* Look ahead to see if it's a C++ class */
|
||
dn_bufp = hpread_get_lntt (dn_bufp->dtype.type.dnttp.index, objfile);
|
||
if (dn_bufp->dblock.kind == DNTT_TYPE_CLASS ||
|
||
dn_bufp->dblock.kind == DNTT_TYPE_ENUM ||
|
||
dn_bufp->dblock.kind == DNTT_TYPE_TEMPLATE) {
|
||
if (global) {
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
VAR_NAMESPACE, storage,
|
||
&objfile->global_psymbols,
|
||
dn_bufp->dsvar.location,
|
||
0, language_unknown, objfile);
|
||
} else {
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
VAR_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, section_offsets,
|
||
"globals", 0,
|
||
(hp_symnum
|
||
* sizeof (struct dntt_type_block)),
|
||
objfile->global_psymbols.next,
|
||
objfile->static_psymbols.next);
|
||
}
|
||
if (dn_bufp->dconst.global)
|
||
add_psymbol_to_list (namestring, strlen (namestring),
|
||
VAR_NAMESPACE, LOC_CONST,
|
||
&objfile->global_psymbols, 0,
|
||
0, language_unknown, objfile);
|
||
else
|
||
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 (objfile)
|
||
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. */
|
||
|
||
union dnttentry *
|
||
hpread_get_lntt (index, objfile)
|
||
int index;
|
||
struct objfile *objfile;
|
||
{
|
||
return (union dnttentry *)
|
||
&(LNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
|
||
}
|
||
|
||
static union dnttentry *
|
||
hpread_get_gntt (index, objfile)
|
||
int index;
|
||
struct objfile *objfile;
|
||
{
|
||
return (union dnttentry *)
|
||
&(GNTT (objfile)[(index * sizeof (struct dntt_type_block))]);
|
||
}
|
||
|
||
union sltentry *
|
||
hpread_get_slt (index, objfile)
|
||
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 existance of DNTT_TYPE_FUNCTION symbols. */
|
||
|
||
static unsigned long
|
||
hpread_get_textlow (global, index, objfile, symcount)
|
||
int global;
|
||
int index;
|
||
struct objfile *objfile;
|
||
int symcount;
|
||
{
|
||
union dnttentry *dn_bufp;
|
||
struct minimal_symbol *msymbol;
|
||
|
||
/* Look for a DNTT_TYPE_FUNCTION symbol. */
|
||
if (index < symcount) /* symcount is the number of symbols in */
|
||
{ /* the dbinfo, LNTT table*/
|
||
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_DOC_FUNCTION
|
||
&& dn_bufp->dblock.kind != DNTT_TYPE_END
|
||
&& index < symcount);
|
||
}
|
||
|
||
/* 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;
|
||
|
||
/* Avoid going past the end of the LNTT file */
|
||
if (index == symcount)
|
||
return 0;
|
||
|
||
/* The minimal symbols are typically more accurate for some reason. */
|
||
if (dn_bufp->dblock.kind == DNTT_TYPE_FUNCTION)
|
||
msymbol = lookup_minimal_symbol (dn_bufp->dfunc.name + VT (objfile), NULL,
|
||
objfile);
|
||
else /* must be a DNTT_TYPE_DOC_FUNCTION */
|
||
msymbol = lookup_minimal_symbol (dn_bufp->ddocfunc.name + VT (objfile), NULL,
|
||
objfile);
|
||
|
||
if (msymbol)
|
||
return SYMBOL_VALUE_ADDRESS (msymbol);
|
||
else
|
||
return dn_bufp->dfunc.lowaddr;
|
||
}
|
||
|
||
/* Allocate and partially fill a partial symtab. It will be
|
||
completely filled at the end of the symbol list.
|
||
|
||
SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
|
||
is the address relative to which its symbols are (incremental) or 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;
|
||
{
|
||
int offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
||
extern void hpread_psymtab_to_symtab();
|
||
struct partial_symtab *result =
|
||
start_psymtab_common (objfile, section_offsets,
|
||
filename, textlow, global_syms, static_syms);
|
||
|
||
result->textlow += offset;
|
||
result->read_symtab_private = (char *)
|
||
obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
|
||
LDSYMOFF (result) = ldsymoff;
|
||
result->read_symtab = hpread_psymtab_to_symtab;
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
/* Close off the current usage of PST.
|
||
Returns PST or NULL if the partial symtab was empty and thrown away.
|
||
|
||
capping_symbol_offset --Byte index in LNTT or GNTT of the
|
||
last symbol processed during the build
|
||
of the previous pst.
|
||
|
||
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;
|
||
{
|
||
int i;
|
||
struct objfile *objfile = pst -> objfile;
|
||
int offset = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT);
|
||
|
||
#ifdef DUMPING
|
||
/* Turn on to see what kind of a psymtab we've built.
|
||
*/
|
||
static int dumping = 0;
|
||
#endif
|
||
|
||
if (capping_symbol_offset != -1)
|
||
LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
|
||
else
|
||
LDSYMLEN(pst) = 0;
|
||
pst->texthigh = capping_text + offset;
|
||
|
||
pst->n_global_syms =
|
||
objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
|
||
pst->n_static_syms =
|
||
objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
|
||
|
||
#ifdef DUMPING
|
||
if( dumping ) {
|
||
printf(
|
||
"\nPst %s, LDSYMOFF %x (%x), LDSYMLEN %x (%x), globals %d, statics %d\n",
|
||
pst->filename,
|
||
LDSYMOFF( pst ),
|
||
LDSYMOFF(pst)/sizeof(struct dntt_type_block),
|
||
LDSYMLEN( pst ),
|
||
LDSYMLEN(pst)/sizeof(struct dntt_type_block),
|
||
pst->n_global_syms, pst->n_static_syms );
|
||
}
|
||
#endif
|
||
|
||
pst->number_of_dependencies = number_dependencies;
|
||
if (number_dependencies)
|
||
{
|
||
pst->dependencies = (struct partial_symtab **)
|
||
obstack_alloc (&objfile->psymbol_obstack,
|
||
number_dependencies * sizeof (struct partial_symtab *));
|
||
memcpy (pst->dependencies, dependency_list,
|
||
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);
|
||
|
||
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;
|
||
|
||
/* We could save slight bits of space by only making one of these,
|
||
shared by the entire set of include files. FIXME-someday. */
|
||
subpst->dependencies = (struct partial_symtab **)
|
||
obstack_alloc (&objfile->psymbol_obstack,
|
||
sizeof (struct partial_symtab *));
|
||
subpst->dependencies[0] = pst;
|
||
subpst->number_of_dependencies = 1;
|
||
|
||
subpst->globals_offset =
|
||
subpst->n_global_syms =
|
||
subpst->statics_offset =
|
||
subpst->n_static_syms = 0;
|
||
|
||
subpst->readin = 0;
|
||
subpst->symtab = 0;
|
||
subpst->read_symtab = pst->read_symtab;
|
||
}
|
||
|
||
sort_pst_symbols (pst);
|
||
|
||
/* If there is already a psymtab or symtab for a file of this name, remove it.
|
||
(If there is a symtab, more drastic things also happen.)
|
||
This happens in VxWorks. */
|
||
free_named_symtabs (pst->filename);
|
||
|
||
if (num_includes == 0
|
||
&& number_dependencies == 0
|
||
&& pst->n_global_syms == 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. */
|
||
/* 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.
|
||
*
|
||
* It's also wrong if we're using the quick look-up tables, as
|
||
* we can get empty psymtabs from modules with no routines in
|
||
* them.
|
||
*/
|
||
|
||
discard_psymtab (pst);
|
||
|
||
/* Indicate that psymtab was thrown away. */
|
||
pst = (struct partial_symtab *)NULL;
|
||
|
||
}
|
||
return pst;
|
||
}
|
||
|
||
|
||
/* End of hp-psymtab-read.c */
|
||
|
||
/* Set indentation to 4 spaces for Emacs; this file is
|
||
mostly non-GNU-ish in its style :-( */
|
||
#if 0
|
||
*** Local Variables:
|
||
*** c-basic-offset: 4
|
||
*** End:
|
||
#endif
|