/* Read a symbol table in MIPS' format (Third-Eye).
- Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
- Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major
- work by Per Bothner and John Gilmore at Cygnus Support.
+ Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software
+ Foundation, Inc.
+ Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work
+ by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
This file is part of GDB.
the most brain-dead adaptation of a file format to byte order.
This module can read all four of the known byte-order combinations,
- on any type of host. However, it does make (and check) the assumption
- that the external form of a symbol table structure (on disk)
- occupies the same number of bytes as the internal form (in a struct).
- Fixing this is possible but requires larger structural changes. */
+ on any type of host. */
-#define TM_FILE_OVERRIDE
#include "defs.h"
-#include "tm-mips.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcore.h"
#include "stabsread.h"
#include "complaints.h"
+/* These are needed if the tm.h file does not contain the necessary
+ mips specific definitions. */
+
+#ifndef MIPS_EFI_SYMBOL_NAME
+#define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
+#include "coff/sym.h"
+#include "coff/symconst.h"
+typedef struct mips_extra_func_info {
+ long numargs;
+ PDR pdr;
+} *mips_extra_func_info_t;
+#ifndef RA_REGNUM
+#define RA_REGNUM 0
+#endif
+#endif
+
#ifdef USG
#include <sys/types.h>
-#define L_SET 0
-#define L_INCR 1
#endif
#include <sys/param.h>
#include "gdb-stabs.h"
-#include "coff/mips.h" /* COFF-like aspects of ecoff files */
-#include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
+#include "bfd.h"
+
+#include "coff/internal.h"
+#include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
-#include "libbfd.h" /* FIXME Secret internal BFD stuff (bfd_read) */
-#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
+/* FIXME: coff/internal.h and aout/aout64.h both define N_ABS. We
+ want the definition from aout/aout64.h. */
+#undef N_ABS
+
+#include "libaout.h" /* Private BFD a.out information. */
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* STABS information */
+
+/* FIXME: libcoff.h and libaout.h both define a couple of macros. We
+ don't use them. */
+#undef exec_hdr
+#undef obj_sym_filepos
+
+#include "libcoff.h" /* Private BFD COFF information. */
+#include "libecoff.h" /* Private BFD ECOFF information. */
+
#include "expression.h"
#include "language.h" /* Needed inside partial-stab.h */
-struct coff_exec
-{
- struct external_filehdr f;
- struct external_aouthdr a;
+/* Provide a default mapping from a ecoff register number to a gdb REGNUM. */
+#ifndef ECOFF_REG_TO_REGNUM
+#define ECOFF_REG_TO_REGNUM(num) (num)
+#endif
+
+/* Information is passed among various mipsread routines for accessing
+ symbol files. A pointer to this structure is kept in the sym_private
+ field of the objfile struct. */
+
+struct ecoff_symfile_info {
+ struct mips_pending **pending_list;
};
+#define ECOFF_SYMFILE_INFO(o) ((struct ecoff_symfile_info *)((o)->sym_private))
+#define ECOFF_PENDING_LIST(o) (ECOFF_SYMFILE_INFO(o)->pending_list)
+
-/* 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.
+/* Each partial symbol table entry contains a pointer to private data
+ for the read_symtab() function to use when expanding a partial
+ symbol table entry to a full symbol table entry.
- For mipsread this structure contains the index of the FDR that this psymtab
- represents and a pointer to the symbol table header HDRR from the symbol
- file that the psymtab was created from. */
+ For mipsread this structure contains the index of the FDR that this
+ psymtab represents and a pointer to the BFD that the psymtab was
+ created from. */
#define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private)
#define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx)
-#define CUR_HDR(p) (PST_PRIVATE(p)->cur_hdr)
+#define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd)
struct symloc
{
int fdr_idx;
- HDRR *cur_hdr;
- EXTR **extern_tab; /* Pointer to external symbols for this file. */
- int extern_count; /* Size of extern_tab. */
+ bfd *cur_bfd;
+ EXTR *extern_tab; /* Pointer to external symbols for this file. */
+ int extern_count; /* Size of extern_tab. */
+ enum language pst_language;
};
/* Things we import explicitly from other modules */
{"block containing %s overfilled", 0, 0};
struct complaint basic_type_complaint =
-{"cannot map MIPS basic type 0x%x", 0, 0};
+{"cannot map MIPS basic type 0x%x for %s", 0, 0};
struct complaint unknown_type_qual_complaint =
{"unknown type qualifier 0x%x", 0, 0};
struct complaint pdr_static_symbol_complaint =
{"can't handle PDR for static proc at 0x%x", 0, 0};
-/* Macros and extra defs */
+struct complaint bad_setjmp_pdr_complaint =
+{"fixing bad setjmp PDR from libc", 0, 0};
-/* Already-parsed symbols are marked specially */
+struct complaint bad_fbitfield_complaint =
+{"can't handle TIR fBitfield for %s", 0, 0};
-#define stParsed stType
+struct complaint bad_rfd_entry_complaint =
+{"bad rfd entry for %s: file %d, index %d", 0, 0};
+
+struct complaint unexpected_type_code_complaint =
+{"unexpected type code for %s", 0, 0};
+
+struct complaint unable_to_cross_ref_complaint =
+{"unable to cross ref btTypedef for %s", 0, 0};
+
+struct complaint illegal_forward_tq0_complaint =
+{"illegal tq0 in forward typedef for %s", 0, 0};
+
+struct complaint illegal_forward_bt_complaint =
+{"illegal bt %d in forward typedef for %s", 0, 0};
+
+/* Macros and extra defs */
/* Puns: hard to find whether -g was used and how */
#define compare_glevel(a,b) \
(((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \
((b) == GLEVEL_3) ? -1 : (int)((b) - (a)))
-
-/* When looking at .o files, avoid tripping over zero pointers.
- FIXME; places that use this should be fixed to convert from
- external to internal format, rather than examining in-place. */
-
-#define UNSAFE_DATA_ADDR(p) ((p) == 0)
\f
/* Things that really are local to this module */
static enum language psymtab_language = language_unknown;
-/* MIPS symtab header for the current file */
+/* Current BFD. */
-static HDRR *cur_hdr;
+static bfd *cur_bfd;
/* Pointer to current file decriptor record, and its index */
/* Forward declarations */
-static void
-fixup_symtab PARAMS ((HDRR *, char *, file_ptr, bfd *));
-
static void
read_mips_symtab PARAMS ((struct objfile *, struct section_offsets *));
static void
-read_the_mips_symtab PARAMS ((bfd *, CORE_ADDR *));
+read_the_mips_symtab PARAMS ((bfd *));
static int
-upgrade_type PARAMS ((struct type **, int, union aux_ext *, int));
+upgrade_type PARAMS ((int, struct type **, int, union aux_ext *, int));
static void
-parse_partial_symbols PARAMS ((int, struct objfile *,
+parse_partial_symbols PARAMS ((struct objfile *,
struct section_offsets *));
static int
-cross_ref PARAMS ((union aux_ext *, struct type **, enum type_code, char **,
- int));
+cross_ref PARAMS ((int, union aux_ext *, struct type **, enum type_code,
+ char **, int, char *));
static void
fixup_sigtramp PARAMS ((void));
static struct blockvector *
new_bvect PARAMS ((int));
+static int
+parse_symbol PARAMS ((SYMR *, union aux_ext *, char *, int));
+
static struct type *
-parse_type PARAMS ((union aux_ext *, int *, int));
+parse_type PARAMS ((int, union aux_ext *, int *, int, char *));
static struct symbol *
mylookup_symbol PARAMS ((char *, struct block *, enum namespace,
static struct partial_symtab *
new_psymtab PARAMS ((char *, struct objfile *));
-#if 0
-static struct partial_symtab *
-parse_fdr PARAMS ((int, int, struct objfile *));
-#endif
-
static void
psymtab_to_symtab_1 PARAMS ((struct partial_symtab *, char *));
mipscoff_new_init (ignore)
struct objfile *ignore;
{
+ sigtramp_address = 0;
+ stabsread_new_init ();
+ buildsym_new_init ();
}
static void
{
mfree (objfile->md, objfile->sym_private);
}
- objfile->sym_private = NULL;
+ objfile->sym_private = (PTR)
+ xmmalloc (objfile->md, sizeof (struct ecoff_symfile_info));
}
static void
struct section_offsets *section_offsets;
int mainline;
{
+ struct cleanup * back_to;
+
init_minimal_symbol_collection ();
- make_cleanup (discard_minimal_symbols, 0);
+ back_to = make_cleanup (discard_minimal_symbols, 0);
/* Now that the executable file is positioned at symbol table,
process it and define symbols accordingly. */
minimal symbols for this objfile. */
install_minimal_symbols (objfile);
+
+ do_cleanups (back_to);
}
/* Perform any local cleanups required when we are done with a particular
mfree (objfile->md, objfile->sym_private);
}
- /* If we have a file symbol header lying around, blow it away. */
-
- if (cur_hdr)
- {
- free ((PTR) cur_hdr);
- }
- cur_hdr = 0;
+ cur_bfd = 0;
}
/* Allocate zeroed memory */
printf_filtered ("Reading in symbols for %s...", pst->filename);
fflush (stdout);
}
- /* Restore the header and list of pending typedefs */
- cur_hdr = CUR_HDR (pst);
next_symbol_text_func = mips_next_symbol_text;
\f
/* File-level interface functions */
-/* Read the symtab information from file ABFD into memory. Also,
- return address just past end of our text segment in *END_OF_TEXT_SEGP. */
+/* Read the symtab information from file ABFD into memory. */
static void
-read_the_mips_symtab (abfd, end_of_text_segp)
+read_the_mips_symtab (abfd)
bfd *abfd;
- CORE_ADDR *end_of_text_segp;
{
- int stsize, st_hdrsize;
- file_ptr st_filptr;
- struct hdr_ext hdr_ext;
- HDRR st_hdr;
- /* Header for executable/object file we read symbols from */
- struct coff_exec filhdr;
- int val;
-
- /* We need some info from the initial headers */
- val = bfd_seek (abfd, (file_ptr) 0, L_SET);
- val = bfd_read ((PTR) & filhdr, sizeof filhdr, 1, abfd);
-
- if (end_of_text_segp)
- *end_of_text_segp =
- bfd_h_get_32 (abfd, filhdr.a.text_start) +
- bfd_h_get_32 (abfd, filhdr.a.tsize);
-
- /* Find and read the symbol table header */
- st_hdrsize = bfd_h_get_32 (abfd, filhdr.f.f_nsyms);
- st_filptr = bfd_h_get_32 (abfd, filhdr.f.f_symptr);
- if (st_filptr == 0)
- return;
-
- bfd_seek (abfd, st_filptr, L_SET);
- if (st_hdrsize != sizeof (hdr_ext))
- { /* Profanity check */
- error ("Wrong header size: %d, not %d", st_hdrsize,
- sizeof (hdr_ext));
- }
- if (bfd_read ((PTR) & hdr_ext, st_hdrsize, 1, abfd) != st_hdrsize)
- goto readerr;
- ecoff_swap_hdr_in (abfd, &hdr_ext, &st_hdr);
-
- /* Find out how large the symbol table is */
- stsize = ((st_hdr.cbExtOffset - (st_filptr + st_hdrsize))
- + st_hdr.iextMax * cbEXTR);
-
- /* Allocate space for the symbol table. Read it in. */
- cur_hdr = (HDRR *) xmalloc (stsize + st_hdrsize);
-
- memcpy ((PTR) cur_hdr, (PTR) & hdr_ext, st_hdrsize);
- if (bfd_read ((char *) cur_hdr + st_hdrsize, stsize, 1, abfd) != stsize)
- goto readerr;
-
- /* Fixup file_pointers in it */
- fixup_symtab (cur_hdr, (char *) cur_hdr + st_hdrsize,
- st_filptr + st_hdrsize, abfd);
-
- return;
-readerr:
- error ("Short read on %s", bfd_get_filename (abfd));
+ if (ecoff_slurp_symbolic_info (abfd) == false)
+ error ("Error reading symbol table: %s", bfd_errmsg (bfd_error));
}
-
-/* Turn all file-relative pointers in the symtab described by HDR
- into memory pointers, given that the symtab itself is located
- at DATA in memory and F_PTR in the file.
-
- Byte-swap all the data structures, in place, while we are at it --
- except AUX entries, which we leave in their original byte order.
- They will be swapped as they are used instead. (FIXME: we ought to
- do all the data structures that way.) */
-
-static void
-fixup_symtab (hdr, data, f_ptr, abfd)
- HDRR *hdr;
- char *data;
- file_ptr f_ptr;
- bfd *abfd;
-{
- int f_idx, s_idx, i;
- FDR *fh;
- SYMR *sh;
- PDR *pr;
- EXTR *esh;
- struct rfd_ext *rbase;
-
- /* This function depends on the external and internal forms
- of the MIPS symbol table taking identical space. Check this
- assumption at compile-time.
- DO NOT DELETE THESE ENTRIES, OR COMMENT THEM OUT, JUST BECAUSE SOME
- "LINT" OR COMPILER THINKS THEY ARE UNUSED! Thank you. */
- static check_hdr1[1 + sizeof (struct hdr_ext) - sizeof (HDRR)] = {0};
- static check_hdr2[1 + sizeof (HDRR) - sizeof (struct hdr_ext)] = {0};
- static check_fdr1[1 + sizeof (struct fdr_ext) - sizeof (FDR)] = {0};
- static check_fdr2[1 + sizeof (FDR) - sizeof (struct fdr_ext)] = {0};
- static check_pdr1[1 + sizeof (struct pdr_ext) - sizeof (PDR)] = {0};
- static check_pdr2[1 + sizeof (PDR) - sizeof (struct pdr_ext)] = {0};
- static check_sym1[1 + sizeof (struct sym_ext) - sizeof (SYMR)] = {0};
- static check_sym2[1 + sizeof (SYMR) - sizeof (struct sym_ext)] = {0};
- static check_ext1[1 + sizeof (struct ext_ext) - sizeof (EXTR)] = {0};
- static check_ext2[1 + sizeof (EXTR) - sizeof (struct ext_ext)] = {0};
- static check_rfd1[1 + sizeof (struct rfd_ext) - sizeof (RFDT)] = {0};
- static check_rfd2[1 + sizeof (RFDT) - sizeof (struct rfd_ext)] = {0};
-
- /* Swap in the header record. */
- ecoff_swap_hdr_in (abfd, hdr, hdr);
-
- /*
- * These fields are useless (and empty) by now:
- * hdr->cbDnOffset, hdr->cbOptOffset
- * We use them for other internal purposes.
- */
- hdr->cbDnOffset = 0;
- hdr->cbOptOffset = 0;
-
-#define FIX(off) \
- if (hdr->off) hdr->off = (unsigned int)data + (hdr->off - f_ptr);
-
- FIX (cbLineOffset);
- FIX (cbPdOffset);
- FIX (cbSymOffset);
- FIX (cbOptOffset);
- FIX (cbAuxOffset);
- FIX (cbSsOffset);
- FIX (cbSsExtOffset);
- FIX (cbFdOffset);
- FIX (cbRfdOffset);
- FIX (cbExtOffset);
-#undef FIX
-
- /* Fix all the RFD's. */
- rbase = (struct rfd_ext *) (hdr->cbRfdOffset);
- for (i = 0; i < hdr->crfd; i++)
- {
- ecoff_swap_rfd_in (abfd, rbase + i, (pRFDT) rbase + i);
- }
-
- /* Fix all string pointers inside the symtab, and
- the FDR records. Also fix other miscellany. */
-
- for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
- {
- register unsigned code_offset;
-
- /* Header itself, and strings */
- fh = (FDR *) (hdr->cbFdOffset) + f_idx;
-
- /* Swap in the FDR */
- ecoff_swap_fdr_in (abfd, fh, fh);
-
- fh->issBase += hdr->cbSsOffset;
- if (fh->rss != -1)
- fh->rss = (long) fh->rss + fh->issBase;
-
- /* Local symbols */
- fh->isymBase = (int) ((SYMR *) (hdr->cbSymOffset) + fh->isymBase);
-
- /* FIXME! Probably don't want to do this here! */
- for (s_idx = 0; s_idx < fh->csym; s_idx++)
- {
- sh = (SYMR *) fh->isymBase + s_idx;
- ecoff_swap_sym_in (abfd, sh, sh);
-
- sh->iss = (long) sh->iss + fh->issBase;
- sh->reserved = 0;
- }
-
- cur_fd = f_idx;
-
- /* cannot fix fh->ipdFirst because it is a short */
-#define IPDFIRST(h,fh) \
- ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR))
-
- /* Optional symbols (actually used for partial_symtabs) */
- fh->ioptBase = 0;
- fh->copt = 0;
-
- /* Aux symbols */
- if (fh->caux)
- fh->iauxBase = hdr->cbAuxOffset + fh->iauxBase * sizeof (union aux_ext);
- /* Relative file descriptor table */
- fh->rfdBase = hdr->cbRfdOffset + fh->rfdBase * sizeof (RFDT);
-
- /* Line numbers */
- if (fh->cbLine)
- fh->cbLineOffset += hdr->cbLineOffset;
-
- /* Procedure symbols. (XXX This should be done later) */
- code_offset = fh->adr;
- for (s_idx = 0; s_idx < fh->cpd; s_idx++)
- {
- unsigned name, only_ext;
-
- pr = (PDR *) (IPDFIRST (hdr, fh)) + s_idx;
- ecoff_swap_pdr_in (abfd, pr, pr);
-
- /* Simple rule to find files linked "-x" */
- only_ext = fh->rss == -1;
- if (only_ext)
- {
- if (pr->isym == -1)
- {
- /* static function */
- sh = (SYMR *) - 1;
- }
- else
- {
- /* external */
- name = hdr->cbExtOffset + pr->isym * sizeof (EXTR);
- sh = &((EXTR *) name)->asym;
- }
- }
- else
- {
- /* Full symbols */
- sh = (SYMR *) fh->isymBase + pr->isym;
- /* Included code ? */
- if (s_idx == 0 && pr->adr != 0)
- code_offset -= pr->adr;
- }
-
- /* Turn index into a pointer */
- pr->isym = (long) sh;
-
- /* Fix line numbers */
- pr->cbLineOffset += fh->cbLineOffset;
-
- /* Relocate address */
- if (!only_ext)
- pr->adr += code_offset;
- }
- }
-
- /* External symbols: swap in, and fix string */
- for (s_idx = 0; s_idx < hdr->iextMax; s_idx++)
- {
- esh = (EXTR *) (hdr->cbExtOffset) + s_idx;
- ecoff_swap_ext_in (abfd, esh, esh);
- esh->asym.iss = esh->asym.iss + hdr->cbSsExtOffset;
- }
-}
-
-
/* Find a file descriptor given its index RF relative to a file CF */
static FDR *
get_rfd (cf, rf)
int cf, rf;
{
+ FDR *fdrs;
register FDR *f;
+ RFDT rfd;
- f = (FDR *) (cur_hdr->cbFdOffset) + cf;
+ fdrs = ecoff_data (cur_bfd)->fdr;
+ f = fdrs + cf;
/* Object files do not have the RFD table, all refs are absolute */
if (f->rfdBase == 0)
- return (FDR *) (cur_hdr->cbFdOffset) + rf;
- cf = *((pRFDT) f->rfdBase + rf);
- return (FDR *) (cur_hdr->cbFdOffset) + cf;
+ return fdrs + rf;
+ (*ecoff_backend (cur_bfd)->swap_rfd_in)
+ (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_rfd
+ + (f->rfdBase + rf) * ecoff_backend (cur_bfd)->external_rfd_size),
+ &rfd);
+ return fdrs + rfd;
}
/* Return a safer print NAME for a file descriptor */
static char *
-fdr_name (name)
- char *name;
+fdr_name (f)
+ FDR *f;
{
- if (name == (char *) -1)
+ if (f->rss == -1)
return "<stripped file>";
- if (UNSAFE_DATA_ADDR (name))
+ if (f->rss == 0)
return "<NFY>";
- return name;
+ return ecoff_data (cur_bfd)->ss + f->issBase + f->rss;
}
struct objfile *objfile;
struct section_offsets *section_offsets;
{
- CORE_ADDR end_of_text_seg;
+ cur_bfd = objfile->obfd;
- read_the_mips_symtab (objfile->obfd, &end_of_text_seg);
+ read_the_mips_symtab (objfile->obfd);
- parse_partial_symbols (end_of_text_seg, objfile, section_offsets);
+ parse_partial_symbols (objfile, section_offsets);
#if 0
- /*
- * Check to make sure file was compiled with -g.
- * If not, warn the user of this limitation.
- */
+ /* Check to make sure file was compiled with -g. If not, warn the
+ user of this limitation. */
if (compare_glevel (max_glevel, GLEVEL_2) < 0)
{
if (max_gdbinfo == 0)
- printf (
- "\n%s not compiled with -g, debugging support is limited.\n",
+ printf ("\n%s not compiled with -g, debugging support is limited.\n",
objfile->name);
- printf (
- "You should compile with -g2 or -g3 for best debugging support.\n");
+ printf ("You should compile with -g2 or -g3 for best debugging support.\n");
fflush (stdout);
}
#endif
struct pst_map
{
struct partial_symtab *pst; /* the psymtab proper */
- int n_globals; /* exported globals (external symbols) */
- int globals_offset; /* cumulative */
+ long n_globals; /* exported globals (external symbols) */
+ long globals_offset; /* cumulative */
};
int maxsyms; /* Max symbols in this block. */
struct type *cur_type; /* Type we parse fields for. */
int cur_field; /* Field number in cur_type. */
- int procadr; /* Start addres of this procedure */
+ CORE_ADDR procadr; /* Start addres of this procedure */
int numargs; /* Its argument count */
-} *top_stack; /* Top stack ptr */
+}
+
+ *top_stack; /* Top stack ptr */
/* Enter a new lexical context */
duplications we keep a quick fixup table, an array
of lists of references indexed by file descriptor */
-static struct mips_pending
+struct mips_pending
{
struct mips_pending *next; /* link */
- SYMR *s; /* the symbol */
+ char *s; /* the unswapped symbol */
struct type *t; /* its partial type descriptor */
-} **pending_list;
+};
-/* Check whether we already saw symbol SH in file FH as undefined */
+/* Check whether we already saw symbol SH in file FH */
static struct mips_pending *
is_pending_symbol (fh, sh)
FDR *fh;
- SYMR *sh;
+ char *sh;
{
- int f_idx = fh - (FDR *) cur_hdr->cbFdOffset;
+ int f_idx = fh - ecoff_data (cur_bfd)->fdr;
register struct mips_pending *p;
+ struct mips_pending **pending_list = ECOFF_PENDING_LIST (current_objfile);
/* Linear search is ok, list is typically no more than 10 deep */
for (p = pending_list[f_idx]; p; p = p->next)
return p;
}
-/* Add a new undef symbol SH of type T */
+/* Add a new symbol SH of type T */
static void
add_pending (fh, sh, t)
FDR *fh;
- SYMR *sh;
+ char *sh;
struct type *t;
{
- int f_idx = fh - (FDR *) cur_hdr->cbFdOffset;
+ int f_idx = fh - ecoff_data (cur_bfd)->fdr;
struct mips_pending *p = is_pending_symbol (fh, sh);
/* Make sure we do not make duplicates */
if (!p)
{
- p = (struct mips_pending *) xmalloc (sizeof (*p));
+ struct mips_pending **pending_list = ECOFF_PENDING_LIST (current_objfile);
+
+ p = ((struct mips_pending *)
+ obstack_alloc (¤t_objfile->psymbol_obstack,
+ sizeof (struct mips_pending)));
p->s = sh;
p->t = t;
p->next = pending_list[f_idx];
pending_list[f_idx] = p;
}
- sh->reserved = 1; /* for quick check */
-}
-
-/* Throw away undef entries when done with file index F_IDX */
-/* FIXME -- storage leak. This is never called!!! --gnu */
-
-#if 0
-
-static void
-free_pending (f_idx)
- int f_idx;
-{
- register struct mips_pending *p, *q;
-
- for (p = pending_list[f_idx]; p; p = q)
- {
- q = p->next;
- free ((PTR) p);
- }
- pending_list[f_idx] = 0;
-}
-
-#endif
-
-static char *
-prepend_tag_kind (tag_name, type_code)
- char *tag_name;
- enum type_code type_code;
-{
- char *prefix;
- char *result;
- switch (type_code)
- {
- case TYPE_CODE_ENUM:
- prefix = "enum ";
- break;
- case TYPE_CODE_STRUCT:
- prefix = "struct ";
- break;
- case TYPE_CODE_UNION:
- prefix = "union ";
- break;
- default:
- prefix = "";
- }
-
- result = (char *) obstack_alloc (¤t_objfile->symbol_obstack,
- strlen (prefix) + strlen (tag_name) + 1);
- sprintf (result, "%s%s", prefix, tag_name);
- return result;
}
\f
/* Parse a single symbol. Mostly just make up a GDB symbol for it.
For blocks, procedures and types we open a new lexical context.
- This is basically just a big switch on the symbol's type.
- Argument AX is the base pointer of aux symbols for this file (fh->iauxBase).
- BIGEND says whether aux symbols are big-endian or little-endian.
- Return count of SYMR's handled (normally one). */
+ This is basically just a big switch on the symbol's type. Argument
+ AX is the base pointer of aux symbols for this file (fh->iauxBase).
+ EXT_SH points to the unswapped symbol, which is needed for struct,
+ union, etc., types; it is NULL for an EXTR. BIGEND says whether
+ aux symbols are big-endian or little-endian. Return count of
+ SYMR's handled (normally one). */
static int
-parse_symbol (sh, ax, bigend)
+parse_symbol (sh, ax, ext_sh, bigend)
SYMR *sh;
union aux_ext *ax;
+ char *ext_sh;
int bigend;
{
+ const bfd_size_type external_sym_size
+ = ecoff_backend (cur_bfd)->external_sym_size;
+ void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *)) =
+ ecoff_backend (cur_bfd)->swap_sym_in;
char *name;
struct symbol *s;
struct block *b;
+ struct mips_pending *pend;
struct type *t;
struct field *f;
int count = 1;
- /* When a symbol is cross-referenced from other files/symbols
- we mark it explicitly */
- int pend = (sh->reserved == 1);
enum address_class class;
TIR tir;
+ long svalue = sh->value;
+
+ if (ext_sh == (char *) NULL)
+ name = ecoff_data (cur_bfd)->ssext + sh->iss;
+ else
+ name = ecoff_data (cur_bfd)->ss + cur_fdr->issBase + sh->iss;
switch (sh->st)
{
-
case stNil:
break;
class = LOC_STATIC;
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
- s = new_symbol ((char *) sh->iss);
+ s = new_symbol (name);
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
goto data;
case stStatic: /* static data, goes into current block. */
class = LOC_STATIC;
b = top_stack->cur_block;
- s = new_symbol ((char *) sh->iss);
- SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
+ s = new_symbol (name);
+ if (sh->sc == scCommon)
+ {
+ /* It is a FORTRAN common block. At least for SGI Fortran the
+ address is not in the symbol; we need to fix it later in
+ scan_file_globals. */
+ int bucket = hashname (SYMBOL_NAME (s));
+ SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
+ global_sym_chain[bucket] = s;
+ }
+ else
+ SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
goto data;
case stLocal: /* local variable, goes into current block */
if (sh->sc == scRegister)
{
class = LOC_REGISTER;
- if (sh->value > 31)
- sh->value += FP0_REGNUM - 32;
+ svalue = ECOFF_REG_TO_REGNUM (svalue);
}
else
class = LOC_LOCAL;
b = top_stack->cur_block;
- s = new_symbol ((char *) sh->iss);
- SYMBOL_VALUE (s) = sh->value;
+ s = new_symbol (name);
+ SYMBOL_VALUE (s) = svalue;
data: /* Common code for symbols describing data */
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
sh->index == 0xfffff)
SYMBOL_TYPE (s) = builtin_type_int; /* undefined? */
else
- SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend);
+ SYMBOL_TYPE (s) = parse_type (cur_fd, ax + sh->index, 0, bigend, name);
/* Value of a data symbol is its memory address */
break;
max_gdbinfo++;
top_stack->numargs++;
- name = (char *) sh->iss;
/* Special GNU C++ name. */
if (name[0] == CPLUS_MARKER && name[1] == 't' && name[2] == 0)
name = "this"; /* FIXME, not alloc'd in obstack */
s = new_symbol (name);
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
- if (sh->sc == scRegister)
+ switch (sh->sc)
{
- SYMBOL_CLASS (s) = LOC_REGPARM;
- if (sh->value > 31)
- sh->value += FP0_REGNUM - 32;
+ case scRegister:
+ /* Pass by value in register. */
+ SYMBOL_CLASS(s) = LOC_REGPARM;
+ svalue = ECOFF_REG_TO_REGNUM (svalue);
+ break;
+ case scVar:
+ /* Pass by reference on stack. */
+ SYMBOL_CLASS(s) = LOC_REF_ARG;
+ break;
+ case scVarRegister:
+ /* Pass by reference in register. */
+ SYMBOL_CLASS(s) = LOC_REGPARM_ADDR;
+ svalue = ECOFF_REG_TO_REGNUM (svalue);
+ break;
+ default:
+ /* Pass by value on stack. */
+ SYMBOL_CLASS(s) = LOC_ARG;
+ break;
}
- else
- SYMBOL_CLASS (s) = LOC_ARG;
- SYMBOL_VALUE (s) = sh->value;
- SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend);
+ SYMBOL_VALUE (s) = svalue;
+ SYMBOL_TYPE (s) = parse_type (cur_fd, ax + sh->index, 0, bigend, name);
add_symbol (s, top_stack->cur_block);
#if 0
/* FIXME: This has not been tested. See dbxread.c */
break;
case stLabel: /* label, goes into current block */
- s = new_symbol ((char *) sh->iss);
+ s = new_symbol (name);
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */
SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
case stProc: /* Procedure, usually goes into global block */
case stStaticProc: /* Static procedure, goes into current block */
- s = new_symbol ((char *) sh->iss);
+ s = new_symbol (name);
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
SYMBOL_CLASS (s) = LOC_BLOCK;
/* Type of the return value */
if (sh->sc == scUndefined || sh->sc == scNil)
t = builtin_type_int;
else
- t = parse_type (ax + sh->index + 1, 0, bigend);
+ t = parse_type (cur_fd, ax + sh->index + 1, 0, bigend, name);
b = top_stack->cur_block;
if (sh->st == stProc)
{
/* Generate a template for the type of this function. The
types of the arguments will be added as we read the symbol
table. */
- bcopy (SYMBOL_TYPE (s), lookup_function_type (t), sizeof (struct type));
+ memcpy (lookup_function_type (t), SYMBOL_TYPE (s), sizeof (struct type));
#else
SYMBOL_TYPE (s) = lookup_function_type (t);
#endif
top_stack->cur_field = -1;
top_stack->procadr = sh->value;
top_stack->numargs = 0;
-
- sh->value = (long) SYMBOL_TYPE (s);
break;
/* Beginning of code for structure, union, and enum definitions.
They all share a common set of local variables, defined here. */
{
enum type_code type_code;
- SYMR *tsym;
+ char *ext_tsym;
int nfields;
long max_value;
struct field *f;
goto structured_common;
case stBlock: /* Either a lexical block, or some type */
- if (sh->sc != scInfo)
+ if (sh->sc != scInfo && sh->sc != scCommon)
goto case_stBlock_code; /* Lexical block */
type_code = TYPE_CODE_UNDEF; /* We have a type. */
push_parse_stack ();
top_stack->blocktype = stBlock;
- s = new_symbol ((char *) sh->iss);
- SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
- SYMBOL_CLASS (s) = LOC_TYPEDEF;
- SYMBOL_VALUE (s) = 0;
- add_symbol (s, top_stack->cur_block);
-
/* First count the number of fields and the highest value. */
nfields = 0;
max_value = 0;
- for (tsym = sh + 1; tsym->st != stEnd; tsym++)
+ for (ext_tsym = ext_sh + external_sym_size;
+ ;
+ ext_tsym += external_sym_size)
{
- if (tsym->st == stMember)
+ SYMR tsym;
+
+ (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
+
+ switch (tsym.st)
{
+ case stEnd:
+ goto end_of_fields;
+
+ case stMember:
if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
/* If the type of the member is Nil (or Void),
without qualifiers, assume the tag is an
enumeration. */
- if (tsym->index == indexNil)
+ if (tsym.index == indexNil)
type_code = TYPE_CODE_ENUM;
else
{
ecoff_swap_tir_in (bigend,
- &ax[tsym->index].a_ti,
+ &ax[tsym.index].a_ti,
&tir);
if ((tir.bt == btNil || tir.bt == btVoid)
&& tir.tq0 == tqNil)
type_code = TYPE_CODE_ENUM;
}
nfields++;
- if (tsym->value > max_value)
- max_value = tsym->value;
- }
- else if (tsym->st == stBlock
- || tsym->st == stUnion
- || tsym->st == stEnum
- || tsym->st == stStruct
- || tsym->st == stParsed)
- {
- if (tsym->sc == scVariant); /*UNIMPLEMENTED*/
- if (tsym->index != 0)
- tsym = ((SYMR *) cur_fdr->isymBase)
- + tsym->index - 1;
+ if (tsym.value > max_value)
+ max_value = tsym.value;
+ break;
+
+ case stBlock:
+ case stUnion:
+ case stEnum:
+ case stStruct:
+ {
+#if 0
+ /* This is a no-op; is it trying to tell us something
+ we should be checking? */
+ if (tsym.sc == scVariant); /*UNIMPLEMENTED*/
+#endif
+ if (tsym.index != 0)
+ {
+ /* This is something like a struct within a
+ struct. Skip over the fields of the inner
+ struct. The -1 is because the for loop will
+ increment ext_tsym. */
+ ext_tsym = ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((cur_fdr->isymBase + tsym.index - 1)
+ * external_sym_size));
+ }
+ }
+ break;
+
+ case stTypedef:
+ /* mips cc puts out a typedef for struct x if it is not yet
+ defined when it encounters
+ struct y { struct x *xp; };
+ Just ignore it. */
+ break;
+
+ default:
+ complain (&block_member_complaint, tsym.st);
}
- else
- complain (&block_member_complaint, tsym->st);
}
+ end_of_fields:;
/* In an stBlock, there is no way to distinguish structs,
unions, and enums at this point. This is a bug in the
else
type_code = TYPE_CODE_STRUCT;
- /* If this type was expected, use its partial definition */
- if (pend)
- t = is_pending_symbol (cur_fdr, sh)->t;
+ /* Create a new type or use the pending type. */
+ pend = is_pending_symbol (cur_fdr, ext_sh);
+ if (pend == (struct mips_pending *) NULL)
+ {
+ t = new_type (NULL);
+ add_pending (cur_fdr, ext_sh, t);
+ }
+ else
+ t = pend->t;
+
+ /* Alpha cc unnamed structs do not get a tag name. */
+ if (sh->iss == 0)
+ TYPE_TAG_NAME (t) = NULL;
else
- t = new_type (prepend_tag_kind ((char *) sh->iss,
- type_code));
+ TYPE_TAG_NAME (t) = obconcat (¤t_objfile->symbol_obstack,
+ "", "", name);
TYPE_CODE (t) = type_code;
TYPE_LENGTH (t) = sh->value;
TYPE_NFIELDS (t) = nfields;
- TYPE_FIELDS (t) = f = (struct field *)
- TYPE_ALLOC (t, nfields * sizeof (struct field));
+ TYPE_FIELDS (t) = f = ((struct field *)
+ TYPE_ALLOC (t,
+ nfields * sizeof (struct field)));
if (type_code == TYPE_CODE_ENUM)
{
/* This is a non-empty enum. */
- for (tsym = sh + 1; tsym->st == stMember; tsym++)
+ for (ext_tsym = ext_sh + external_sym_size;
+ ;
+ ext_tsym += external_sym_size)
{
+ SYMR tsym;
struct symbol *enum_sym;
- f->bitpos = tsym->value;
+
+ (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
+
+ if (tsym.st != stMember)
+ break;
+
+ f->bitpos = tsym.value;
f->type = t;
- f->name = (char *) tsym->iss;
+ f->name = (ecoff_data (cur_bfd)->ss
+ + cur_fdr->issBase
+ + tsym.iss);
f->bitsize = 0;
enum_sym = ((struct symbol *)
SYMBOL_CLASS (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
- SYMBOL_VALUE (enum_sym) = tsym->value;
+ SYMBOL_VALUE (enum_sym) = tsym.value;
add_symbol (enum_sym, top_stack->cur_block);
/* Skip the stMembers that we've handled. */
f++;
}
}
- SYMBOL_TYPE (s) = t;
/* make this the current type */
top_stack->cur_type = t;
top_stack->cur_field = 0;
- /* Mark that symbol has a type, and say which one */
- sh->value = (long) t;
+
+ /* Do not create a symbol for alpha cc unnamed structs. */
+ if (sh->iss == 0)
+ break;
+ s = new_symbol (name);
+ SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
+ SYMBOL_CLASS (s) = LOC_TYPEDEF;
+ SYMBOL_VALUE (s) = 0;
+ SYMBOL_TYPE (s) = t;
+
+ /* gcc puts out an empty struct for an opaque struct definitions. */
+ if (TYPE_NFIELDS (t) == 0)
+ {
+ TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
+ SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ }
+ add_symbol (s, top_stack->cur_block);
break;
/* End of local variables shared by struct, union, enum, and
break;
case stEnd: /* end (of anything) */
- if (sh->sc == scInfo)
+ if (sh->sc == scInfo || sh->sc == scCommon)
{
/* Finished with type */
top_stack->cur_type = 0;
}
- else if (sh->sc == scText
- && (top_stack->blocktype == stProc
- || top_stack->blocktype == stStaticProc))
+ else if (sh->sc == scText &&
+ (top_stack->blocktype == stProc ||
+ top_stack->blocktype == stStaticProc))
{
/* Finished with procedure */
struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
e = ((struct mips_extra_func_info *)
obstack_alloc (¤t_objfile->symbol_obstack,
sizeof (struct mips_extra_func_info)));
- SYMBOL_VALUE (s) = (int) e;
+ SYMBOL_VALUE (s) = (long) e;
e->numargs = top_stack->numargs;
add_symbol (s, top_stack->cur_block);
b = shrink_block (top_stack->cur_block, top_stack->cur_st);
/* f77 emits proc-level with address bounds==[0,0],
- So look for such child blocks, and patch them. */
+ So look for such child blocks, and patch them. */
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
{
struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
}
else if (sh->sc == scText && top_stack->blocktype == stBlock)
{
- /* End of (code) block. The value of the symbol
- is the displacement from the procedure`s start
- address of the end of this block. */
+ /* End of (code) block. The value of the symbol is the
+ displacement from the procedure`s start address of the
+ end of this block. */
BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
shrink_block (top_stack->cur_block, top_stack->cur_st);
}
else if (sh->sc == scText && top_stack->blocktype == stFile)
{
/* End of file. Pop parse stack and ignore. Higher
- level code deals with this. */
+ level code deals with this. */
;
}
else
case stMember: /* member of struct or union */
f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
- f->name = (char *) sh->iss;
+ f->name = name;
f->bitpos = sh->value;
f->bitsize = 0;
- f->type = parse_type (ax + sh->index, &f->bitsize, bigend);
+ f->type = parse_type (cur_fd, ax + sh->index, &f->bitsize, bigend, name);
break;
case stTypedef: /* type definition */
- s = new_symbol ((char *) sh->iss);
+ /* Typedefs for forward declarations and opaque structs from alpha cc
+ are handled by cross_ref, skip them. */
+ if (sh->iss == 0)
+ break;
+
+ /* Parse the type or use the pending type. */
+ pend = is_pending_symbol (cur_fdr, ext_sh);
+ if (pend == (struct mips_pending *) NULL)
+ {
+ t = parse_type (cur_fd, ax + sh->index, (int *)NULL, bigend, name);
+ add_pending (cur_fdr, ext_sh, t);
+ }
+ else
+ t = pend->t;
+
+ /* mips cc puts out a typedef with the name of the struct for forward
+ declarations. These should not go into the symbol table and
+ TYPE_NAME should not be set for them.
+ They can't be distinguished from an intentional typedef to
+ the same name however:
+ x.h:
+ struct x { int ix; int jx; };
+ struct xx;
+ x.c:
+ typedef struct x x;
+ struct xx {int ixx; int jxx; };
+ generates a cross referencing stTypedef for x and xx.
+ The user visible effect of this is that the type of a pointer
+ to struct foo sometimes is given as `foo *' instead of `struct foo *'.
+ The problem is fixed with alpha cc. */
+
+ s = new_symbol (name);
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
SYMBOL_CLASS (s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
+ SYMBOL_TYPE (s) = t;
add_symbol (s, top_stack->cur_block);
- SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend);
- sh->value = (long) SYMBOL_TYPE (s);
+
+ /* Incomplete definitions of structs should not get a name. */
+ if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
+ && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
+ || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
+ && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
+ {
+ if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
+ || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
+ {
+ /* If we are giving a name to a type such as "pointer to
+ foo" or "function returning foo", we better not set
+ the TYPE_NAME. If the program contains "typedef char
+ *caddr_t;", we don't want all variables of type char
+ * to print as caddr_t. This is not just a
+ consequence of GDB's type management; CC and GCC (at
+ least through version 2.4) both output variables of
+ either type char * or caddr_t with the type
+ refering to the stTypedef symbol for caddr_t. If a future
+ compiler cleans this up it GDB is not ready for it
+ yet, but if it becomes ready we somehow need to
+ disable this check (without breaking the PCC/GCC2.4
+ case).
+
+ Sigh.
+
+ Fortunately, this check seems not to be necessary
+ for anything except pointers or functions. */
+ }
+ else
+ TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
+ }
break;
case stFile: /* file name */
complain (&unknown_mips_symtype_complaint, sh->st);
break;
}
- sh->st = stParsed;
+
return count;
}
they are big-endian or little-endian (from fh->fBigendian). */
static struct type *
-parse_type (ax, bs, bigend)
+parse_type (fd, ax, bs, bigend, sym_name)
+ int fd;
union aux_ext *ax;
int *bs;
int bigend;
+ char *sym_name;
{
/* Null entries in this map are treated specially */
static struct type **map_bt[] =
0, /* btBit */
0, /* btPicture */
&builtin_type_void, /* btVoid */
- &builtin_type_long_long, /* btLongLong */
- &builtin_type_unsigned_long_long, /* btULongLong */
+ 0, /* DEC C++: Pointer to member */
+ 0, /* DEC C++: Virtual function table */
+ 0, /* DEC C++: Class (Record) */
+ &builtin_type_long, /* btLong64 */
+ &builtin_type_unsigned_long, /* btULong64 */
+ &builtin_type_long_long, /* btLongLong64 */
+ &builtin_type_unsigned_long_long, /* btULongLong64 */
+ &builtin_type_unsigned_long, /* btAdr64 */
+ &builtin_type_long, /* btInt64 */
+ &builtin_type_unsigned_long, /* btUInt64 */
};
TIR t[1];
struct type *tp = 0;
- char *fmt;
union aux_ext *tax;
- enum type_code type_code;
+ enum type_code type_code = TYPE_CODE_UNDEF;
/* Use aux as a type information record, map its basic type. */
tax = ax;
ecoff_swap_tir_in (bigend, &tax->a_ti, t);
- if (t->bt > (sizeof (map_bt) / sizeof (*map_bt)))
+ if (t->bt >= (sizeof (map_bt) / sizeof (*map_bt)))
{
- complain (&basic_type_complaint, t->bt);
+ complain (&basic_type_complaint, t->bt, sym_name);
return builtin_type_int;
}
if (map_bt[t->bt])
{
tp = *map_bt[t->bt];
- fmt = "%s";
}
else
{
{
case btAdr:
tp = lookup_pointer_type (builtin_type_void);
- fmt = "%s";
break;
case btStruct:
type_code = TYPE_CODE_STRUCT;
- fmt = "struct %s";
break;
case btUnion:
type_code = TYPE_CODE_UNION;
- fmt = "union %s";
break;
case btEnum:
type_code = TYPE_CODE_ENUM;
- fmt = "enum %s";
break;
case btRange:
type_code = TYPE_CODE_RANGE;
- fmt = "%s";
break;
case btSet:
type_code = TYPE_CODE_SET;
- fmt = "set %s";
break;
case btTypedef:
+ /* alpha cc uses this for typedefs. The true type will be
+ obtained by crossreferencing below. */
+ type_code = TYPE_CODE_ERROR;
+ break;
default:
- complain (&basic_type_complaint, t->bt);
+ complain (&basic_type_complaint, t->bt, sym_name);
return builtin_type_int;
}
}
do
{
ax++;
- ecoff_swap_tir_in (bigend, ax, t1);
+ ecoff_swap_tir_in (bigend, &ax->a_ti, t1);
}
while (t1->continued);
}
if (t->fBitfield)
{
+ /* Inhibit core dumps with some cfront generated objects that
+ corrupt the TIR. */
+ if (bs == (int *)NULL)
+ {
+ complain (&bad_fbitfield_complaint, sym_name);
+ return builtin_type_int;
+ }
*bs = AUX_GET_WIDTH (bigend, ax);
ax++;
}
/* All these types really point to some (common) MIPS type
definition, and only the type-qualifiers fully identify
them. We'll make the same effort at sharing. */
- if (t->bt == btIndirect ||
- t->bt == btStruct ||
+ if (t->bt == btStruct ||
t->bt == btUnion ||
t->bt == btEnum ||
- t->bt == btTypedef ||
- t->bt == btRange ||
+
+ /* btSet (I think) implies that the name is a tag name, not a typedef
+ name. This apparently is a MIPS extension for C sets. */
t->bt == btSet)
{
- char name[256], *pn;
-
- /* Try to cross reference this type */
- ax += cross_ref (ax, &tp, type_code, &pn, bigend);
- /* reading .o file ? */
- if (UNSAFE_DATA_ADDR (tp))
- tp = init_type (type_code, 0, 0, (char *) NULL,
- (struct objfile *) NULL);
- /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */
- sprintf (name, fmt, pn);
-
- /* Usually, TYPE_CODE(tp) is already type_code. The main
- exception is if we guessed wrong re struct/union/enum. */
- if (TYPE_CODE (tp) != type_code)
+ char *name;
+
+ /* Try to cross reference this type, build new type on failure. */
+ ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
+ if (tp == (struct type *) NULL)
+ tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+
+ /* Make sure that TYPE_CODE(tp) has an expected type code.
+ Any type may be returned from cross_ref if file indirect entries
+ are corrupted. */
+ if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
+ && TYPE_CODE (tp) != TYPE_CODE_UNION
+ && TYPE_CODE (tp) != TYPE_CODE_ENUM)
+ {
+ complain (&unexpected_type_code_complaint, sym_name);
+ }
+ else
+ {
+
+ /* Usually, TYPE_CODE(tp) is already type_code. The main
+ exception is if we guessed wrong re struct/union/enum.
+ But for struct vs. union a wrong guess is harmless, so
+ don't complain(). */
+ if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
+ && type_code != TYPE_CODE_ENUM)
+ || (TYPE_CODE (tp) != TYPE_CODE_ENUM
+ && type_code == TYPE_CODE_ENUM))
+ {
+ complain (&bad_tag_guess_complaint, sym_name);
+ }
+
+ if (TYPE_CODE (tp) != type_code)
+ {
+ TYPE_CODE (tp) = type_code;
+ }
+
+ /* Do not set the tag name if it is a compiler generated tag name
+ (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
+ if (name[0] == '.' || name[0] == '\0')
+ TYPE_TAG_NAME (tp) = NULL;
+ else if (TYPE_TAG_NAME (tp) == NULL
+ || !STREQ (TYPE_TAG_NAME (tp), name))
+ TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name),
+ ¤t_objfile->type_obstack);
+ }
+ }
+
+ /* All these types really point to some (common) MIPS type
+ definition, and only the type-qualifiers fully identify
+ them. We'll make the same effort at sharing.
+ FIXME: btIndirect cannot happen here as it is handled by the
+ switch t->bt above. And we are not doing any guessing on range types. */
+ if (t->bt == btIndirect ||
+ t->bt == btRange)
+ {
+ char *name;
+
+ /* Try to cross reference this type, build new type on failure. */
+ ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
+ if (tp == (struct type *) NULL)
+ tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+
+ /* Make sure that TYPE_CODE(tp) has an expected type code.
+ Any type may be returned from cross_ref if file indirect entries
+ are corrupted. */
+ if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
{
- complain (&bad_tag_guess_complaint, name);
- TYPE_CODE (tp) = type_code;
+ complain (&unexpected_type_code_complaint, sym_name);
+ }
+ else
+ {
+ /* Usually, TYPE_CODE(tp) is already type_code. The main
+ exception is if we guessed wrong re struct/union/enum. */
+ if (TYPE_CODE (tp) != type_code)
+ {
+ complain (&bad_tag_guess_complaint, sym_name);
+ TYPE_CODE (tp) = type_code;
+ }
+ if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
+ TYPE_NAME (tp) = obsavestring (name, strlen (name),
+ ¤t_objfile->type_obstack);
+ }
+ }
+ if (t->bt == btTypedef)
+ {
+ char *name;
+
+ /* Try to cross reference this type, it should succeed. */
+ ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
+ if (tp == (struct type *) NULL)
+ {
+ complain (&unable_to_cross_ref_complaint, sym_name);
+ tp = builtin_type_int;
}
- if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
- TYPE_NAME (tp) = obsavestring (name, strlen (name),
- ¤t_objfile->type_obstack);
}
/* Deal with range types */
}
/* Parse all the type qualifiers now. If there are more
- than 6 the game will continue in the next aux */
+ than 6 the game will continue in the next aux */
#define PARSE_TQ(tq) \
- if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
+ if (t->tq != tqNil) ax += upgrade_type(fd, &tp, t->tq, ax, bigend);
again:PARSE_TQ (tq0);
PARSE_TQ (tq1);
Returns the number of aux symbols we parsed. */
static int
-upgrade_type (tpp, tq, ax, bigend)
+upgrade_type (fd, tpp, tq, ax, bigend)
+ int fd;
struct type **tpp;
int tq;
union aux_ext *ax;
off = 0;
/* Determine and record the domain type (type of index) */
- ecoff_swap_rndx_in (bigend, ax, &rndx);
+ ecoff_swap_rndx_in (bigend, &ax->a_rndx, &rndx);
id = rndx.index;
rf = rndx.rfd;
if (rf == 0xfff)
rf = AUX_GET_ISYM (bigend, ax);
off++;
}
- fh = get_rfd (cur_fd, rf);
+ fh = get_rfd (fd, rf);
- indx = parse_type (id + (union aux_ext *) fh->iauxBase,
- (int *) NULL, bigend);
+ indx = parse_type (fd,
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase
+ + id),
+ (int *) NULL, bigend, "<array index>");
/* Get the bounds, and create the array type. */
ax++;
}
-/* Parse a procedure descriptor record PR. Note that the procedure
- is parsed _after_ the local symbols, now we just insert the extra
- information we need into a MIPS_EFI_SYMBOL_NAME symbol that has already
- been placed in the procedure's main block. Note also that images that
- have been partially stripped (ld -x) have been deprived
- of local symbols, and we have to cope with them here.
- The procedure's code ends at BOUND */
+/* Parse a procedure descriptor record PR. Note that the procedure is
+ parsed _after_ the local symbols, now we just insert the extra
+ information we need into a MIPS_EFI_SYMBOL_NAME symbol that has
+ already been placed in the procedure's main block. Note also that
+ images that have been partially stripped (ld -x) have been deprived
+ of local symbols, and we have to cope with them here. FIRST_OFF is
+ the offset of the first procedure for this FDR; we adjust the
+ address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab
+ to look for the function which contains the MIPS_EFI_SYMBOL_NAME symbol
+ in question, or NULL to use top_stack->cur_block. */
+
+static void parse_procedure PARAMS ((PDR *, struct symtab *, unsigned long));
static void
-parse_procedure (pr, bound, have_stabs)
+parse_procedure (pr, search_symtab, first_off)
PDR *pr;
- int bound;
- int have_stabs;
+ struct symtab *search_symtab;
+ unsigned long first_off;
{
struct symbol *s, *i;
- SYMR *sh = (SYMR *) pr->isym;
struct block *b;
struct mips_extra_func_info *e;
char *sh_name;
- /* Static procedure at address pr->adr. Sigh. */
- if (sh == (SYMR *) - 1)
+ /* Simple rule to find files linked "-x" */
+ if (cur_fdr->rss == -1)
{
- complain (&pdr_static_symbol_complaint, pr->adr);
- return;
+ if (pr->isym == -1)
+ {
+ /* Static procedure at address pr->adr. Sigh. */
+ complain (&pdr_static_symbol_complaint, pr->adr);
+ return;
+ }
+ else
+ {
+ /* external */
+ EXTR she;
+
+ (*ecoff_backend (cur_bfd)->swap_ext_in)
+ (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_ext
+ + pr->isym * ecoff_backend (cur_bfd)->external_ext_size),
+ &she);
+ sh_name = ecoff_data (cur_bfd)->ssext + she.asym.iss;
+ }
+ }
+ else
+ {
+ /* Full symbols */
+ SYMR sh;
+
+ (*ecoff_backend (cur_bfd)->swap_sym_in)
+ (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((cur_fdr->isymBase + pr->isym)
+ * ecoff_backend (cur_bfd)->external_sym_size)),
+ &sh);
+ sh_name = ecoff_data (cur_bfd)->ss + cur_fdr->issBase + sh.iss;
+ }
+
+ if (search_symtab != NULL)
+ {
+#if 0
+ /* This loses both in the case mentioned (want a static, find a global),
+ but also if we are looking up a non-mangled name which happens to
+ match the name of a mangled function. */
+ /* We have to save the cur_fdr across the call to lookup_symbol.
+ If the pdr is for a static function and if a global function with
+ the same name exists, lookup_symbol will eventually read in the symtab
+ for the global function and clobber cur_fdr. */
+ FDR *save_cur_fdr = cur_fdr;
+ s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
+ cur_fdr = save_cur_fdr;
+#else
+ s = mylookup_symbol
+ (sh_name,
+ BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
+ VAR_NAMESPACE,
+ LOC_BLOCK);
+#endif
}
- sh_name = (char *) sh->iss;
- if (have_stabs)
- s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
else
s = mylookup_symbol (sh_name, top_stack->cur_block,
VAR_NAMESPACE, LOC_BLOCK);
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = pr->adr;
+ /* BOUND used to be the end of procedure's text, but the
+ argument is no longer passed in. */
BLOCK_END (b) = bound;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
add_block (b, top_stack->cur_st);
e = (struct mips_extra_func_info *) SYMBOL_VALUE (i);
e->pdr = *pr;
e->pdr.isym = (long) s;
+ e->pdr.adr += cur_fdr->adr - first_off;
+
+ /* Correct incorrect setjmp procedure descriptor from the library
+ to make backtrace through setjmp work. */
+ if (e->pdr.pcreg == 0 && strcmp (sh_name, "setjmp") == 0)
+ {
+ complain (&bad_setjmp_pdr_complaint, 0);
+ e->pdr.pcreg = RA_REGNUM;
+ e->pdr.regmask = 0x80000000;
+ e->pdr.regoffset = -4;
+ }
}
}
if (es->ifd != ifdNil)
{
cur_fd = es->ifd;
- cur_fdr = (FDR *) (cur_hdr->cbFdOffset) + cur_fd;
- ax = (union aux_ext *) cur_fdr->iauxBase;
+ cur_fdr = ecoff_data (cur_bfd)->fdr + cur_fd;
+ ax = ecoff_data (cur_bfd)->external_aux + cur_fdr->iauxBase;
}
else
{
- cur_fdr = (FDR *) (cur_hdr->cbFdOffset);
+ cur_fdr = ecoff_data (cur_bfd)->fdr;
ax = 0;
}
/* FIXME: Turn this into a complaint? */
if (info_verbose)
printf_filtered ("Warning: %s `%s' is undefined (in %s)\n",
- what, es->asym.iss, fdr_name ((char *) cur_fdr->rss));
+ what,
+ ecoff_data (cur_bfd)->ssext + es->asym.iss,
+ fdr_name (cur_fdr));
return;
}
/* If we have full symbols we do not need more */
if (skip_procedures)
return;
- if (mylookup_symbol ((char *) es->asym.iss, top_stack->cur_block,
+ if (mylookup_symbol (ecoff_data (cur_bfd)->ssext + es->asym.iss,
+ top_stack->cur_block,
VAR_NAMESPACE, LOC_BLOCK))
break;
/* fall through */
case stGlobal:
case stLabel:
- /*
- * Note that the case of a symbol with indexNil
- * must be handled anyways by parse_symbol().
- */
- parse_symbol (&es->asym, ax, bigend);
+ /* Note that the case of a symbol with indexNil must be handled
+ anyways by parse_symbol(). */
+ parse_symbol (&es->asym, ax, (char *) NULL, bigend);
break;
default:
break;
with that and do not need to reorder our linetables */
static void
-parse_lines (fh, lt)
+parse_lines (fh, pr, lt)
FDR *fh;
+ PDR *pr;
struct linetable *lt;
{
- unsigned char *base = (unsigned char *) fh->cbLineOffset;
+ unsigned char *base;
int j, k;
int delta, count, lineno = 0;
- PDR *pr;
+ unsigned long first_off = pr->adr;
- if (base == 0)
+ if (fh->cbLine == 0)
return;
+ base = ecoff_data (cur_bfd)->line + fh->cbLineOffset;
+
/* Scan by procedure descriptors */
- j = 0, k = 0;
- for (pr = (PDR *) IPDFIRST (cur_hdr, fh); j < fh->cpd; j++, pr++)
+ k = 0;
+ for (j = 0; j < fh->cpd; j++, pr++)
{
- int l, halt;
+ long l, halt;
+ unsigned long adr;
/* No code for this one */
if (pr->iline == ilineNil ||
pr->lnLow == -1 || pr->lnHigh == -1)
continue;
- /*
- * Aurgh! To know where to stop expanding we
- * must look-ahead.
- */
+
+ /* Aurgh! To know where to stop expanding we must look-ahead. */
for (l = 1; l < (fh->cpd - j); l++)
if (pr[l].iline != -1)
break;
halt = fh->cline;
else
halt = pr[l].iline;
- /*
- * When procedures are moved around the linenumbers
- * are attributed to the next procedure up
- */
+
+ /* When procedures are moved around the linenumbers are
+ attributed to the next procedure up. */
if (pr->iline >= halt)
continue;
- base = (unsigned char *) pr->cbLineOffset;
- l = pr->adr >> 2; /* in words */
- halt += (pr->adr >> 2) - pr->iline;
+ base = ecoff_data (cur_bfd)->line + fh->cbLineOffset + pr->cbLineOffset;
+ adr = fh->adr + pr->adr - first_off;
+ l = adr >> 2; /* in words */
+ halt += (adr >> 2) - pr->iline;
for (lineno = pr->lnLow; l < halt;)
{
count = *base & 0x0f;
}
\f
/* Master parsing procedure for first-pass reading of file symbols
- into a partial_symtab.
-
- Parses the symtab described by the global symbolic header CUR_HDR.
- END_OF_TEXT_SEG gives the address just after the text segment for
- the symtab we are reading. */
+ into a partial_symtab. */
static void
-parse_partial_symbols (end_of_text_seg, objfile, section_offsets)
- int end_of_text_seg;
+parse_partial_symbols (objfile, section_offsets)
struct objfile *objfile;
struct section_offsets *section_offsets;
{
+ const struct ecoff_backend_data * const backend = ecoff_backend (cur_bfd);
+ const bfd_size_type external_sym_size = backend->external_sym_size;
+ const bfd_size_type external_rfd_size = backend->external_rfd_size;
+ const bfd_size_type external_ext_size = backend->external_ext_size;
+ void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
+ = backend->swap_ext_in;
+ void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
+ = backend->swap_sym_in;
+ void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
+ = backend->swap_rfd_in;
int f_idx, s_idx;
- HDRR *hdr = cur_hdr;
+ HDRR *hdr = &ecoff_data (cur_bfd)->symbolic_header;
/* Running pointers */
FDR *fh;
- register EXTR *esh;
- register SYMR *sh;
+ char *ext_out;
+ char *ext_out_end;
+ EXTR *ext_block;
+ register EXTR *ext_in;
+ EXTR *ext_in_end;
+ SYMR sh;
struct partial_symtab *pst;
int past_first_source_file = 0;
char **psymtab_include_list;
int includes_allocated;
int includes_used;
- EXTR **extern_tab;
+ EXTR *extern_tab;
struct pst_map *fdr_to_pst;
/* Index within current psymtab dependency list */
struct partial_symtab **dependency_list;
int dependencies_used, dependencies_allocated;
struct cleanup *old_chain;
char *name;
+ enum language prev_language;
- extern_tab = (EXTR **) obstack_alloc (&objfile->psymbol_obstack,
- sizeof (EXTR *) * hdr->iextMax);
+ extern_tab = (EXTR *) obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (EXTR) * hdr->iextMax);
includes_allocated = 30;
includes_used = 0;
last_source_file = NULL;
/*
- * Big plan:
- *
- * Only parse the Local and External symbols, and the Relative FDR.
- * Fixup enough of the loader symtab to be able to use it.
- * Allocate space only for the file's portions we need to
- * look at. (XXX)
- */
+ * Big plan:
+ *
+ * Only parse the Local and External symbols, and the Relative FDR.
+ * Fixup enough of the loader symtab to be able to use it.
+ * Allocate space only for the file's portions we need to
+ * look at. (XXX)
+ */
max_gdbinfo = 0;
max_glevel = MIN_GLEVEL;
FDR_IDX (pst) = -1;
}
+ /* Allocate the global pending list. */
+ ECOFF_PENDING_LIST (objfile) =
+ ((struct mips_pending **)
+ obstack_alloc (&objfile->psymbol_obstack,
+ hdr->ifdMax * sizeof (struct mips_pending *)));
+ memset ((PTR) ECOFF_PENDING_LIST (objfile), 0,
+ hdr->ifdMax * sizeof (struct mips_pending *));
+
+ /* Pass 0 over external syms: swap them in. */
+ ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
+ make_cleanup (free, ext_block);
+
+ ext_out = (char *) ecoff_data (cur_bfd)->external_ext;
+ ext_out_end = ext_out + hdr->iextMax * external_ext_size;
+ ext_in = ext_block;
+ for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
+ (*swap_ext_in) (cur_bfd, ext_out, ext_in);
+
/* Pass 1 over external syms: Presize and partition the list */
- for (s_idx = 0; s_idx < hdr->iextMax; s_idx++)
- {
- esh = (EXTR *) (hdr->cbExtOffset) + s_idx;
- fdr_to_pst[esh->ifd].n_globals++;
- }
+ ext_in = ext_block;
+ ext_in_end = ext_in + hdr->iextMax;
+ for (; ext_in < ext_in_end; ext_in++)
+ fdr_to_pst[ext_in->ifd].n_globals++;
/* Pass 1.5 over files: partition out global symbol space */
s_idx = 0;
}
/* Pass 2 over external syms: fill in external symbols */
- for (s_idx = 0; s_idx < hdr->iextMax; s_idx++)
+ ext_in = ext_block;
+ ext_in_end = ext_in + hdr->iextMax;
+ for (; ext_in < ext_in_end; ext_in++)
{
enum minimal_symbol_type ms_type = mst_text;
- esh = (EXTR *) (hdr->cbExtOffset) + s_idx;
- extern_tab[fdr_to_pst[esh->ifd].globals_offset
- + fdr_to_pst[esh->ifd].n_globals++] = esh;
+ extern_tab[fdr_to_pst[ext_in->ifd].globals_offset
+ + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in;
- if (esh->asym.sc == scUndefined || esh->asym.sc == scNil)
+ if (ext_in->asym.sc == scUndefined || ext_in->asym.sc == scNil)
continue;
- switch (esh->asym.st)
+ name = ecoff_data (cur_bfd)->ssext + ext_in->asym.iss;
+ switch (ext_in->asym.st)
{
case stProc:
break;
+ case stStaticProc:
+ ms_type = mst_file_text;
+ break;
case stGlobal:
- ms_type = mst_data;
+ if (ext_in->asym.sc == scData
+ || ext_in->asym.sc == scSData
+ || ext_in->asym.sc == scRData)
+ ms_type = mst_data;
+ else
+ ms_type = mst_bss;
break;
case stLabel:
+ if (ext_in->asym.sc == scAbs)
+ ms_type = mst_abs;
+ else if (ext_in->asym.sc == scText)
+ ms_type = mst_text;
+ else if (ext_in->asym.sc == scData
+ || ext_in->asym.sc == scSData
+ || ext_in->asym.sc == scRData)
+ ms_type = mst_data;
+ else
+ ms_type = mst_bss;
break;
default:
ms_type = mst_unknown;
- complain (&unknown_ext_complaint, esh->asym.iss);
+ complain (&unknown_ext_complaint, name);
}
- name = (char *) esh->asym.iss;
- prim_record_minimal_symbol (name, esh->asym.value, ms_type);
+ prim_record_minimal_symbol (name, ext_in->asym.value, ms_type);
}
/* Pass 3 over files, over local syms: fill in static symbols */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
struct partial_symtab *save_pst;
- EXTR **ext_ptr;
+ EXTR *ext_ptr;
- cur_fdr = fh = f_idx + (FDR *) (cur_hdr->cbFdOffset);
+ cur_fdr = fh = ecoff_data (cur_bfd)->fdr + f_idx;
if (fh->csym == 0)
{
fdr_to_pst[f_idx].pst = NULL;
continue;
}
- pst = start_psymtab_common (objfile, section_offsets, (char *) fh->rss,
+ pst = start_psymtab_common (objfile, section_offsets,
+ fdr_name (fh),
fh->cpd ? fh->adr : 0,
objfile->global_psymbols.next,
objfile->static_psymbols.next);
pst->read_symtab_private = ((char *)
obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct symloc)));
+ memset ((PTR) pst->read_symtab_private, 0, sizeof (struct symloc));
save_pst = pst;
- /* Make everything point to everything. */
FDR_IDX (pst) = f_idx;
- fdr_to_pst[f_idx].pst = pst;
- fh->ioptBase = (int) pst;
-
- CUR_HDR (pst) = cur_hdr;
+ CUR_BFD (pst) = cur_bfd;
/* The way to turn this into a symtab is to call... */
pst->read_symtab = mipscoff_psymtab_to_symtab;
+ /* Set up language for the pst.
+ The language from the FDR is used if it is unambigious (e.g. cfront
+ with native cc and g++ will set the language to C).
+ Otherwise we have to deduce the language from the filename.
+ Native ecoff has every header file in a separate FDR, so
+ deduce_language_from_filename will return language_unknown for
+ a header file, which is not what we want.
+ But the FDRs for the header files are after the FDR for the source
+ file, so we can assign the language of the source file to the
+ following header files. Then we save the language in the private
+ pst data so that we can reuse it when building symtabs. */
+ prev_language = psymtab_language;
+
+ switch (fh->lang)
+ {
+ case langCplusplusV2:
+ psymtab_language = language_cplus;
+ break;
+ default:
+ psymtab_language = deduce_language_from_filename (fdr_name (fh));
+ break;
+ }
+ if (psymtab_language == language_unknown)
+ psymtab_language = prev_language;
+ PST_PRIVATE (pst)->pst_language = psymtab_language;
+
pst->texthigh = pst->textlow;
/* For stabs-in-ecoff files, the second symbol must be @stab.
- This symbol is emitted by mips-tfile to signal
- that the current object file uses encapsulated stabs
- instead of mips ecoff for local symbols.
- (It is the second symbol because the first symbol is
- the stFile used to signal the start of a file). */
- if (fh->csym >= 2
- && STREQ ((char *) (((SYMR *) fh->isymBase)[1].iss), stabs_symbol))
+ This symbol is emitted by mips-tfile to signal that the
+ current object file uses encapsulated stabs instead of mips
+ ecoff for local symbols. (It is the second symbol because
+ the first symbol is the stFile used to signal the start of a
+ file). */
+ processing_gcc_compilation = 0;
+ if (fh->csym >= 2)
+ {
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + (fh->isymBase + 1) * external_sym_size),
+ &sh);
+ if (STREQ (ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss,
+ stabs_symbol))
+ processing_gcc_compilation = 2;
+ }
+
+ if (processing_gcc_compilation != 0)
{
- processing_gcc_compilation = 2;
for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
{
int type_code;
char *namestring;
- sh = cur_sdx + (SYMR *) fh->isymBase;
- type_code = MIPS_UNMARK_STAB (sh->index);
- if (!MIPS_IS_STAB (sh))
+
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + (fh->isymBase + cur_sdx) * external_sym_size),
+ &sh);
+ type_code = ECOFF_UNMARK_STAB (sh.index);
+ if (!ECOFF_IS_STAB (&sh))
{
- if (sh->st == stProc || sh->st == stStaticProc)
+ if (sh.st == stProc || sh.st == stStaticProc)
{
- long procaddr = sh->value;
- sh = (AUX_GET_ISYM (fh->fBigendian,
- (sh->index
- + (union aux_ext *) (fh->iauxBase)))
- + (SYMR *) fh->isymBase - 1);
- if (sh->st == stEnd)
+ long procaddr = sh.value;
+ long isym;
+
+
+ isym = AUX_GET_ISYM (fh->fBigendian,
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase
+ + sh.index));
+ (*swap_sym_in) (cur_bfd,
+ (((char *)
+ ecoff_data (cur_bfd)->external_sym)
+ + ((fh->isymBase + isym - 1)
+ * external_sym_size)),
+ &sh);
+ if (sh.st == stEnd)
{
- long high = procaddr + sh->value;
+ long high = procaddr + sh.value;
if (high > pst->texthigh)
pst->texthigh = high;
}
}
continue;
}
-#define SET_NAMESTRING() namestring = (char*)sh->iss
+#define SET_NAMESTRING() \
+ namestring = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss
#define CUR_SYMBOL_TYPE type_code
-#define CUR_SYMBOL_VALUE sh->value
+#define CUR_SYMBOL_VALUE sh.value
#define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
pst = save_pst
#define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps) (void)0
}
else
{
- processing_gcc_compilation = 0;
for (cur_sdx = 0; cur_sdx < fh->csym;)
{
char *name;
enum address_class class;
- sh = cur_sdx + (SYMR *) fh->isymBase;
- if (MIPS_IS_STAB (sh))
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((fh->isymBase + cur_sdx)
+ * external_sym_size)),
+ &sh);
+
+ if (ECOFF_IS_STAB (&sh))
{
cur_sdx++;
continue;
}
- if (sh->sc == scUndefined || sh->sc == scNil ||
- sh->index == 0xfffff)
+ /* Non absolute static symbols go into the minimal table. */
+ if (sh.sc == scUndefined || sh.sc == scNil
+ || (sh.index == indexNil
+ && (sh.st != stStatic || sh.sc == scAbs)))
{
/* FIXME, premature? */
cur_sdx++;
continue;
}
- name = (char *) (sh->iss);
+ name = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss;
- switch (sh->st)
+ switch (sh.st)
{
long high;
long procaddr;
int new_sdx;
- case stProc: /* Asm labels apparently */
case stStaticProc: /* Function */
+ /* I believe this is used only for file-local functions.
+ The comment in symconst.h ("load time only static procs")
+ isn't particularly clear on this point. */
+ prim_record_minimal_symbol (name, sh.value, mst_file_text);
+ /* FALLTHROUGH */
+
+ case stProc: /* Asm labels apparently */
ADD_PSYMBOL_TO_LIST (name, strlen (name),
VAR_NAMESPACE, LOC_BLOCK,
- objfile->static_psymbols, sh->value,
+ objfile->static_psymbols, sh.value,
psymtab_language, objfile);
/* Skip over procedure to next one. */
- if (sh->index >= hdr->iauxMax)
+ if (sh.index >= hdr->iauxMax)
{
/* Should not happen, but does when cross-compiling
with the MIPS compiler. FIXME -- pull later. */
}
else
new_sdx = AUX_GET_ISYM (fh->fBigendian,
- sh->index + (union aux_ext *) fh->iauxBase);
- procaddr = sh->value;
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase
+ + sh.index));
+ procaddr = sh.value;
if (new_sdx <= cur_sdx)
{
}
cur_sdx = new_sdx;
- sh = cur_sdx + (SYMR *) fh->isymBase - 1;
- if (sh->st != stEnd)
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((fh->isymBase + cur_sdx - 1)
+ * external_sym_size)),
+ &sh);
+ if (sh.st != stEnd)
continue;
- high = procaddr + sh->value;
+ high = procaddr + sh.value;
if (high > pst->texthigh)
pst->texthigh = high;
continue;
case stStatic: /* Variable */
+ if (sh.sc == scData || sh.sc == scSData || sh.sc == scRData)
+ prim_record_minimal_symbol (name, sh.value, mst_file_data);
+ else
+ prim_record_minimal_symbol (name, sh.value, mst_file_bss);
class = LOC_STATIC;
break;
case stStruct:
case stEnum:
case stBlock: /* { }, str, un, enum*/
- if (sh->sc == scInfo)
+ if (sh.sc == scInfo || sh.sc == scCommon)
{
ADD_PSYMBOL_TO_LIST (name, strlen (name),
STRUCT_NAMESPACE, LOC_TYPEDEF,
objfile->static_psymbols,
- sh->value,
+ sh.value,
psymtab_language, objfile);
}
/* Skip over the block */
- new_sdx = sh->index;
+ new_sdx = sh.index;
if (new_sdx <= cur_sdx)
{
/* This happens with the Ultrix kernel. */
default:
/* Both complaints are valid: one gives symbol name,
the other the offending symbol type. */
- complain (&unknown_sym_complaint, sh->iss);
- complain (&unknown_st_complaint, sh->st);
+ complain (&unknown_sym_complaint, name);
+ complain (&unknown_st_complaint, sh.st);
cur_sdx++;
continue;
}
/* Use this gdb symbol */
ADD_PSYMBOL_TO_LIST (name, strlen (name),
VAR_NAMESPACE, class,
- objfile->static_psymbols, sh->value,
+ objfile->static_psymbols, sh.value,
psymtab_language, objfile);
skip:
cur_sdx++; /* Go to next file symbol */
PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
for (; --cur_sdx >= 0; ext_ptr++)
{
- register struct partial_symbol *psym;
enum address_class class;
+ SYMR *psh;
+ char *name;
- if ((*ext_ptr)->ifd != f_idx)
+ if (ext_ptr->ifd != f_idx)
abort ();
- sh = &(*ext_ptr)->asym;
- switch (sh->st)
+ psh = &ext_ptr->asym;
+ switch (psh->st)
{
case stProc:
+ case stStaticProc:
class = LOC_BLOCK;
break;
case stLabel:
class = LOC_LABEL;
break;
default:
- complain (&unknown_ext_complaint, sh->iss);
+ complain (&unknown_ext_complaint,
+ ecoff_data (cur_bfd)->ssext + psh->iss);
/* Fall through, pretend it's global. */
case stGlobal:
class = LOC_STATIC;
break;
}
- if (objfile->global_psymbols.next >=
- objfile->global_psymbols.list + objfile->global_psymbols.size)
- extend_psymbol_list (&objfile->global_psymbols, objfile);
- psym = objfile->global_psymbols.next++;
- SYMBOL_NAME (psym) = (char *) sh->iss;
- SYMBOL_NAMESPACE (psym) = VAR_NAMESPACE;
- SYMBOL_CLASS (psym) = class;
- SYMBOL_VALUE_ADDRESS (psym) = (CORE_ADDR) sh->value;
+ name = ecoff_data (cur_bfd)->ssext + psh->iss;
+ ADD_PSYMBOL_ADDR_TO_LIST (name, strlen (name),
+ VAR_NAMESPACE, class,
+ objfile->global_psymbols, (CORE_ADDR) psh->value,
+ psymtab_language, objfile);
}
}
- end_psymtab (save_pst, psymtab_include_list, includes_used,
- -1, save_pst->texthigh,
- dependency_list, dependencies_used);
+ /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
+ empty and put on the free list. */
+ fdr_to_pst[f_idx].pst = end_psymtab (save_pst,
+ psymtab_include_list, includes_used,
+ -1, save_pst->texthigh,
+ dependency_list, dependencies_used);
if (objfile->ei.entry_point >= save_pst->textlow &&
objfile->ei.entry_point < save_pst->texthigh)
{
}
}
- /* Mark the last code address, and remember it for later */
- hdr->cbDnOffset = end_of_text_seg;
-
/* Now scan the FDRs for dependencies */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
- int s_id0 = 0;
- fh = f_idx + (FDR *) (cur_hdr->cbFdOffset);
+ fh = f_idx + ecoff_data (cur_bfd)->fdr;
pst = fdr_to_pst[f_idx].pst;
+ if (pst == (struct partial_symtab *)NULL)
+ continue;
+
/* This should catch stabs-in-ecoff. */
if (fh->crfd <= 1)
continue;
- if (fh->cpd == 0)
- { /* If there are no functions defined here ... */
- /* ...then presumably a .h file: drop reverse depends .h->.c */
- for (; s_id0 < fh->crfd; s_id0++)
- {
- RFDT *rh = (RFDT *) (fh->rfdBase) + s_id0;
- if (*rh == f_idx)
- {
- s_id0++; /* Skip self-dependency */
- break;
- }
- }
- }
- pst->number_of_dependencies = fh->crfd - s_id0;
+ /* Skip the first file indirect entry as it is a self dependency
+ for source files or a reverse .h -> .c dependency for header files. */
+ pst->number_of_dependencies = 0;
pst->dependencies =
((struct partial_symtab **)
obstack_alloc (&objfile->psymbol_obstack,
- (pst->number_of_dependencies
+ ((fh->crfd - 1)
* sizeof (struct partial_symtab *))));
- for (s_idx = s_id0; s_idx < fh->crfd; s_idx++)
+ for (s_idx = 1; s_idx < fh->crfd; s_idx++)
{
- RFDT *rh = (RFDT *) (fh->rfdBase) + s_idx;
- if (*rh < 0 || *rh >= hdr->ifdMax)
- complain (&bad_file_number_complaint, *rh);
- else
- pst->dependencies[s_idx - s_id0] = fdr_to_pst[*rh].pst;
- }
- }
- do_cleanups (old_chain);
-}
-
-
-#if 0
-/* Do the initial analisys of the F_IDX-th file descriptor.
- Allocates a partial symtab for it, and builds the list
- of dependent files by recursion. LEV says at which level
- of recursion we are called (to pretty up debug traces) */
-
-static struct partial_symtab *
-parse_fdr (f_idx, lev, objfile)
- int f_idx;
- int lev;
- struct objfile *objfile;
-{
- register FDR *fh;
- register struct partial_symtab *pst;
- int s_idx, s_id0;
+ RFDT rh;
- fh = (FDR *) (cur_hdr->cbFdOffset) + f_idx;
-
- /* Use this to indicate into which symtab this file was parsed */
- if (fh->ioptBase)
- return (struct partial_symtab *) fh->ioptBase;
-
- /* Debuggability level */
- if (compare_glevel (max_glevel, fh->glevel) < 0)
- max_glevel = fh->glevel;
-
- /* Make a new partial_symtab */
- pst = new_psymtab (fh->rss, objfile);
- if (fh->cpd == 0)
- {
- pst->textlow = 0;
- pst->texthigh = 0;
- }
- else
- {
- pst->textlow = fh->adr;
- pst->texthigh = fh->cpd; /* To be fixed later */
- }
-
- /* Make everything point to everything. */
- FDR_IDX (pst) = f_idx;
- fdr_to_pst[f_idx].pst = pst;
- fh->ioptBase = (int) pst;
-
- /* Analyze its dependencies */
- if (fh->crfd <= 1)
- return pst;
-
- s_id0 = 0;
- if (fh->cpd == 0)
- { /* If there are no functions defined here ... */
- /* ...then presumably a .h file: drop reverse depends .h->.c */
- for (; s_id0 < fh->crfd; s_id0++)
- {
- RFDT *rh = (RFDT *) (fh->rfdBase) + s_id0;
- if (*rh == f_idx)
+ (*swap_rfd_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_rfd
+ + (fh->rfdBase + s_idx) * external_rfd_size),
+ &rh);
+ if (rh < 0 || rh >= hdr->ifdMax)
{
- s_id0++; /* Skip self-dependency */
- break;
+ complain (&bad_file_number_complaint, rh);
+ continue;
}
- }
- }
- pst->number_of_dependencies = fh->crfd - s_id0;
- pst->dependencies = ((struct partial_symtab **)
- obstack_alloc (&objfile->psymbol_obstack,
- (pst->number_of_dependencies
- * sizeof (struct partial_symtab *))));
- for (s_idx = s_id0; s_idx < fh->crfd; s_idx++)
- {
- RFDT *rh = (RFDT *) (fh->rfdBase) + s_idx;
- pst->dependencies[s_idx - s_id0] = parse_fdr (*rh, lev + 1, objfile);
- }
+ /* Skip self dependencies of header files. */
+ if (rh == f_idx)
+ continue;
- return pst;
+ /* Do not add to dependeny list if psymtab was empty. */
+ if (fdr_to_pst[rh].pst == (struct partial_symtab *)NULL)
+ continue;
+ pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst;
+ }
+ }
+ do_cleanups (old_chain);
}
-#endif
static char *
mips_next_symbol_text ()
{
+ SYMR sh;
+
cur_sdx++;
- return (char *) ((SYMR *) cur_fdr->isymBase)[cur_sdx].iss;
+ (*ecoff_backend (cur_bfd)->swap_sym_in)
+ (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((cur_fdr->isymBase + cur_sdx)
+ * ecoff_backend (cur_bfd)->external_sym_size)),
+ &sh);
+ return ecoff_data (cur_bfd)->ss + cur_fdr->issBase + sh.iss;
}
/* Ancillary function to psymtab_to_symtab(). Does all the work
struct partial_symtab *pst;
char *filename;
{
+ const bfd_size_type external_sym_size
+ = ecoff_backend (cur_bfd)->external_sym_size;
+ const bfd_size_type external_pdr_size
+ = ecoff_backend (cur_bfd)->external_pdr_size;
+ void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
+ = ecoff_backend (cur_bfd)->swap_sym_in;
+ void (* const swap_pdr_in) PARAMS ((bfd *, PTR, PDR *))
+ = ecoff_backend (cur_bfd)->swap_pdr_in;
int i;
struct symtab *st;
FDR *fh;
struct linetable *lines;
- int bound;
if (pst->readin)
return;
pst->dependencies[i]->filename);
}
+ /* Do nothing if this is a dummy psymtab. */
+
+ if (pst->n_global_syms == 0 && pst->n_static_syms == 0
+ && pst->textlow == 0 && pst->texthigh == 0)
+ return;
+
/* Now read the symbols for this symtab */
+ cur_bfd = CUR_BFD (pst);
current_objfile = pst->objfile;
cur_fd = FDR_IDX (pst);
- fh = (cur_fd == -1) ? 0 : (FDR *) (cur_hdr->cbFdOffset) + FDR_IDX (pst);
+ fh = (cur_fd == -1) ? (FDR *) NULL : ecoff_data (cur_bfd)->fdr + cur_fd;
cur_fdr = fh;
- /* BOUND is the highest core address of this file's procedures */
- bound = (cur_fd == cur_hdr->ifdMax - 1) ?
- cur_hdr->cbDnOffset :
- fh[1].adr;
-
/* See comment in parse_partial_symbols about the @stabs sentinel. */
- if (fh && fh->csym >= 2
- && STREQ ((char *) (((SYMR *) fh->isymBase)[1].iss), stabs_symbol))
+ processing_gcc_compilation = 0;
+ if (fh != (FDR *) NULL && fh->csym >= 2)
{
+ SYMR sh;
+
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + (fh->isymBase + 1) * external_sym_size),
+ &sh);
+ if (STREQ (ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss,
+ stabs_symbol))
+ {
+ /* We indicate that this is a GCC compilation so that certain
+ features will be enabled in stabsread/dbxread. */
+ processing_gcc_compilation = 2;
+ }
+ }
- /*
- * This symbol table contains stabs-in-ecoff entries.
- */
+ if (processing_gcc_compilation != 0)
+ {
+ char *pdr_ptr;
+ char *pdr_end;
+ int first_pdr;
+ unsigned long first_off = 0;
- PDR *pr;
+ /* This symbol table contains stabs-in-ecoff entries. */
- /* We indicate that this is a GCC compilation so that certain features
- will be enabled in stabsread/dbxread. */
- processing_gcc_compilation = 2;
/* Parse local symbols first */
if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */
}
for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++)
{
- register SYMR *sh = cur_sdx + (SYMR *) fh->isymBase;
- char *name = (char *) sh->iss;
- CORE_ADDR valu = sh->value;
- if (MIPS_IS_STAB (sh))
+ SYMR sh;
+ char *name;
+ CORE_ADDR valu;
+
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + (fh->isymBase + cur_sdx) * external_sym_size),
+ &sh);
+ name = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss;
+ valu = sh.value;
+ if (ECOFF_IS_STAB (&sh))
{
- int type_code = MIPS_UNMARK_STAB (sh->index);
+ int type_code = ECOFF_UNMARK_STAB (sh.index);
process_one_symbol (type_code, 0, valu, name,
pst->section_offsets, pst->objfile);
if (type_code == N_FUN)
/* Make up special symbol to contain
procedure specific info */
struct mips_extra_func_info *e =
- (struct mips_extra_func_info *)
- obstack_alloc (¤t_objfile->symbol_obstack,
- sizeof (struct mips_extra_func_info));
+ ((struct mips_extra_func_info *)
+ obstack_alloc (¤t_objfile->symbol_obstack,
+ sizeof (struct mips_extra_func_info)));
struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
SYMBOL_CLASS (s) = LOC_CONST;
SYMBOL_TYPE (s) = builtin_type_void;
- SYMBOL_VALUE (s) = (int) e;
+ SYMBOL_VALUE (s) = (long) e;
add_symbol_to_list (s, &local_symbols);
}
}
- else if (sh->st == stLabel && sh->index != indexNil)
+ else if (sh.st == stLabel && sh.index != indexNil)
{
/* Handle encoded stab line number. */
- record_line (current_subfile, sh->index, valu);
+ record_line (current_subfile, sh.index, valu);
}
+ else if (sh.st == stProc || sh.st == stStaticProc || sh.st == stEnd)
+ /* These are generated by gcc-2.x, do not complain */
+ ;
else
- complain (&stab_unknown_complaint, sh->iss);
+ complain (&stab_unknown_complaint, name);
}
- st = end_symtab (pst->texthigh, 0, 0, pst->objfile);
+ st = end_symtab (pst->texthigh, 0, 0, pst->objfile, SECT_OFF_TEXT);
end_stabs ();
/* Sort the symbol table now, we are done adding symbols to it.
/* This may not be necessary for stabs symtabs. FIXME. */
sort_blocks (st);
- /* Fill in procedure info next. We need to look-ahead to
- find out where each procedure's code ends. */
-
- for (i = 0; i <= fh->cpd - 1; i++)
+ /* Fill in procedure info next. */
+ first_pdr = 1;
+ pdr_ptr = ((char *) ecoff_data (cur_bfd)->external_pdr
+ + fh->ipdFirst * external_pdr_size);
+ pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
+ for (; pdr_ptr < pdr_end; pdr_ptr += external_pdr_size)
{
- pr = (PDR *) (IPDFIRST (cur_hdr, fh)) + i;
- parse_procedure (pr, i < fh->cpd - 1 ? pr[1].adr : bound, 1);
+ PDR pr;
+
+ (*swap_pdr_in) (cur_bfd, pdr_ptr, &pr);
+ if (first_pdr)
+ {
+ first_off = pr.adr;
+ first_pdr = 0;
+ }
+ parse_procedure (&pr, st, first_off);
}
}
else
{
-
- /*
- * This symbol table contains ordinary ecoff entries.
- */
+ /* This symbol table contains ordinary ecoff entries. */
/* FIXME: doesn't use pst->section_offsets. */
int f_max;
int maxlines;
- EXTR **ext_ptr;
-
- processing_gcc_compilation = 0;
+ EXTR *ext_ptr;
/* How many symbols will we need */
/* FIXME, this does not count enum values. */
f_max += fh->csym + fh->cpd;
maxlines = 2 * fh->cline;
st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
+
+ /* The proper language was already determined when building
+ the psymtab, use it. */
+ st->language = PST_PRIVATE (pst)->pst_language;
}
+ psymtab_language = st->language;
+
lines = LINETABLE (st);
- pending_list = (struct mips_pending **) cur_hdr->cbOptOffset;
- if (pending_list == 0)
- {
- pending_list = (struct mips_pending **)
- xzalloc (cur_hdr->ifdMax * sizeof (struct mips_pending *));
- cur_hdr->cbOptOffset = (int) pending_list;
- }
/* Get a new lexical context */
if (fh)
{
- SYMR *sh;
- PDR *pr;
+ char *sym_ptr;
+ char *sym_end;
/* Parse local symbols first */
-
- for (cur_sdx = 0; cur_sdx < fh->csym;)
+ sym_ptr = ((char *) ecoff_data (cur_bfd)->external_sym
+ + fh->isymBase * external_sym_size);
+ sym_end = sym_ptr + fh->csym * external_sym_size;
+ while (sym_ptr < sym_end)
{
- sh = (SYMR *) (fh->isymBase) + cur_sdx;
- cur_sdx += parse_symbol (sh, (union aux_ext *) fh->iauxBase,
- fh->fBigendian);
+ SYMR sh;
+ int c;
+
+ (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
+ c = parse_symbol (&sh,
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase),
+ sym_ptr, fh->fBigendian);
+ sym_ptr += c * external_sym_size;
}
- /* Linenumbers. At the end, check if we can save memory */
-
- parse_lines (fh, lines);
- if (lines->nitems < fh->cline)
- lines = shrink_linetable (lines);
-
- /* Fill in procedure info next. We need to look-ahead to
- find out where each procedure's code ends. */
-
- for (i = 0; i <= fh->cpd - 1; i++)
+ /* Linenumbers. At the end, check if we can save memory.
+ parse_lines has to look ahead an arbitrary number of PDR
+ structures, so we swap them all first. */
+ if (fh->cpd > 0)
{
- pr = (PDR *) (IPDFIRST (cur_hdr, fh)) + i;
- parse_procedure (pr, i < fh->cpd - 1 ? pr[1].adr : bound, 0);
+ PDR *pr_block;
+ struct cleanup *old_chain;
+ char *pdr_ptr;
+ char *pdr_end;
+ PDR *pdr_in;
+ PDR *pdr_in_end;
+
+ pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+
+ old_chain = make_cleanup (free, pr_block);
+
+ pdr_ptr = ((char *) ecoff_data (cur_bfd)->external_pdr
+ + fh->ipdFirst * external_pdr_size);
+ pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
+ pdr_in = pr_block;
+ for (;
+ pdr_ptr < pdr_end;
+ pdr_ptr += external_pdr_size, pdr_in++)
+ (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
+
+ parse_lines (fh, pr_block, lines);
+ if (lines->nitems < fh->cline)
+ lines = shrink_linetable (lines);
+
+ /* Fill in procedure info next. */
+ pdr_in = pr_block;
+ pdr_in_end = pdr_in + fh->cpd;
+ for (; pdr_in < pdr_in_end; pdr_in++)
+ parse_procedure (pdr_in, 0, pr_block->adr);
+
+ do_cleanups (old_chain);
}
}
top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
top_stack->blocktype = stFile;
- top_stack->maxsyms =
- cur_hdr->isymMax + cur_hdr->ipdMax + cur_hdr->iextMax;
+ top_stack->maxsyms = (ecoff_data (cur_bfd)->symbolic_header.isymMax
+ + ecoff_data (cur_bfd)->symbolic_header.ipdMax
+ + ecoff_data (cur_bfd)->symbolic_header.iextMax);
ext_ptr = PST_PRIVATE (pst)->extern_tab;
for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
- parse_external (*ext_ptr, 1, fh->fBigendian);
+ parse_external (ext_ptr, 1, fh->fBigendian);
/* If there are undefined, tell the user */
if (n_undef_symbols)
Return value says how many aux symbols we ate. */
static int
-cross_ref (ax, tpp, type_code, pname, bigend)
+cross_ref (fd, ax, tpp, type_code, pname, bigend, sym_name)
+ int fd;
union aux_ext *ax;
struct type **tpp;
enum type_code type_code; /* Use to alloc new type if none is found. */
char **pname;
int bigend;
+ char *sym_name;
{
RNDXR rn[1];
- unsigned rf;
+ unsigned int rf;
int result = 1;
+ FDR *fh;
+ char *esh;
+ SYMR sh;
+ int xref_fd;
+ struct mips_pending *pend;
+
+ *tpp = (struct type *)NULL;
- ecoff_swap_rndx_in (bigend, ax, rn);
+ ecoff_swap_rndx_in (bigend, &ax->a_rndx, rn);
/* Escape index means 'the next one' */
if (rn->rfd == 0xfff)
rf = rn->rfd;
}
+ /* mips cc uses a rf of -1 for opaque struct definitions.
+ Set TYPE_FLAG_STUB for these types so that check_stub_type will
+ resolve them if the struct gets defined in another compilation unit. */
if (rf == -1)
{
- /* Ooops */
*pname = "<undefined>";
+ *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
+ TYPE_FLAGS (*tpp) |= TYPE_FLAG_STUB;
+ return result;
}
+
+ /* mips cc uses an escaped rn->index of 0 for struct return types
+ of procedures that were compiled without -g. These will always remain
+ undefined. */
+ if (rn->rfd == 0xfff && rn->index == 0)
+ {
+ *pname = "<undefined>";
+ return result;
+ }
+
+ /* Find the relative file descriptor and the symbol in it. */
+ fh = get_rfd (fd, rf);
+ xref_fd = fh - ecoff_data (cur_bfd)->fdr;
+
+ if (rn->index >= fh->csym)
+ {
+ /* File indirect entry is corrupt. */
+ *pname = "<illegal>";
+ complain (&bad_rfd_entry_complaint,
+ sym_name, xref_fd, rn->index);
+ return result;
+ }
+
+ /* If we have processed this symbol then we left a forwarding
+ pointer to the type in the pending list. If not, we`ll put
+ it in a list of pending types, to be processed later when
+ the file will be. In any event, we collect the name for the
+ type here. */
+
+ esh = ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((fh->isymBase + rn->index)
+ * ecoff_backend (cur_bfd)->external_sym_size));
+ (*ecoff_backend (cur_bfd)->swap_sym_in) (cur_bfd, esh, &sh);
+
+ /* Make sure that this type of cross reference can be handled. */
+ if (sh.sc != scInfo
+ || (sh.st != stBlock && sh.st != stTypedef
+ && sh.st != stStruct && sh.st != stUnion
+ && sh.st != stEnum))
+ {
+ /* File indirect entry is corrupt. */
+ *pname = "<illegal>";
+ complain (&bad_rfd_entry_complaint,
+ sym_name, xref_fd, rn->index);
+ return result;
+ }
+
+ *pname = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss;
+
+ pend = is_pending_symbol (fh, esh);
+ if (pend)
+ *tpp = pend->t;
else
{
- /*
- * Find the relative file descriptor and the symbol in it
- */
- FDR *fh = get_rfd (cur_fd, rf);
- SYMR *sh;
- struct type *t;
-
- /*
- * If we have processed this symbol then we left a forwarding
- * pointer to the corresponding GDB symbol. If not, we`ll put
- * it in a list of pending symbols, to be processed later when
- * the file f will be. In any event, we collect the name for
- * the type here. Which is why we made a first pass at
- * strings.
- */
- sh = (SYMR *) (fh->isymBase) + rn->index;
-
- /* Careful, we might be looking at .o files */
- *pname = (UNSAFE_DATA_ADDR (sh->iss)) ? "<undefined>" :
- (char *) sh->iss;
-
- /* Have we parsed it ? */
- if ((!UNSAFE_DATA_ADDR (sh->value)) && (sh->st == stParsed))
- {
- t = (struct type *) sh->value;
- *tpp = t;
- }
- else
+ /* We have not yet seen this type. */
+
+ if (sh.iss == 0 && sh.st == stTypedef)
{
- /* Avoid duplicates */
- struct mips_pending *p = is_pending_symbol (fh, sh);
- if (p)
- *tpp = p->t;
- else
+ TIR tir;
+
+ /* alpha cc puts out a stTypedef with a sh.iss of zero for
+ two cases:
+ a) forward declarations of structs/unions/enums which are not
+ defined in this compilation unit.
+ For these the type will be void. This is a bad design decision
+ as cross referencing across compilation units is impossible
+ due to the missing name.
+ b) forward declarations of structs/unions/enums which are defined
+ later in this file or in another file in the same compilation
+ unit. Simply cross reference those again to get the
+ true type.
+ The forward references are not entered in the pending list and
+ in the symbol table. */
+
+ ecoff_swap_tir_in (bigend,
+ &(ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase + sh.index)->a_ti,
+ &tir);
+ if (tir.tq0 != tqNil)
+ complain (&illegal_forward_tq0_complaint, sym_name);
+ switch (tir.bt)
{
+ case btVoid:
+ *tpp = init_type (type_code, 0, 0, (char *) NULL,
+ current_objfile);
+ *pname = "<undefined>";
+ break;
+
+ case btStruct:
+ case btUnion:
+ case btEnum:
+ cross_ref (xref_fd,
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase + sh.index + 1),
+ tpp, type_code, pname,
+ fh->fBigendian, sym_name);
+ break;
+
+ default:
+ complain (&illegal_forward_bt_complaint, tir.bt, sym_name);
*tpp = init_type (type_code, 0, 0, (char *) NULL,
- (struct objfile *) NULL);
- add_pending (fh, sh, *tpp);
+ current_objfile);
+ break;
}
+ return result;
+ }
+ else if (sh.st == stTypedef)
+ {
+ /* Parse the type for a normal typedef. This might recursively call
+ cross_ref till we get a non typedef'ed type.
+ FIXME: This is not correct behaviour, but gdb currently
+ cannot handle typedefs without type copying. But type copying is
+ impossible as we might have mutual forward references between
+ two files and the copied type would not get filled in when
+ we later parse its definition. */
+ *tpp = parse_type (xref_fd,
+ (ecoff_data (cur_bfd)->external_aux
+ + fh->iauxBase + sh.index),
+ (int *)NULL,
+ fh->fBigendian,
+ (ecoff_data (cur_bfd)->ss
+ + fh->issBase + sh.iss));
+ }
+ else
+ {
+ /* Cross reference to a struct/union/enum which is defined
+ in another file in the same compilation unit but that file
+ has not been parsed yet.
+ Initialize the type only, it will be filled in when
+ it's definition is parsed. */
+ *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile);
}
+ add_pending (fh, esh, *tpp);
}
/* We used one auxent normally, two if we got a "next one" rf. */
if (SYMBOL_NAME (sym)[0] == inc
&& SYMBOL_NAMESPACE (sym) == namespace
&& SYMBOL_CLASS (sym) == class
- && STREQ (SYMBOL_NAME (sym), name))
+ && strcmp (SYMBOL_NAME (sym), name) == 0)
return sym;
bot++;
}
struct blockvector *bv = BLOCKVECTOR (s);
bv = (struct blockvector *) xrealloc ((PTR) bv,
- sizeof (struct blockvector) +
- BLOCKVECTOR_NBLOCKS (bv)
- * sizeof (bv->block));
+ (sizeof (struct blockvector)
+ + BLOCKVECTOR_NBLOCKS (bv)
+ * sizeof (bv->block)));
if (bv != BLOCKVECTOR (s))
BLOCKVECTOR (s) = bv;
/* Add a new linenumber entry (LINENO,ADR) to a linevector LT.
MIPS' linenumber encoding might need more than one byte
- to describe it, LAST is used to detect these continuation lines */
+ to describe it, LAST is used to detect these continuation lines.
+
+ Combining lines with the same line number seems like a bad idea.
+ E.g: There could be a line number entry with the same line number after the
+ prologue and GDB should not ignore it (this is a better way to find
+ a prologue than mips_skip_prologue).
+ But due to the compressed line table format there are line number entries
+ for the same line which are needed to bridge the gap to the next
+ line number entry. These entries have a bogus address info with them
+ and we are unable to tell them from intended duplicate line number
+ entries.
+ This is another reason why -ggdb debugging format is preferable. */
static int
add_line (lt, lineno, adr, last)
addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
if (addr_diff == 0)
- return (BLOCK_END ((*b1))) - (BLOCK_END ((*b2)));
+ return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
return addr_diff;
}
{
struct partial_symtab *psymtab;
- /* FIXME -- why (char *) -1 rather than NULL? */
- psymtab = allocate_psymtab (name == (char *) -1 ? "<no name>" : name,
- objfile);
+ psymtab = allocate_psymtab (name, objfile);
/* Keep a backpointer to the file's symbols */
psymtab->read_symtab_private = ((char *)
obstack_alloc (&objfile->psymbol_obstack,
sizeof (struct symloc)));
- CUR_HDR (psymtab) = cur_hdr;
+ memset ((PTR) psymtab->read_symtab_private, 0, sizeof (struct symloc));
+ CUR_BFD (psymtab) = cur_bfd;
/* The way to turn this into a symtab is to call... */
psymtab->read_symtab = mipscoff_psymtab_to_symtab;
{
return (struct linetable *) xrealloc ((PTR) lt,
- sizeof (struct linetable)
- + (lt->nitems - 1) * sizeof (lt->item));
+ (sizeof (struct linetable)
+ + ((lt->nitems - 1)
+ * sizeof (lt->item))));
}
/* Allocate and zero a new blockvector of NBLOCKS blocks. */
/* Just reallocate it and fix references to the old one */
- new = (struct block *) xrealloc ((PTR) b, sizeof (struct block) +
- (BLOCK_NSYMS (b) - 1) * sizeof (struct symbol *));
+ new = (struct block *) xrealloc ((PTR) b,
+ (sizeof (struct block)
+ + ((BLOCK_NSYMS (b) - 1)
+ * sizeof (struct symbol *))));
/* Should chase pointers to old one. Fortunately, that`s just
the block`s function and inferior blocks */
new_symbol (name)
char *name;
{
- struct symbol *s = (struct symbol *)
- obstack_alloc (¤t_objfile->symbol_obstack, sizeof (struct symbol));
+ struct symbol *s = ((struct symbol *)
+ obstack_alloc (¤t_objfile->symbol_obstack,
+ sizeof (struct symbol)));
memset ((PTR) s, 0, sizeof (*s));
SYMBOL_NAME (s) = name;
+ SYMBOL_LANGUAGE (s) = psymtab_language;
+ SYMBOL_INIT_DEMANGLED_NAME (s, ¤t_objfile->symbol_obstack);
return s;
}
t = alloc_type (current_objfile);
TYPE_NAME (t) = name;
- TYPE_CPLUS_SPECIFIC (t) = ((struct cplus_struct_type *)
- &cplus_struct_default);
+ TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default;
return t;
}
\f
{
struct symbol *s;
struct symtab *st;
- struct block *b, *b0;
+ struct block *b, *b0 = NULL;
sigtramp_address = -1;
- /* We know it is sold as sigvec */
+ /* We have to handle the following cases here:
+ a) The Mips library has a sigtramp label within sigvec.
+ b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
-
- /* Most programs do not play with signals */
- if (s == 0)
- s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
- else
+ if (s != 0)
{
b0 = SYMBOL_BLOCK_VALUE (s);
-
- /* A label of sigvec, to be more precise */
s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
}
+ if (s == 0)
+ {
+ /* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
+ s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
+ }
/* But maybe this program uses its own version of sigvec */
if (s == 0)
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
SYMBOL_CLASS (s) = LOC_BLOCK;
SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
- (struct objfile *) NULL);
+ st->objfile);
TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = builtin_type_void;
/* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
/* align_longword(sigcontext + SIGFRAME) */
e->pdr.frameoffset = 0x150;
e->pdr.framereg = SP_REGNUM;
- e->pdr.pcreg = 31;
+ /* read_next_frame_reg provides the true pc at the time of signal */
+ e->pdr.pcreg = PC_REGNUM;
e->pdr.regmask = -2;
e->pdr.regoffset = -(41 * sizeof (int));
e->pdr.fregmask = -1;
- e->pdr.fregoffset = -(37 * sizeof (int));
+ e->pdr.fregoffset = -(7 * sizeof (int));
e->pdr.isym = (long) s;
+ e->pdr.adr = sigtramp_address;
current_objfile = st->objfile; /* Keep new_symbol happy */
s = new_symbol (MIPS_EFI_SYMBOL_NAME);
- SYMBOL_VALUE (s) = (int) e;
+ SYMBOL_VALUE (s) = (long) e;
SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
SYMBOL_CLASS (s) = LOC_CONST;
SYMBOL_TYPE (s) = builtin_type_void;
projects / deliverable / binutils-gdb.git / blobdiff