Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

Tue Mar 3 15:11:52 1992 Michael Tiemann (tiemann@cygnus.com)

Browse Source 
* All GDB files that #include defs.h: Removed stdio.h.
	(defs.h): #include stdio.h.

This has been tested by building GDBs for all targets hosted on Sun4.
None of the build problems were related to stdio.h inclusion.  (n.b.
many configurations don't build for other reasons.)
This commit is contained in:
Michael Tiemann
1992-03-03 23:26:26 +00:00
parent af7fc06643
commit d747e0af3d
84 changed files with 995 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

365
gdb/mipsread.c
View File

@@ -1,6 +1,7 @@
/* Read a symbol table in MIPS' format (Third-Eye).
Copyright 1986, 1987, 1989, 1990, 1991 Free Software Foundation, Inc.
Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU.
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.
This file is part of GDB.
@@ -31,11 +32,26 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
file, the corresponding partial symbol table is mutated into a full
fledged symbol table by going back and reading the symbols
for real. mipscoff_psymtab_to_symtab() is called indirectly through
a pointer in the psymtab to do this. */
a pointer in the psymtab to do this.
#include <stdio.h>
ECOFF symbol tables are mostly written in the byte order of the
target machine. However, one section of the table (the auxiliary
symbol information) is written in the host byte order. There is a
bit in the other symbol info which describes which host byte order
was used. ECOFF thereby takes the trophy from Intel `b.out' for
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. */
#define TM_FILE_OVERRIDE
#include "defs.h"
#include "tm-mips.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcore.h"
#include "symfile.h"
#include "obstack.h"
@@ -46,14 +62,18 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifdef CMUCS
#include <mips/syms.h>
#else /* not CMUCS */
#include <symconst.h>
#include <sym.h>
#ifndef LANGUAGE_C
#define LANGUAGE_C
#endif
#include "symconst.h"
#include "sym.h"
#endif /* not CMUCS */
#include "coff/mips.h"
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
#include "coff/ecoff-ext.h"
struct coff_exec {
struct external_filehdr f;
@@ -121,9 +141,6 @@ struct complaint unknown_type_qual_complaint =
struct complaint array_bitsize_complaint =
{"size of array target type not known, assuming %d bits", 0, 0};
struct complaint array_parse_complaint =
{"array type with strange relative symbol", 0, 0};
struct complaint bad_tag_guess_complaint =
{"guessed tag type incorrectly", 0, 0};
@@ -190,6 +207,24 @@ struct type *builtin_type_string;
/* Forward declarations */
static void
fixup_symtab ();
static void
read_mips_symtab ();
static int
upgrade_type ();
static void
parse_partial_symbols();
static int
cross_ref();
static void
fixup_sigtramp();
static struct symbol *new_symbol();
static struct type *new_type();
static struct block *new_block();
@@ -283,9 +318,9 @@ mipscoff_symfile_read(sf, addr, mainline)
install_minimal_symbols (sf -> objfile);
}
/* Exported procedure: Allocate zeroed memory */
/* Allocate zeroed memory */
char *
static char *
xzalloc(size)
{
char *p = xmalloc(size);
@@ -353,6 +388,7 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
{
int stsize, st_hdrsize;
unsigned st_filptr;
struct hdr_ext hdr_ext;
HDRR st_hdr;
/* Header for executable/object file we read symbols from */
struct coff_exec filhdr;
@@ -360,7 +396,7 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
/* We get here with DESC pointing to the symtab header. But we need
* other info from the initial headers */
lseek(fsym, 0L, 0);
myread(fsym, &filhdr, sizeof filhdr);
myread(fsym, (char *)&filhdr, sizeof filhdr);
if (end_of_text_segp)
*end_of_text_segp =
@@ -374,10 +410,13 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
return 0;
lseek(fsym, st_filptr, L_SET);
if (st_hdrsize > sizeof (st_hdr)) /* Profanity check */
abort();
if (read(fsym, &st_hdr, st_hdrsize) != st_hdrsize)
if (st_hdrsize != sizeof (hdr_ext)) { /* Profanity check */
error ("Wrong header size: %d, not %d", st_hdrsize,
sizeof (hdr_ext));
}
if (read(fsym, &hdr_ext, st_hdrsize) != 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))
@@ -386,13 +425,13 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
/* Allocate space for the symbol table. Read it in. */
cur_hdr = (HDRR *) xmalloc(stsize + st_hdrsize);
memcpy(cur_hdr, &st_hdr, st_hdrsize);
memcpy(cur_hdr, &hdr_ext, st_hdrsize);
if (read(fsym, (char *) cur_hdr + st_hdrsize, stsize) != stsize)
goto readerr;
/* Fixup file_pointers in it */
fixup_symtab(cur_hdr, (char *) cur_hdr + st_hdrsize,
st_filptr + st_hdrsize);
st_filptr + st_hdrsize, abfd);
return;
readerr:
@@ -402,20 +441,43 @@ readerr:
/* 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. */
at DATA in memory and F_PTR in the file.
static
fixup_symtab( hdr, data, f_ptr)
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;
int f_ptr;
bfd *abfd;
{
int f_idx, s_idx;
FDR *fh;
SYMR *sh;
OPTR *op;
PDR *pr;
EXTR *esh;
/* This function depends on the external and internal forms
of the MIPS symbol table taking identical space. Check this
assumption at compile-time. */
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};
/* Swap in the header record. */
ecoff_swap_hdr_in (abfd, hdr, hdr);
/*
* These fields are useless (and empty) by now:
* hdr->cbDnOffset, hdr->cbOptOffset
@@ -440,15 +502,18 @@ fixup_symtab( hdr, data, f_ptr)
#undef FIX
/*
* Fix all string pointers inside the symtab, and
* the FDR records. Also fix other miscellany.
*/
/* 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;
@@ -459,6 +524,8 @@ fixup_symtab( hdr, data, f_ptr)
/* 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;
}
@@ -475,7 +542,7 @@ fixup_symtab( hdr, data, f_ptr)
/* Aux symbols */
if (fh->caux)
fh->iauxBase = hdr->cbAuxOffset + fh->iauxBase * sizeof(AUXU);
fh->iauxBase = hdr->cbAuxOffset + fh->iauxBase * sizeof(union aux_ext);
/* Relative file descriptor table */
fh->rfdBase = hdr->cbRfdOffset + fh->rfdBase * sizeof(RFDT);
@@ -489,6 +556,7 @@ fixup_symtab( hdr, data, f_ptr)
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;
@@ -521,9 +589,10 @@ fixup_symtab( hdr, data, f_ptr)
}
}
/* External symbols: fix string */
/* 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;
}
}
@@ -563,7 +632,7 @@ fdr_name(name)
whether we are adding to the general symtab or not.
FIXME: INCREMENTAL is currently always zero, though it should not be. */
static
static void
read_mips_symtab (objfile, desc)
struct objfile *objfile;
int desc;
@@ -806,7 +875,7 @@ prepend_tag_kind(tag_name, type_code)
prefix = "";
}
result = (char*)obstack_alloc (symbol_obstack,
result = (char*)obstack_alloc (&current_objfile->symbol_obstack,
strlen(prefix) + strlen(tag_name) + 1);
sprintf(result, "%s%s", prefix, tag_name);
return result;
@@ -818,12 +887,15 @@ prepend_tag_kind(tag_name, type_code)
/* 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). */
static int
parse_symbol(sh, ax)
parse_symbol(sh, ax, bigend)
SYMR *sh;
AUXU *ax;
union aux_ext *ax;
int bigend;
{
char *name;
struct symbol *s;
@@ -835,6 +907,7 @@ parse_symbol(sh, ax)
we mark it explicitly */
int pend = (sh->reserved == 1);
enum address_class class;
TIR tir;
switch (sh->st) {
@@ -877,7 +950,7 @@ data: /* Common code for symbols describing data */
sh->index == 0xfffff)
SYMBOL_TYPE(s) = builtin_type_int; /* undefined? */
else
SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0);
SYMBOL_TYPE(s) = parse_type(ax + sh->index, 0, bigend);
/* Value of a data symbol is its memory address */
break;
@@ -899,7 +972,7 @@ data: /* Common code for symbols describing data */
} else
SYMBOL_CLASS(s) = LOC_ARG;
SYMBOL_VALUE(s) = sh->value;
SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0);
SYMBOL_TYPE(s) = parse_type(ax + sh->index, 0, bigend);
add_symbol(s, top_stack->cur_block);
#if 0
/* FIXME: This has not been tested. See dbxread.c */
@@ -927,7 +1000,7 @@ data: /* Common code for symbols describing data */
if (sh->sc == scUndefined || sh->sc == scNil)
t = builtin_type_int;
else
t = parse_type(ax + sh->index, sh, 0);
t = parse_type(ax + sh->index + 1, 0, bigend);
b = top_stack->cur_block;
if (sh->st == stProc) {
struct blockvector *bv = BLOCKVECTOR(top_stack->cur_st);
@@ -1017,10 +1090,15 @@ data: /* Common code for symbols describing data */
if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
/* If the type of the member is Nil (or Void)
assume the tag is an enumeration. */
if (tsym->index == indexNil
|| ax[tsym->index].ti.bt == btNil
|| ax[tsym->index].ti.bt == btVoid)
if (tsym->index == indexNil)
type_code = TYPE_CODE_ENUM;
else {
ecoff_swap_tir_in (bigend,
&ax[tsym->index].a_ti,
&tir);
if (tir.bt == btNil || tir.bt == btVoid)
type_code = TYPE_CODE_ENUM;
}
nfields++;
if (tsym->value > max_value)
max_value = tsym->value;
@@ -1033,7 +1111,6 @@ data: /* Common code for symbols describing data */
+ tsym->index-1;
}
/* There is no guaranteed way to distinguish struct,
unions, and enums at this point. This is a bug in the
original design (that has been fixed with the
@@ -1097,7 +1174,7 @@ data: /* Common code for symbols describing data */
f->bitsize = 0;
enum_sym = (struct symbol *)
obstack_alloc (&objfile->symbol_obstack,
obstack_alloc (&current_objfile->symbol_obstack,
sizeof (struct symbol));
memset (enum_sym, 0, sizeof (struct symbol));
SYMBOL_NAME (enum_sym) = f->name;
@@ -1172,7 +1249,7 @@ data: /* Common code for symbols describing data */
f->name = (char*)sh->iss;
f->bitpos = sh->value;
f->bitsize = 0;
f->type = parse_type(ax + sh->index, sh, &f->bitsize);
f->type = parse_type(ax + sh->index, &f->bitsize, bigend);
break;
case stTypedef: /* type definition */
@@ -1181,7 +1258,7 @@ data: /* Common code for symbols describing data */
SYMBOL_CLASS(s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE(s) = top_stack->cur_block;
add_symbol(s, top_stack->cur_block);
SYMBOL_TYPE(s) = parse_type(ax + sh->index, sh, 0);
SYMBOL_TYPE(s) = parse_type(ax + sh->index, 0, bigend);
sh->value = (long) SYMBOL_TYPE(s);
break;
@@ -1204,13 +1281,15 @@ data: /* Common code for symbols describing data */
return count;
}
/* Parse the type information provided in the AX entries for
the symbol SH. Return the bitfield size in BS, in case. */
/* Parse the type information provided in the raw AX entries for
the symbol SH. Return the bitfield size in BS, in case.
We must byte-swap the AX entries before we use them; BIGEND says whether
they are big-endian or little-endian (from fh->fBigendian). */
static struct type *parse_type(ax, sh, bs)
AUXU *ax;
SYMR *sh;
static struct type *parse_type(ax, bs, bigend)
union aux_ext *ax;
int *bs;
int bigend;
{
/* Null entries in this map are treated specially */
static struct type **map_bt[] =
@@ -1244,23 +1323,16 @@ static struct type *parse_type(ax, sh, bs)
&builtin_type_void, /* btVoid */
};
TIR *t;
TIR t[1];
struct type *tp = 0;
char *fmt;
int i;
union aux_ext *tax;
int type_code;
/* Procedures start off by one */
if (sh->st == stProc || sh->st == stStaticProc)
ax++;
/* Undefined ? Should not happen */
if (ax->rndx.rfd == 0xfff) {
return builtin_type_void;
}
/* Use aux as a type information record, map its basic type */
t = &ax->ti;
/* 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))) {
complain (&basic_type_complaint, t->bt);
return builtin_type_int;
@@ -1303,17 +1375,21 @@ static struct type *parse_type(ax, sh, bs)
}
}
/* Move on to next aux */
ax++;
/* Skip over any further type qualifiers (FIXME). */
if (t->continued) {
/* This is the way it would work if the compiler worked */
register TIR *t1 = t;
while (t1->continued)
TIR t1[1];
do {
ax++;
ecoff_swap_tir_in (bigend, ax, t1);
} while (t1->continued);
}
/* Move on to next aux */
ax++;
if (t->fBitfield) {
*bs = ax->width;
*bs = AUX_GET_WIDTH (bigend, ax);
ax++;
}
@@ -1330,7 +1406,7 @@ static struct type *parse_type(ax, sh, bs)
char name[256], *pn;
/* Try to cross reference this type */
ax += cross_ref(ax, &tp, type_code, &pn);
ax += cross_ref(ax, &tp, type_code, &pn, bigend);
/* reading .o file ? */
if (UNSAFE_DATA_ADDR(tp))
tp = init_type(type_code, 0, 0, 0, (struct objfile *) NULL);
@@ -1358,11 +1434,11 @@ static struct type *parse_type(ax, sh, bs)
2 * sizeof (struct field));
TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
&current_objfile -> type_obstack);
TYPE_FIELD_BITPOS (tp, 0) = ax->dnLow;
TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
ax++;
TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
&current_objfile -> type_obstack);
TYPE_FIELD_BITPOS (tp, 1) = ax->dnHigh;
TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
ax++;
}
@@ -1370,7 +1446,7 @@ static struct type *parse_type(ax, sh, bs)
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, sh);
if (t->tq != tqNil) ax += upgrade_type(&tp, t->tq, ax, bigend);
again: PARSE_TQ(tq0);
PARSE_TQ(tq1);
@@ -1381,7 +1457,8 @@ again: PARSE_TQ(tq0);
#undef PARSE_TQ
if (t->continued) {
t++;
tax++;
ecoff_swap_tir_in (bigend, &tax->a_ti, t);
goto again;
}
return tp;
@@ -1390,24 +1467,25 @@ again: PARSE_TQ(tq0);
/* Make up a complex type from a basic one. Type is passed by
reference in TPP and side-effected as necessary. The type
qualifier TQ says how to handle the aux symbols at AX for
the symbol SX we are currently analyzing.
the symbol SX we are currently analyzing. BIGEND says whether
aux symbols are big-endian or little-endian.
Returns the number of aux symbols we parsed. */
static int
upgrade_type(tpp, tq, ax, sh)
struct type **tpp;
AUXU *ax;
SYMR *sh;
upgrade_type(tpp, tq, ax, bigend)
struct type **tpp;
union aux_ext *ax;
int bigend;
{
int off;
struct type *t;
int off;
struct type *t;
/* Used in array processing */
int rf, id;
FDR *fh;
struct field *f;
SYMR ss;
int lower, upper;
RNDXR rndx;
switch (tq) {
case tqPtr:
@@ -1426,10 +1504,12 @@ upgrade_type(tpp, tq, ax, sh)
TYPE_TARGET_TYPE(t) = *tpp;
/* Determine and record the domain type (type of index) */
id = ax->rndx.index;
rf = ax->rndx.rfd;
ecoff_swap_rndx_in (bigend, ax, &rndx);
id = rndx.index;
rf = rndx.rfd;
if (rf == 0xfff) {
rf = (++ax)->isym;
ax++;
rf = AUX_GET_ISYM (bigend, ax);
off++;
}
fh = get_rfd(cur_fd, rf);
@@ -1438,7 +1518,7 @@ upgrade_type(tpp, tq, ax, sh)
/* FIXME - Memory leak! */
if (TYPE_NFIELDS(t))
TYPE_FIELDS(t) = (struct field*)
xrealloc(TYPE_FIELDS(t),
xrealloc((char *) TYPE_FIELDS(t),
(TYPE_NFIELDS(t)+1) * sizeof(struct field));
else
TYPE_FIELDS(t) = (struct field*)
@@ -1447,28 +1527,15 @@ upgrade_type(tpp, tq, ax, sh)
TYPE_NFIELDS(t)++;
memset(f, 0, sizeof(struct field));
memset(&ss, 0, sizeof ss);
/* XXX */ f->type = parse_type(fh->iauxBase + id * sizeof(AUXU),
&ss, &f->bitsize);
/* XXX */ f->type = parse_type(fh->iauxBase + id * sizeof(union aux_ext),
&f->bitsize, bigend);
if (off == 0) {
/*
* This seems to be a pointer to the end of the Block defining
* the type. Why it is here is magic for me, and I have no
* good use for it anyways.
*/
/* This used to occur because cross_ref returned
the wrong result (ax pointed wrong). FIXME,
delete this code in a while. -- gnu@cygnus jul91 */
complain (&array_parse_complaint, 0);
off++;
id = (++ax)->rndx.index;
if ((rf = ax->rndx.rfd) == 0xfff)
rf = (++ax)->isym, off++;
}
lower = (++ax)->dnLow;
upper = (++ax)->dnHigh;
rf = (++ax)->width; /* bit size of array element */
ax++;
lower = AUX_GET_DNLOW (bigend, ax);
ax++;
upper = AUX_GET_DNHIGH (bigend, ax);
ax++;
rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
/* Check whether supplied array element bit size matches
the known size of the element type. If this complaint
@@ -1568,19 +1635,22 @@ parse_procedure(pr, bound)
parsing of the PDRs has already provided all the needed
information, we only parse them if SKIP_PROCEDURES is false,
and only if this causes no symbol duplication.
BIGEND says whether aux entries are big-endian or little-endian.
This routine clobbers top_stack->cur_block and ->cur_st. */
static
parse_external(es, skip_procedures)
parse_external(es, skip_procedures, bigend)
EXTR *es;
int skip_procedures;
int bigend;
{
AUXU *ax;
union aux_ext *ax;
if (es->ifd != ifdNil) {
cur_fd = es->ifd;
cur_fdr = (FDR*)(cur_hdr->cbFdOffset) + cur_fd;
ax = (AUXU*)cur_fdr->iauxBase;
ax = (union aux_ext *)cur_fdr->iauxBase;
} else {
cur_fdr = (FDR*)(cur_hdr->cbFdOffset);
ax = 0;
@@ -1621,7 +1691,7 @@ parse_external(es, skip_procedures)
* Note that the case of a symbol with indexNil
* must be handled anyways by parse_symbol().
*/
parse_symbol(&es->asym, ax);
parse_symbol(&es->asym, ax, bigend);
break;
default:
break;
@@ -1702,7 +1772,7 @@ parse_lines(fh, lt)
END_OF_TEXT_SEG gives the address just after the text segment for
the symtab we are reading. */
static
static void
parse_partial_symbols(end_of_text_seg, objfile)
int end_of_text_seg;
struct objfile *objfile;
@@ -1730,7 +1800,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
int dependencies_used, dependencies_allocated;
struct cleanup *old_chain;
extern_tab = (EXTR**)obstack_alloc (psymbol_obstack,
extern_tab = (EXTR**)obstack_alloc (&objfile->psymbol_obstack,
sizeof(EXTR *) * hdr->iextMax);
includes_allocated = 30;
@@ -1826,10 +1896,10 @@ parse_partial_symbols(end_of_text_seg, objfile)
}
pst = start_psymtab_common (objfile, 0, (char*)fh->rss,
fh->cpd ? fh->adr : 0,
global_psymbols.next,
static_psymbols.next);
objfile->global_psymbols.next,
objfile->static_psymbols.next);
pst->read_symtab_private = (char *)
obstack_alloc (psymbol_obstack, sizeof (struct symloc));
obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
save_pst = pst;
/* Make everything point to everything. */
@@ -1859,7 +1929,8 @@ parse_partial_symbols(end_of_text_seg, objfile)
(It is the second symbol because the first symbol is
the stFile used to signal the start of a file). */
if (fh->csym >= 2
&& strcmp(((SYMR *)fh->isymBase)[1].iss, stabs_symbol) == 0) {
&& strcmp((char *)(((SYMR *)fh->isymBase)[1].iss),
stabs_symbol) == 0) {
for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++) {
int type_code;
char *namestring;
@@ -1868,7 +1939,8 @@ parse_partial_symbols(end_of_text_seg, objfile)
if (!MIPS_IS_STAB(sh)) {
if (sh->st == stProc || sh->st == stStaticProc) {
long procaddr = sh->value;
sh = (sh->index + (AUXU *)fh->iauxBase)->isym
sh = AUX_GET_ISYM (fh->fBigendian,
sh->index + (union aux_ext *)(fh->iauxBase))
+ (SYMR *) fh->isymBase - 1;
if (sh->st == stEnd) {
long high = procaddr + sh->value;
@@ -1920,9 +1992,10 @@ parse_partial_symbols(end_of_text_seg, objfile)
case stStaticProc: /* Function */
ADD_PSYMBOL_TO_LIST(name, strlen(name),
VAR_NAMESPACE, LOC_BLOCK,
static_psymbols, sh->value);
objfile->static_psymbols, sh->value);
/* Skip over procedure to next one. */
cur_sdx = (sh->index + (AUXU *)fh->iauxBase)->isym;
cur_sdx = AUX_GET_ISYM (fh->fBigendian,
sh->index + (union aux_ext *)fh->iauxBase);
procaddr = sh->value;
sh = cur_sdx + (SYMR *) fh->isymBase - 1;
@@ -1945,7 +2018,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
if (sh->sc == scInfo) {
ADD_PSYMBOL_TO_LIST(name, strlen(name),
STRUCT_NAMESPACE, LOC_TYPEDEF,
static_psymbols, sh->value);
objfile->static_psymbols, sh->value);
}
/* Skip over the block */
cur_sdx = sh->index;
@@ -1963,7 +2036,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
/* Use this gdb symbol */
ADD_PSYMBOL_TO_LIST(name, strlen(name),
VAR_NAMESPACE, class,
static_psymbols, sh->value);
objfile->static_psymbols, sh->value);
skip:
cur_sdx++; /* Go to next file symbol */
}
@@ -1991,10 +2064,10 @@ parse_partial_symbols(end_of_text_seg, objfile)
class = LOC_STATIC;
break;
}
if (global_psymbols.next >=
global_psymbols.list + global_psymbols.size)
extend_psymbol_list (&global_psymbols, objfile);
psym = global_psymbols.next++;
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;
@@ -2004,8 +2077,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
end_psymtab (save_pst, psymtab_include_list, includes_used,
-1, save_pst->texthigh,
dependency_list, dependencies_used,
global_psymbols.next, static_psymbols.next);
dependency_list, dependencies_used);
if (entry_point < save_pst->texthigh
&& entry_point >= save_pst->textlow) {
startup_file_start = save_pst->textlow;
@@ -2038,7 +2110,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
}
pst->number_of_dependencies = fh->crfd - s_id0;
pst->dependencies = (struct partial_symtab **)
obstack_alloc (psymbol_obstack,
obstack_alloc (&objfile->psymbol_obstack,
pst->number_of_dependencies *
sizeof (struct partial_symtab *));
for (s_idx = s_id0; s_idx < fh->crfd; s_idx++) {
@@ -2168,7 +2240,8 @@ psymtab_to_symtab_1(pst, filename)
/* See comment in parse_partial_symbols about the @stabs sentinel. */
have_stabs =
fh && fh->csym >= 2
&& strcmp(((SYMR *)fh->isymBase)[1].iss, stabs_symbol) == 0;
&& strcmp((char *)(((SYMR *)fh->isymBase)[1].iss), stabs_symbol)
== 0;
if (!have_stabs) {
if (fh)
@@ -2268,7 +2341,7 @@ psymtab_to_symtab_1(pst, filename)
: fh[1].adr;
for (cur_sdx = 0; cur_sdx < fh->csym; ) {
sh = (SYMR *) (fh->isymBase) + cur_sdx;
cur_sdx += parse_symbol(sh, fh->iauxBase);
cur_sdx += parse_symbol(sh, fh->iauxBase, fh->fBigendian);
}
/* Procedures next, note we need to look-ahead to
@@ -2303,7 +2376,7 @@ psymtab_to_symtab_1(pst, filename)
ext_ptr = PST_PRIVATE(pst)->extern_tab;
for (i = PST_PRIVATE(pst)->extern_count; --i >= 0; ext_ptr++)
parse_external(*ext_ptr, 1);
parse_external(*ext_ptr, 1, fh->fBigendian);
/* If there are undefined, tell the user */
if (n_undef_symbols) {
@@ -2332,22 +2405,30 @@ psymtab_to_symtab_1(pst, filename)
/* Lookup the type at relative index RN. Return it in TPP
if found and in any event come up with its name PNAME.
Return value says how many aux symbols we ate */
BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian).
Return value says how many aux symbols we ate. */
static
cross_ref(rn, tpp, type_code, pname)
RNDXR *rn;
static int
cross_ref(ax, tpp, type_code, pname, bigend)
union aux_ext *ax;
struct type **tpp;
int type_code; /* Use to alloc new type if none is found. */
char **pname;
int bigend;
{
RNDXR rn[1];
unsigned rf;
int result = 1;
ecoff_swap_rndx_in (bigend, ax, rn);
/* Escape index means 'the next one' */
if (rn->rfd == 0xfff)
rf = *(unsigned *) (rn + 1);
else
if (rn->rfd == 0xfff) {
result++;
rf = AUX_GET_ISYM (bigend, ax + 1);
} else {
rf = rn->rfd;
}
if (rf == -1) {
/* Ooops */
@@ -2391,7 +2472,7 @@ cross_ref(rn, tpp, type_code, pname)
}
/* We used one auxent normally, two if we got a "next one" rf. */
return (rn->rfd == 0xfff? 2: 1);
return result;
}
@@ -2470,8 +2551,10 @@ add_block(b,s)
{
struct blockvector *bv = BLOCKVECTOR(s);
bv = (struct blockvector *)xrealloc(bv, sizeof(struct blockvector) +
BLOCKVECTOR_NBLOCKS(bv) * sizeof(bv->block));
bv = (struct blockvector *)xrealloc((char *) bv,
sizeof(struct blockvector) +
BLOCKVECTOR_NBLOCKS(bv)
* sizeof(bv->block));
if (bv != BLOCKVECTOR(s))
BLOCKVECTOR(s) = bv;
@@ -2614,6 +2697,9 @@ static
struct symtab *
new_symtab(name, maxsyms, maxlines, objfile)
char *name;
int maxsyms;
int maxlines;
struct objfile *objfile;
{
struct symtab *s = allocate_symtab (name, objfile);
@@ -2749,7 +2835,7 @@ new_symbol(name)
char *name;
{
struct symbol *s = (struct symbol *)
obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
obstack_alloc (&current_objfile->symbol_obstack, sizeof (struct symbol));
memset (s, 0, sizeof (*s));
SYMBOL_NAME(s) = name;
@@ -2767,7 +2853,8 @@ new_type(name)
t = alloc_type (current_objfile);
TYPE_NAME(t) = name;
TYPE_CPLUS_SPECIFIC(t) = &cplus_struct_default;
TYPE_CPLUS_SPECIFIC(t) = (struct cplus_struct_type *)
&cplus_struct_default;
return t;
}
@@ -2782,7 +2869,7 @@ new_type(name)
from MIPS does not do so, we make up that information ourselves.
If they fix the library (unlikely) this code will neutralize itself. */
static
static void
fixup_sigtramp()
{
struct symbol *s;