diff options
Diffstat (limited to 'gdb/mipsread.c')
| -rw-r--r-- | gdb/mipsread.c | 1237 |
1 files changed, 579 insertions, 658 deletions
diff --git a/gdb/mipsread.c b/gdb/mipsread.c index f77ec4a..b98c9cb 100644 --- a/gdb/mipsread.c +++ b/gdb/mipsread.c @@ -39,6 +39,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "gdbcore.h" #include "symfile.h" #include "obstack.h" +#include "buildsym.h" #include <sys/param.h> #include <sys/file.h> #include <sys/stat.h> @@ -50,12 +51,22 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #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 */ struct coff_exec { struct external_filehdr f; struct external_aouthdr a; }; +/* These must match the corresponding definition in mips-tfile.c. */ + +#define CODE_MASK 0x8F300 +#define MIPS_IS_STAB(sym) (((sym)->index & 0xFFF00) == CODE_MASK) +#define MIPS_MARK_STAB(code) ((code)+CODE_MASK) +#define MIPS_UNMARK_STAB(code) ((code)-CODE_MASK) + /* 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. @@ -153,6 +164,10 @@ static max_glevel; static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs; +/* Pseudo symbol to use when putting stabs into the symbol table. */ + +static char stabs_symbol[] = "@stabs"; + /* Extra builtin types */ struct type *builtin_type_complex; @@ -165,7 +180,6 @@ struct type *builtin_type_string; static struct symbol *new_symbol(); static struct type *new_type(); -static struct field *new_field(); static struct block *new_block(); static struct symtab *new_symtab(); static struct linetable *new_linetable(); @@ -173,9 +187,9 @@ static struct blockvector *new_bvect(); static struct type *parse_type(); static struct type *make_type(); -static struct type *make_struct_type(); static struct symbol *mylookup_symbol(); static struct block *shrink_block(); +static void sort_blocks(); static int compare_symtabs(); static int compare_psymtabs(); @@ -189,9 +203,7 @@ static void psymtab_to_symtab_1(); static void add_block(); static void add_symbol(); static int add_line(); -static void reorder_symtabs(); -static void reorder_psymtabs(); -static void shrink_linetable(); +static struct linetable *shrink_linetable(); /* Things we export to other modules */ @@ -264,7 +276,7 @@ xzalloc(size) { char *p = xmalloc(size); - bzero(p, size); + memset(p, 0, size); return p; } @@ -292,7 +304,9 @@ mipscoff_psymtab_to_symtab(pst) psymtab_to_symtab_1(pst, pst->filename); - reorder_symtabs(); + /* Match with global symbols. This only needs to be done once, + after all of the symtabs and dependencies have been read in. */ + scan_file_globals (); if (info_verbose) printf_filtered("done.\n"); @@ -356,7 +370,7 @@ 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); - bcopy(&st_hdr, cur_hdr, st_hdrsize); + memcpy(cur_hdr, &st_hdr, st_hdrsize); if (read(fsym, (char *) cur_hdr + st_hdrsize, stsize) != stsize) goto readerr; @@ -422,17 +436,19 @@ fixup_symtab( hdr, data, f_ptr) 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*)(hdr->cbSymOffset) + fh->isymBase + s_idx; + sh = (SYMR*)fh->isymBase + s_idx; sh->iss = (long) sh->iss + fh->issBase; sh->reserved = 0; } cur_fd = f_idx; - /* Local symbols */ - fh->isymBase = (int)((SYMR*)(hdr->cbSymOffset)+fh->isymBase); - /* cannot fix fh->ipdFirst because it is a short */ #define IPDFIRST(h,fh) \ ((long)h->cbPdOffset + fh->ipdFirst * sizeof(PDR)) @@ -542,6 +558,7 @@ read_mips_symtab (objfile, desc) parse_partial_symbols(end_of_text_seg, objfile); +#if 0 /* * Check to make sure file was compiled with -g. * If not, warn the user of this limitation. @@ -555,6 +572,7 @@ read_mips_symtab (objfile, desc) "You should compile with -g2 or -g3 for best debugging support.\n"); fflush(stdout); } +#endif } /* Local utilities */ @@ -563,8 +581,6 @@ read_mips_symtab (objfile, desc) static struct pst_map { struct partial_symtab *pst; /* the psymtab proper */ - int n_globals; /* globals it exports */ - int n_statics; /* statics (locals) it contains */ } * fdr_to_pst; @@ -574,14 +590,15 @@ static struct pst_map { after use. */ static struct parse_stack { - struct parse_stack *next, *prev; - struct symtab *cur_st; /* Current symtab */ - struct block *cur_block; /* Block in it */ - int blocktype; /* What are we parsing */ - int maxsyms; /* Max symbols in this block */ - struct type *cur_type; /* Type we parse fields for */ - int procadr; /* Start addres of this procedure */ - int numargs; /* Its argument count */ + struct parse_stack *next, *prev; + struct symtab *cur_st; /* Current symtab. */ + struct block *cur_block; /* Block in it. */ + int blocktype; /* What are we parsing. */ + 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 */ + int numargs; /* Its argument count */ } *top_stack; /* Top stack ptr */ @@ -624,8 +641,8 @@ static pop_parse_stack() duplications we keep a quick fixup table, an array of lists of references indexed by file descriptor */ -static struct pending { - struct pending *next; /* link */ +static struct mips_pending { + struct mips_pending *next; /* link */ SYMR *s; /* the symbol */ struct type *t; /* its partial type descriptor */ } **pending_list; @@ -634,12 +651,12 @@ static struct pending { /* Check whether we already saw symbol SH in file FH as undefined */ static -struct pending *is_pending_symbol(fh, sh) +struct mips_pending *is_pending_symbol(fh, sh) FDR *fh; SYMR *sh; { int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; - register struct pending *p; + register struct mips_pending *p; /* Linear search is ok, list is typically no more than 10 deep */ for (p = pending_list[f_idx]; p; p = p->next) @@ -651,12 +668,12 @@ struct pending *is_pending_symbol(fh, sh) /* Check whether we already saw type T in file FH as undefined */ static -struct pending *is_pending_type(fh, t) +struct mips_pending *is_pending_type(fh, t) FDR *fh; struct type *t; { int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; - register struct pending *p; + register struct mips_pending *p; for (p = pending_list[f_idx]; p; p = p->next) if (p->t == t) @@ -673,11 +690,11 @@ add_pending(fh, sh, t) struct type *t; { int f_idx = fh - (FDR *) cur_hdr->cbFdOffset; - struct pending *p = is_pending_symbol(fh, sh); + struct mips_pending *p = is_pending_symbol(fh, sh); /* Make sure we do not make duplicates */ if (!p) { - p = (struct pending *) xmalloc(sizeof(*p)); + p = (struct mips_pending *) xmalloc(sizeof(*p)); p->s = sh; p->t = t; p->next = pending_list[f_idx]; @@ -691,7 +708,7 @@ add_pending(fh, sh, t) static free_pending(f_idx) { - register struct pending *p, *q; + register struct mips_pending *p, *q; for (p = pending_list[f_idx]; p; p = q) { q = p->next; @@ -755,17 +772,20 @@ free_numargs() /* 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 */ + This is basically just a big switch on the symbol's type. + Return count of SYMR's handled (normally one). */ -static void +static int parse_symbol(sh, ax) SYMR *sh; AUXU *ax; { + char *name; struct symbol *s; struct block *b; 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); @@ -819,7 +839,13 @@ data: /* Common code for symbols describing data */ case stParam: /* arg to procedure, goes into current block */ max_gdbinfo++; top_stack->numargs++; - s = new_symbol(sh->iss); + + name = (char*)sh->iss; + /* Special GNU C++ name. */ + if (name[0] == CPLUS_MARKER && name[1] == 't' && name[2] == 0) + name = "this"; + s = new_symbol(name); + SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; if (sh->sc == scRegister) { SYMBOL_CLASS(s) = LOC_REGPARM; @@ -895,6 +921,7 @@ data: /* Common code for symbols describing data */ top_stack->cur_block = b; top_stack->blocktype = sh->st; top_stack->cur_type = SYMBOL_TYPE(s); + top_stack->cur_field = -1; top_stack->procadr = sh->value; top_stack->numargs = 0; @@ -905,26 +932,91 @@ data: /* Common code for symbols describing data */ push_parse_stack(); top_stack->blocktype = stBlock; if (sh->sc == scInfo) { /* structure/union/enum def */ - s = new_symbol(sh->iss); - SYMBOL_NAMESPACE(s) = STRUCT_NAMESPACE; - SYMBOL_CLASS(s) = LOC_TYPEDEF; - SYMBOL_VALUE(s) = 0; - add_symbol(s, top_stack->cur_block); - /* If this type was expected, use its partial definition */ - if (pend) { - t = is_pending_symbol(cur_fdr, sh)->t; - } else { - /* Uhmm, can`t decide yet. Smash later */ - t = new_type(sh->iss); - TYPE_CODE(t) = TYPE_CODE_UNDEF; - add_pending(cur_fdr, sh, t); + int type_code = TYPE_CODE_UNDEF; + + s = new_symbol(sh->iss); + SYMBOL_NAMESPACE(s) = STRUCT_NAMESPACE; + SYMBOL_CLASS(s) = LOC_TYPEDEF; + SYMBOL_VALUE(s) = 0; + add_symbol(s, top_stack->cur_block); + /* If this type was expected, use its partial definition */ + if (pend) { + t = is_pending_symbol(cur_fdr, sh)->t; + } else { + int nfields = 0; + SYMR *tsym; + long max_value = 0; + struct field *f; + + /* First count the number of fields. */ + for (tsym = sh+1; tsym->st != stEnd; tsym++) + if (tsym->st == stMember) { + if (nfields == 0) + if (tsym->index == indexNil + || ax[tsym->index].ti.bt==26)/*btVoid*/ + type_code = TYPE_CODE_ENUM; + nfields++; + if (tsym->value > max_value) + max_value = tsym->value; + } + else if (tsym->st == stBlock + || tsym->st == stParsed) { + if (tsym->sc == scVariant) ; /*UNIMPLEMENTED*/ + if (tsym->index != 0) + tsym = ((SYMR*)cur_fdr->isymBase) + + tsym->index-1; + } + + t = new_type(sh->iss); + + /* Guess the type code. */ + if (type_code == TYPE_CODE_UNDEF) + if (max_value == 0) type_code = TYPE_CODE_UNION; + else type_code = TYPE_CODE_STRUCT; + + TYPE_CODE(t) = type_code; + TYPE_NFIELDS(t) = nfields; + TYPE_FIELDS(t) = f = (struct field*) + obstack_alloc (symbol_obstack, + nfields * sizeof (struct field)); + + if (type_code == TYPE_CODE_ENUM) { + /* This is a non-empty enum. */ + while (sh[1].st == stMember) { + struct symbol *enum_sym; + sh++; + f->bitpos = sh->value; + f->type = t; + f->name = (char*)sh->iss; + f->bitsize = 0; + + enum_sym = (struct symbol *) + obstack_alloc (symbol_obstack, + sizeof (struct symbol)); + memset (enum_sym, 0, sizeof (struct symbol)); + SYMBOL_NAME (enum_sym) = f->name; + SYMBOL_CLASS (enum_sym) = LOC_CONST; + SYMBOL_TYPE (enum_sym) = t; + SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE; + SYMBOL_VALUE (enum_sym) = sh->value; + add_symbol(enum_sym, top_stack->cur_block); + + count++; + f++; + } } - SYMBOL_TYPE(s) = t; - /* make this the current type */ - top_stack->cur_type = t; - TYPE_LENGTH(t) = sh->value; - /* Mark that symbol has a type, and say which one */ - sh->value = (long) t; + else { + /* Uhmm, can`t decide yet. Guess. */ + add_pending(cur_fdr, sh, t); + } + } + SYMBOL_TYPE(s) = t; + /* make this the current type */ + top_stack->cur_type = t; + top_stack->cur_field = 0; + TYPE_LENGTH(t) = sh->value; + /* Mark that symbol has a type, and say which one */ + sh->value = (long) t; } else { /* beginnning of (code) block. Value of symbol is the displacement from procedure start */ @@ -979,9 +1071,11 @@ data: /* Common code for symbols describing data */ pop_parse_stack(); /* restore previous lexical context */ break; - case stMember: /* member of struct/union/enum.. */ - f = new_field(top_stack->cur_type, sh->iss); + case stMember: /* member of struct or union */ + f = &TYPE_FIELDS(top_stack->cur_type)[top_stack->cur_field++]; + f->name = (char*)sh->iss; f->bitpos = sh->value; + f->bitsize = 0; f->type = parse_type(ax + sh->index, sh, &f->bitsize); break; @@ -1011,6 +1105,7 @@ data: /* Common code for symbols describing data */ error("Unknown symbol type %x.", sh->st); } sh->st = stParsed; + return count; } /* Parse the type information provided in the AX entries for @@ -1054,9 +1149,10 @@ static struct type *parse_type(ax, sh, bs) }; TIR *t; - struct type *tp = 0, *tp1; + struct type *tp = 0; char *fmt; int i; + int type_code; /* Procedures start off by one */ if (sh->st == stProc || sh->st == stStaticProc) @@ -1077,6 +1173,7 @@ static struct type *parse_type(ax, sh, bs) tp = *map_bt[t->bt]; fmt = "%s"; } else { + tp = NULL; /* Cannot use builtin types -- build our own */ switch (t->bt) { case btAdr: @@ -1084,25 +1181,26 @@ static struct type *parse_type(ax, sh, bs) fmt = "%s"; break; case btStruct: - tp = make_struct_type(TYPE_CODE_STRUCT, 0, 0, 0); + type_code = TYPE_CODE_STRUCT; fmt = "struct %s"; break; case btUnion: - tp = make_struct_type(TYPE_CODE_UNION, 0, 0, 0); + type_code = TYPE_CODE_UNION; fmt = "union %s"; break; case btEnum: - tp = make_type(TYPE_CODE_ENUM, 0, 0, 0); + type_code = TYPE_CODE_ENUM; fmt = "enum %s"; break; case btRange: - tp = make_type(TYPE_CODE_RANGE, 0, 0, 0); + type_code = TYPE_CODE_RANGE; fmt = "%s"; break; case btSet: - tp = make_type(TYPE_CODE_SET, 0, 0, 0); + type_code = TYPE_CODE_SET; fmt = "set %s"; break; + case btTypedef: default: complain (&basic_type_complaint, t->bt); return builtin_type_int; @@ -1118,15 +1216,14 @@ static struct type *parse_type(ax, sh, bs) ax++; } - /* For bitfields all we need is the width */ if (t->fBitfield) { *bs = ax->width; - return tp; + 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 */ + them. We'll make the same effort at sharing. */ if (t->bt == btIndirect || t->bt == btStruct || t->bt == btUnion || @@ -1137,54 +1234,32 @@ static struct type *parse_type(ax, sh, bs) char name[256], *pn; /* Try to cross reference this type */ - tp1 = tp; - ax += cross_ref(ax, &tp1, &pn); + ax += cross_ref(ax, &tp, type_code, &pn); + /* reading .o file ? */ + if (UNSAFE_DATA_ADDR(tp)) + tp = make_type(type_code, 0, 0, 0); /* SOMEONE OUGHT TO FIX DBXREAD TO DROP "STRUCT" */ sprintf(name, fmt, pn); - /* reading .o file ? */ - if (UNSAFE_DATA_ADDR(tp1)) - tp1 = tp; - if (TYPE_CODE(tp1) == TYPE_CODE_UNDEF) { - /* - * Type was incompletely defined, now we know. - */ - TYPE_CODE(tp1) = TYPE_CODE(tp); - TYPE_NAME(tp1) = obsavestring(name, strlen(name)); - TYPE_TYPE_SPECIFIC(tp1) = TYPE_TYPE_SPECIFIC(tp); - - /* Now do cleanup based on the final type. */ - switch (TYPE_CODE (tp1)) { - case TYPE_CODE_ENUM: - for (i = 0; i < TYPE_NFIELDS(tp1); i++) - make_enum_constant(&TYPE_FIELD(tp1,i), - tp1); - break; - } - } - if (tp1 != tp) { - /* found as cross ref, rid of our template */ - if ((TYPE_FLAGS(tp) & TYPE_FLAG_PERM) == 0) - free(tp); - tp = tp1; - /* stupid idea of prepending "struct" to type names */ - if (t->bt == btStruct && !index(TYPE_NAME(tp), ' ')) { - sprintf(name, fmt, TYPE_NAME(tp)); - TYPE_NAME(tp) = obsavestring(name, strlen(name)); - } - } else - TYPE_NAME(tp) = savestring(name, strlen(name)); + /* Usually, TYPE_CODE(tp) is already type_code. The main + exception is if we guessed wrong re struct/union/enum. */ + TYPE_CODE(tp) = type_code; + TYPE_NAME(tp) = obsavestring(pn, strlen(pn)); } /* Deal with range types */ if (t->bt == btRange) { struct field *f; - f = new_field(tp, "Low"); - f->bitpos = ax->dnLow; + TYPE_NFIELDS (tp) = 2; + TYPE_FIELDS (tp) = + (struct field *) obstack_alloc (symbol_obstack, + 2 * sizeof (struct field)); + TYPE_FIELD_NAME (tp, 0) = "Low"; + TYPE_FIELD_BITPOS (tp, 0) = ax->dnLow; ax++; - f = new_field(tp, "High"); - f->bitpos = ax->dnHigh; + TYPE_FIELD_NAME (tp, 1) = "High"; + TYPE_FIELD_BITPOS (tp, 1) = ax->dnHigh; ax++; } @@ -1255,8 +1330,21 @@ upgrade_type(tpp, tq, ax, sh) off++; } fh = get_rfd(cur_fd, rf); - f = new_field(t, (char *)0); - bzero(&ss, sizeof ss); + + /* Fields are kept in an array */ + /* FIXME - Memory leak! */ + if (TYPE_NFIELDS(t)) + TYPE_FIELDS(t) = (struct field*) + xrealloc(TYPE_FIELDS(t), + (TYPE_NFIELDS(t)+1) * sizeof(struct field)); + else + TYPE_FIELDS(t) = (struct field*) + xzalloc(sizeof(struct field)); + f = &(TYPE_FIELD(t,TYPE_NFIELDS(t))); + 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); @@ -1503,43 +1591,6 @@ parse_lines(fh, lt) } } - -/* Parse the symbols of the file described by FH, whose index is F_IDX. - BOUND is the highest core address of this file's procedures */ - -static -parse_one_file(fh, f_idx, bound) - FDR *fh; -{ - register int s_idx; - SYMR *sh; - PDR *pr; - - /* Parse local symbols first */ - - for (s_idx = 0; s_idx < fh->csym; s_idx++) { - sh = (SYMR *) (fh->isymBase) + s_idx; - cur_sdx = s_idx; - parse_symbol(sh, fh->iauxBase); - } - - /* Procedures next, note we need to look-ahead to - find out where the procedure's code ends */ - - for (s_idx = 0; s_idx < fh->cpd-1; s_idx++) { - pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; - parse_procedure(pr, pr[1].adr); /* next proc up */ - } - if (fh->cpd) { - pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; - parse_procedure(pr, bound); /* next file up */ - } - - /* Linenumbers. At the end, check if we can save memory */ - parse_lines(fh, LINETABLE(cur_stab)); - if (LINETABLE(cur_stab)->nitems < fh->cline) - shrink_linetable(cur_stab); -} /* Master parsing procedure for first-pass reading of file symbols into a partial_symtab. @@ -1553,7 +1604,8 @@ parse_partial_symbols(end_of_text_seg, objfile) int end_of_text_seg; struct objfile *objfile; { - int f_idx, s_idx, h_max, stat_idx; + int f_idx, s_idx; +/* int stat_idx, h_max;*/ HDRR *hdr; /* Running pointers */ FDR *fh; @@ -1562,6 +1614,30 @@ parse_partial_symbols(end_of_text_seg, objfile) register SYMR *sh; struct partial_symtab *pst; + int past_first_source_file = 0; + + /* List of current psymtab's include files */ + char **psymtab_include_list; + int includes_allocated; + int includes_used; + + /* Index within current psymtab dependency list */ + struct partial_symtab **dependency_list; + int dependencies_used, dependencies_allocated; + + includes_allocated = 30; + includes_used = 0; + psymtab_include_list = (char **) alloca (includes_allocated * + sizeof (char *)); + + dependencies_allocated = 30; + dependencies_used = 0; + dependency_list = + (struct partial_symtab **) alloca (dependencies_allocated * + sizeof (struct partial_symtab *)); + + last_source_file = 0; + /* * Big plan: * @@ -1586,70 +1662,6 @@ parse_partial_symbols(end_of_text_seg, objfile) FDR_IDX(pst) = -1; } - /* Now scan the FDRs, mostly for dependencies */ - for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) - (void) parse_fdr(f_idx, 1, objfile); - - /* Take a good guess at how many symbols we might ever need */ - h_max = hdr->iextMax; - - /* Parse externals: two passes because they can be ordered - in any way, but gdb likes to have them segregated by their - source file. */ - - /* 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++; - } - - if (global_psymbols.list) { - int origsize = global_psymbols.next - global_psymbols.list; - - global_psymbols.list = (struct partial_symbol *) - xrealloc (global_psymbols.list, - (h_max + origsize) * sizeof(struct partial_symbol)); - global_psymbols.next = global_psymbols.list + origsize; - global_psymbols.size = h_max + origsize; - } else { - global_psymbols.list = (struct partial_symbol *) - xmalloc (h_max * sizeof(struct partial_symbol)); - global_psymbols.next = global_psymbols.list; - global_psymbols.size = h_max; - } - - /* Pass 1.5 over files: partition out global symbol space */ - s_idx = global_psymbols.next - global_psymbols.list; - for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++) { - fdr_to_pst[f_idx].pst->globals_offset = s_idx; - s_idx += fdr_to_pst[f_idx].n_globals; - } - - /* Pass 1.6 over files: partition out static symbol space. - Note that this loop starts at 0, not at -1. */ - stat_idx = static_psymbols.next - static_psymbols.list; - for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) { - fdr_to_pst[f_idx].pst->statics_offset = stat_idx; - fh = f_idx + (FDR *)(hdr->cbFdOffset); - stat_idx += fh->csym; - } - - /* Now that we know its max size, allocate static symbol list */ - if (static_psymbols.list) { - int origsize = static_psymbols.next - static_psymbols.list; - - static_psymbols.list = (struct partial_symbol *) - xrealloc (static_psymbols.list, - stat_idx * sizeof(struct partial_symbol)); - static_psymbols.next = static_psymbols.list + origsize; - static_psymbols.size = stat_idx; - } else { - static_psymbols.list = (struct partial_symbol *) - xmalloc (stat_idx * sizeof(struct partial_symbol)); - static_psymbols.next = static_psymbols.list; - static_psymbols.size = stat_idx; - } - /* Pass 2 over external syms: fill in external symbols */ for (s_idx = 0; s_idx < hdr->iextMax; s_idx++) { register struct partial_symbol *p; @@ -1659,132 +1671,185 @@ parse_partial_symbols(end_of_text_seg, objfile) if (esh->asym.sc == scUndefined || esh->asym.sc == scNil) continue; - /* Locate the psymtab and the preallocated psymbol. */ - pst = fdr_to_pst[esh->ifd].pst; - p = global_psymbols.list + pst->globals_offset + - pst->n_global_syms++; - SYMBOL_NAME(p) = (char *)(esh->asym.iss); - SYMBOL_NAMESPACE(p) = VAR_NAMESPACE; - switch (esh->asym.st) { case stProc: - SYMBOL_CLASS(p) = LOC_BLOCK; - SYMBOL_VALUE(p) = esh->asym.value; break; case stGlobal: - SYMBOL_CLASS(p) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS(p) = (CORE_ADDR)esh->asym.value; misc_type = mf_data; break; case stLabel: - SYMBOL_CLASS(p) = LOC_LABEL; - SYMBOL_VALUE_ADDRESS(p) = (CORE_ADDR)esh->asym.value; break; default: misc_type = mf_unknown; complain (&unknown_ext_complaint, SYMBOL_NAME(p)); } - prim_record_misc_function (SYMBOL_NAME(p), - SYMBOL_VALUE(p), + prim_record_misc_function ((char *)(esh->asym.iss), + esh->asym.value, misc_type); } /* Pass 3 over files, over local syms: fill in static symbols */ for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) { - fh = f_idx + (FDR *)(cur_hdr->cbFdOffset); - pst = fdr_to_pst[f_idx].pst; - pst->texthigh = pst->textlow; - - for (s_idx = 0; s_idx < fh->csym; ) { - register struct partial_symbol *p; - - sh = s_idx + (SYMR *) fh->isymBase; - - if (sh->sc == scUndefined || sh->sc == scNil || - sh->index == 0xfffff) { - /* FIXME, premature? */ - s_idx++; - continue; + struct partial_symtab *save_pst; + + fh = f_idx + (FDR *)(cur_hdr->cbFdOffset); + if (fh->csym == 0) { + fdr_to_pst[f_idx].pst = NULL; + continue; + } + pst = start_psymtab (objfile, 0, (char*)fh->rss, + fh->cpd ? fh->adr : 0, + -1, + global_psymbols.next, + static_psymbols.next); + 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; + + /* The way to turn this into a symtab is to call... */ + pst->read_symtab = mipscoff_psymtab_to_symtab; + + pst->texthigh = pst->textlow; + + pst->globals_offset = global_psymbols.next - global_psymbols.list; + pst->statics_offset = static_psymbols.next - static_psymbols.list; + + pst->n_global_syms = 0; + pst->n_static_syms = 0; + + + /* The second symbol must be @stab. */ + if (fh->csym >= 2 + && strcmp(((SYMR *)fh->isymBase)[1].iss, stabs_symbol) == 0) { + for (s_idx = 2; s_idx < fh->csym; s_idx++) { + int type_code; + char *namestring; + sh = s_idx + (SYMR *) fh->isymBase; + type_code = MIPS_UNMARK_STAB(sh->index); + /* TEMPORARY: */ + if (type_code == 0x84 && s_idx == 2) continue; + if (!MIPS_IS_STAB(sh)) { + if (sh->st == stProc || sh->st == stStaticProc) { + long procaddr = sh->value; + sh = (sh->index + (AUXU *)fh->iauxBase)->isym + + (SYMR *) fh->isymBase - 1; + if (sh->st == stEnd) { + long high = procaddr + sh->value; + if (high > pst->texthigh) + pst->texthigh = high; + } } + continue; + } +#define SET_NAMESTRING() namestring = (char*)sh->iss +#define CUR_SYMBOL_TYPE type_code +#define CUR_SYMBOL_VALUE sh->value +#define CHECK_SECOND_N_SO() \ + if (s_idx < fh->csym \ + && MIPS_UNMARK_STAB(((SYMR *)fh->isymBase)[s_idx+1].index) == (unsigned char)N_SO)\ + {\ + s_idx++;\ + sh = s_idx + (SYMR *) fh->isymBase;\ + SET_NAMESTRING ();\ + valu = CUR_SYMBOL_VALUE;\ + s_idx++;\ + } +#define START_PSYMTAB(ofile,addr,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 +#define addr 0 +#define HANDLE_RBRAC(val) \ + if ((val) > save_pst->texthigh) save_pst->texthigh = (val); +/* FIXME: Handle start_file_start and _end */ +/* FIXME: Handle enums - but must deal with next_symbol_text. */ +#include "partial-stab.h" +#undef addr + } + } + else { + for (s_idx = 0; s_idx < fh->csym; ) { + register struct partial_symbol *p; + char *name; + int class; + sh = s_idx + (SYMR *) fh->isymBase; + + if (MIPS_IS_STAB(sh)) { + s_idx++; + continue; + } - /* Locate the preallocated psymbol. */ - p = static_psymbols.list + pst->statics_offset + - pst->n_static_syms; - SYMBOL_NAME(p) = (char *)(sh->iss); - SYMBOL_VALUE(p) = sh->value; - SYMBOL_NAMESPACE(p) = VAR_NAMESPACE; - - switch (sh->st) { - case stProc: /* Asm labels apparently */ - case stStaticProc: /* Function */ - SYMBOL_CLASS(p) = LOC_BLOCK; - pst->n_static_syms++; /* Use gdb symbol */ - /* Skip over procedure to next one. */ - s_idx = (sh->index + (AUXU *)fh->iauxBase) - ->isym; - { - long high; - long procaddr = sh->value; - - sh = s_idx + (SYMR *) fh->isymBase - 1; - if (sh->st != stEnd) - continue; - high = procaddr + sh->value; - if (high > pst->texthigh) - pst->texthigh = high; - } - continue; - case stStatic: /* Variable */ - SYMBOL_CLASS(p) = LOC_STATIC; - SYMBOL_VALUE_ADDRESS(p) = (CORE_ADDR)sh->value; - break; - case stTypedef: /* Typedef */ - SYMBOL_CLASS(p) = LOC_TYPEDEF; - break; - case stConstant: /* Constant decl */ - SYMBOL_CLASS(p) = LOC_CONST; - break; - case stBlock: /* { }, str, un, enum*/ - if (sh->sc == scInfo) { - SYMBOL_NAMESPACE(p) = STRUCT_NAMESPACE; - SYMBOL_CLASS(p) = LOC_TYPEDEF; - pst->n_static_syms++; - } - /* Skip over the block */ - s_idx = sh->index; - continue; - case stFile: /* File headers */ - case stLabel: /* Labels */ - case stEnd: /* Ends of files */ - goto skip; - default: - complain (&unknown_sym_complaint, SYMBOL_NAME(p)); - complain (&unknown_st_complaint, sh->st); - s_idx++; - continue; + if (sh->sc == scUndefined || sh->sc == scNil || + sh->index == 0xfffff) { + /* FIXME, premature? */ + s_idx++; + continue; + } + + name = (char *)(sh->iss); + + switch (sh->st) { + long high; + long procaddr; + case stProc: /* Asm labels apparently */ + case stStaticProc: /* Function */ + ADD_PSYMBOL_TO_LIST(name, strlen(name), + VAR_NAMESPACE, LOC_BLOCK, + static_psymbols, sh->value); + /* Skip over procedure to next one. */ + s_idx = (sh->index + (AUXU *)fh->iauxBase)->isym; + procaddr = sh->value; + + sh = s_idx + (SYMR *) fh->isymBase - 1; + if (sh->st != stEnd) + continue; + high = procaddr + sh->value; + if (high > pst->texthigh) + pst->texthigh = high; + continue; + case stStatic: /* Variable */ + class = LOC_STATIC; + break; + case stTypedef: /* Typedef */ + class = LOC_TYPEDEF; + break; + case stConstant: /* Constant decl */ + class = LOC_CONST; + break; + case stBlock: /* { }, str, un, enum*/ + if (sh->sc == scInfo) { + ADD_PSYMBOL_TO_LIST(name, strlen(name), + STRUCT_NAMESPACE, LOC_TYPEDEF, + static_psymbols, sh->value); } - pst->n_static_syms++; /* Use this gdb symbol */ - skip: - s_idx++; /* Go to next file symbol */ -#if 0 -/* We don't usually record static syms, but some we seem to. chk dbxread. */ -/*FIXME*/ prim_record_misc_function (SYMBOL_NAME(p), - SYMBOL_VALUE(p), - misc_type); -#endif + /* Skip over the block */ + s_idx = sh->index; + continue; + case stFile: /* File headers */ + case stLabel: /* Labels */ + case stEnd: /* Ends of files */ + goto skip; + default: + complain (&unknown_sym_complaint, SYMBOL_NAME(p)); + complain (&unknown_st_complaint, sh->st); + s_idx++; + continue; + } + /* Use this gdb symbol */ + ADD_PSYMBOL_TO_LIST(name, strlen(name), + VAR_NAMESPACE, class, + static_psymbols, sh->value); + skip: + s_idx++; /* Go to next file symbol */ } - } - - /* The array (of lists) of globals must be sorted. */ - reorder_psymtabs(); - - /* Now sort the global psymbols. */ - for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) { - struct partial_symtab *pst = fdr_to_pst[f_idx].pst; - if (pst->n_global_syms > 1) - qsort (global_psymbols.list + pst->globals_offset, - pst->n_global_syms, sizeof (struct partial_symbol), - compare_psymbols); + } + end_psymtab (save_pst, psymtab_include_list, includes_used, + -1, save_pst->texthigh, + dependency_list, dependencies_used, + global_psymbols.next, static_psymbols.next); } /* Mark the last code address, and remember it for later */ @@ -1864,6 +1929,16 @@ parse_fdr(f_idx, lev, objfile) return pst; } +#ifdef READ_MIPS_FORMAT +static int s_idx; + +char* +next_symbol_text () +{ + s_idx++; + return (char*)((SYMR *)cur_fdr->isymBase)[s_idx].iss; +} +#endif /* Ancillary function to psymtab_to_symtab(). Does all the work for turning the partial symtab PST into a symtab, recurring @@ -1873,68 +1948,83 @@ parse_fdr(f_idx, lev, objfile) static void psymtab_to_symtab_1(pst, filename) - struct partial_symtab *pst; - char *filename; + struct partial_symtab *pst; + char *filename; { - int i, f_max; - struct symtab *st; - FDR *fh; - - if (pst->readin) - return; - pst->readin = 1; - - pending_list = (struct pending **) cur_hdr->cbOptOffset; + int have_stabs; + int i, f_max; + struct symtab *st; + FDR *fh; + int maxlines; + struct linetable *lines; + + if (pst->readin) + return; + pst->readin = 1; + + /* How many symbols will we need */ + /* FIXME, this does not count enum values. */ + f_max = pst->n_global_syms + pst->n_static_syms; + if (FDR_IDX(pst) == -1) { + fh = 0; + maxlines = 0; + } else { + fh = (FDR *) (cur_hdr->cbFdOffset) + FDR_IDX(pst); + f_max += fh->csym + fh->cpd; + maxlines = 2 * fh->cline; + } + + have_stabs = + fh && fh->csym >= 2 + && strcmp(((SYMR *)fh->isymBase)[1].iss, stabs_symbol) == 0; + + if (!have_stabs) { + if (fh) + st = new_symtab (pst->filename, 2 * f_max, maxlines, + pst->objfile); + else + st = new_symtab ("unknown", f_max, 0, pst->objfile); + lines = LINETABLE(st); + pending_list = (struct mips_pending **) cur_hdr->cbOptOffset; if (pending_list == 0) { - pending_list = (struct pending **) - xzalloc(cur_hdr->ifdMax * sizeof(struct pending *)); - cur_hdr->cbOptOffset = (int)pending_list; - } - - /* How many symbols will we need */ - /* FIXME, this does not count enum values. */ - f_max = pst->n_global_syms + pst->n_static_syms; - if (FDR_IDX(pst) == -1) { - fh = 0; - st = new_symtab ("unknown", f_max, 0, pst->objfile); - } else { - fh = (FDR *) (cur_hdr->cbFdOffset) + FDR_IDX(pst); - f_max += fh->csym + fh->cpd; - st = new_symtab (pst->filename, 2 * f_max, 2 * fh->cline, - pst->objfile); + pending_list = (struct mips_pending **) + xzalloc(cur_hdr->ifdMax * sizeof(struct mips_pending *)); + cur_hdr->cbOptOffset = (int)pending_list; } - - /* Read in all partial symbtabs on which this one is dependent. - NOTE that we do have circular dependencies, sigh. We solved - that by setting pst->readin before this point. */ - - for (i = 0; i < pst->number_of_dependencies; i++) - if (!pst->dependencies[i]->readin) { - /* Inform about additional files to be read in. */ - if (info_verbose) - { - fputs_filtered (" ", stdout); - wrap_here (""); - fputs_filtered ("and ", stdout); - wrap_here (""); - printf_filtered ("%s...", - pst->dependencies[i]->filename); - wrap_here (""); /* Flush output */ - fflush (stdout); - } - /* We only pass the filename for debug purposes */ - psymtab_to_symtab_1(pst->dependencies[i], - pst->dependencies[i]->filename); + } + + /* Read in all partial symbtabs on which this one is dependent. + NOTE that we do have circular dependencies, sigh. We solved + that by setting pst->readin before this point. */ + + for (i = 0; i < pst->number_of_dependencies; i++) + if (!pst->dependencies[i]->readin) { + /* Inform about additional files to be read in. */ + if (info_verbose) + { + fputs_filtered (" ", stdout); + wrap_here (""); + fputs_filtered ("and ", stdout); + wrap_here (""); + printf_filtered ("%s...", + pst->dependencies[i]->filename); + wrap_here (""); /* Flush output */ + fflush (stdout); } - - /* Now read the symbols for this symtab */ - + /* We only pass the filename for debug purposes */ + psymtab_to_symtab_1(pst->dependencies[i], + pst->dependencies[i]->filename); + } + + cur_fdr = fh; + /* Now read the symbols for this symtab */ + + if (!have_stabs) { cur_fd = FDR_IDX(pst); - cur_fdr = fh; cur_stab = st; - + /* Get a new lexical context */ - + push_parse_stack(); top_stack->cur_st = cur_stab; top_stack->cur_block = BLOCKVECTOR_BLOCK(BLOCKVECTOR(cur_stab), @@ -1946,42 +2036,102 @@ psymtab_to_symtab_1(pst, filename) top_stack->cur_type = 0; top_stack->procadr = 0; top_stack->numargs = 0; + } + + /* Parse locals and procedures */ + if (fh) { + SYMR *sh; + PDR *pr; + int f_idx = cur_fd; + char *fh_name = (char*)fh->rss; + + /* Parse local symbols first */ + + + if (have_stabs) { + if (fh->csym <= 2) + return; + for (s_idx = 2; s_idx < fh->csym; s_idx++) { + register SYMR *sh = s_idx + (SYMR *) fh->isymBase; + char *name = (char*)sh->iss; + CORE_ADDR valu = sh->value; + if (MIPS_IS_STAB(sh)) { + int type_code = MIPS_UNMARK_STAB(sh->index); + /* TEMPORARY: */ + if (type_code == 0x84 && s_idx == 2) continue; + process_one_symbol (type_code, 0, valu, name); + } + else if (sh->st == stLabel && sh->index != indexNil) { + /* Handle encoded stab line number. */ + record_line (current_subfile, sh->index, valu); + } + } + st = end_symtab (pst->texthigh, 0, 0, pst->objfile); + } + else { + /* BOUND is the highest core address of this file's procedures */ + int bound = cur_fd == cur_hdr->ifdMax - 1 ? cur_hdr->cbDnOffset + : fh[1].adr; + for (s_idx = 0; s_idx < fh->csym; ) { + sh = (SYMR *) (fh->isymBase) + s_idx; + cur_sdx = s_idx; + s_idx += parse_symbol(sh, fh->iauxBase); + } - /* Parse locals and procedures */ - if (fh) - parse_one_file(fh, cur_fd, (cur_fd == (cur_hdr->ifdMax - 1)) ? - cur_hdr->cbDnOffset : fh[1].adr); + /* Procedures next, note we need to look-ahead to + find out where the procedure's code ends */ + + for (s_idx = 0; s_idx < fh->cpd-1; s_idx++) { + pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; + parse_procedure(pr, pr[1].adr); /* next proc up */ + } + if (fh->cpd) { + pr = (PDR *) (IPDFIRST(cur_hdr, fh)) + s_idx; + parse_procedure(pr, bound); /* next file up */ + } + /* Linenumbers. At the end, check if we can save memory */ + parse_lines(fh, lines); + if (lines->nitems < fh->cline) + lines = shrink_linetable(lines); + } + } + if (!have_stabs) { + LINETABLE(st) = lines; + /* .. and our share of externals. XXX use the global list to speed up things here. how ? FIXME, Maybe quit once we have found the right number of ext's? */ /* parse_external clobbers top_stack->cur_block and ->cur_st here. */ top_stack->blocktype = stFile; - top_stack->maxsyms = cur_hdr->isymMax + cur_hdr->ipdMax + cur_hdr->iextMax; + top_stack->maxsyms = + cur_hdr->isymMax + cur_hdr->ipdMax + cur_hdr->iextMax; + for (i = 0; i < cur_hdr->iextMax; i++) { - register EXTR *esh = (EXTR *) (cur_hdr->cbExtOffset) + i; - if (esh->ifd == cur_fd) - parse_external(esh, 1); + register EXTR *esh = (EXTR *) (cur_hdr->cbExtOffset) + i; + if (esh->ifd == cur_fd) + parse_external(esh, 1); } - + /* If there are undefined, tell the user */ if (n_undef_symbols) { - printf_filtered("File %s contains %d unresolved references:", - st->filename, n_undef_symbols); - printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n", - n_undef_vars, n_undef_procs, n_undef_labels); - n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0; - } + printf_filtered("File %s contains %d unresolved references:", + st->filename, n_undef_symbols); + printf_filtered("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n", + n_undef_vars, n_undef_procs, n_undef_labels); + n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0; + } pop_parse_stack(); - - /* - * Sort the symbol table now, we are done adding symbols to it. - */ - sort_symtab_syms(st); - - /* Now link the psymtab and the symtab. */ - pst->symtab = st; + } + + /* Sort the symbol table now, we are done adding symbols to it.*/ + sort_symtab_syms(st); + + sort_blocks (st); + + /* Now link the psymtab and the symtab. */ + pst->symtab = st; } /* Ancillary parsing procedures. */ @@ -1991,10 +2141,11 @@ psymtab_to_symtab_1(pst, filename) Return value says how many aux symbols we ate */ static -cross_ref(rn, tpp, pname) - RNDXR *rn; - struct type **tpp; - char **pname; +cross_ref(rn, tpp, type_code, pname) + RNDXR *rn; + struct type **tpp; + int type_code; /* Use to alloc new type if none is found. */ + char **pname; { unsigned rf; @@ -2034,15 +2185,14 @@ cross_ref(rn, tpp, pname) t = (struct type *) sh->value; *tpp = t; } else { - struct pending *p; - - /* Avoid duplicates */ - p = is_pending_symbol(fh, sh); - - if (p) - *tpp = p->t; - else - add_pending(fh, sh, *tpp); + /* Avoid duplicates */ + struct mips_pending *p = is_pending_symbol(fh, sh); + if (p) + *tpp = p->t; + else { + *tpp = make_type(type_code, 0, 0, 0); + add_pending(fh, sh, *tpp); + } } } @@ -2195,20 +2345,6 @@ compare_psymtabs( s1, s2) } -/* Partial symbols are compared lexicog by their print names */ - -static int -compare_psymbols (s1, s2) - register struct partial_symbol *s1, *s2; -{ - register char - *st1 = SYMBOL_NAME(s1), - *st2 = SYMBOL_NAME(s2); - - return (st1[0] - st2[0] ? st1[0] - st2[0] : - strcmp(st1 + 1, st2 + 1)); -} - /* Blocks with a smaller low bound should come first */ static int compare_blocks(b1,b2) @@ -2274,80 +2410,6 @@ sort_blocks(s) BLOCK_END (BLOCKVECTOR_BLOCK(bv,GLOBAL_BLOCK)); } -/* Sort the symtab list, as required by some search procedures. - We want files ordered to make them look right to users, and for - searching (see block_for_pc). */ - -static void -reorder_symtabs() -{ - register int i; - struct symtab *stab; - register struct symtab **all_symtabs; - register int symtab_count; - - if (!symtab_list) - return; - - /* Create an array of pointers to all the symtabs. */ - for (symtab_count = 0, stab = symtab_list; - stab; - symtab_count++, stab = stab->next) { - obstack_grow (psymbol_obstack, &stab, sizeof (stab)); - /* FIXME: Only sort blocks for new symtabs ??? */ - sort_blocks(stab); - } - - all_symtabs = (struct symtab **) - obstack_base (psymbol_obstack); - qsort((char *)all_symtabs, symtab_count, - sizeof(struct symtab *), compare_symtabs); - - /* Re-construct the symtab list, but now it is sorted. */ - for (i = 0; i < symtab_count-1; i++) - all_symtabs[i]->next = all_symtabs[i+1]; - all_symtabs[i]->next = 0; - symtab_list = all_symtabs[0]; - - obstack_free (psymbol_obstack, all_symtabs); -} - -/* Sort the partial symtab list, as required by some search procedures. - PC lookups stop at the first psymtab such that textlow <= PC < texthigh */ - -static void -reorder_psymtabs() -{ - register int i; - register int all_psymtabs_count; - struct partial_symtab *pstab; - struct partial_symtab **all_psymtabs; - - if (!partial_symtab_list) - return; - - /* Create an array of pointers to all the partial_symtabs. */ - - for (all_psymtabs_count = 0, pstab = partial_symtab_list; - pstab; - all_psymtabs_count++, pstab = pstab->next) - obstack_grow (psymbol_obstack, &pstab, sizeof (pstab)); - - all_psymtabs = (struct partial_symtab **) - obstack_base (psymbol_obstack); - - qsort((char *)all_psymtabs, all_psymtabs_count, - sizeof(struct partial_symtab *), compare_psymtabs); - - /* Re-construct the partial_symtab_list, but now it is sorted. */ - - for (i = 0; i < all_psymtabs_count-1; i++) - all_psymtabs[i]->next = all_psymtabs[i+1]; - all_psymtabs[i]->next = 0; - partial_symtab_list = all_psymtabs[0]; - - obstack_free (psymbol_obstack, all_psymtabs); -} /* Constructor/restructor/destructor procedures */ @@ -2390,7 +2452,7 @@ new_psymtab(name, objfile) pst = (struct partial_symtab *) obstack_alloc (psymbol_obstack, sizeof (*pst)); - bzero (pst, sizeof (*pst)); + memset (pst, 0, sizeof (*pst)); if (name == (char*)-1) /* FIXME -- why not null here? */ pst->filename = "<no name>"; @@ -2419,8 +2481,8 @@ new_psymtab(name, objfile) /* Allocate a linetable array of the given SIZE */ -static -struct linetable *new_linetable(size) +static struct linetable * +new_linetable(size) { struct linetable *l; @@ -2433,16 +2495,15 @@ struct linetable *new_linetable(size) /* Oops, too big. Shrink it. This was important with the 2.4 linetables, I am not so sure about the 3.4 ones */ -static void -shrink_linetable(s) - struct symtab *s; +static struct linetable * +shrink_linetable(lt) + struct linetable * lt; { - struct linetable *l = new_linetable(LINETABLE(s)->nitems); + struct linetable *l = new_linetable(lt->nitems); - bcopy(LINETABLE(s), l, - LINETABLE(s)->nitems * sizeof(l->item) + sizeof(struct linetable)); - free (LINETABLE(s)); - LINETABLE(s) = l; + memcpy(l, lt, lt->nitems * sizeof(l->item) + sizeof(struct linetable)); + free (lt); + return l; } /* Allocate and zero a new blockvector of NBLOCKS blocks. */ @@ -2513,7 +2574,7 @@ new_symbol(name) struct symbol *s = (struct symbol *) obstack_alloc (symbol_obstack, sizeof (struct symbol)); - bzero (s, sizeof (*s)); + memset (s, 0, sizeof (*s)); SYMBOL_NAME(s) = name; return s; } @@ -2528,9 +2589,10 @@ new_type(name) struct type *t = (struct type *) obstack_alloc (symbol_obstack, sizeof (struct type)); - bzero (t, sizeof (*t)); + memset (t, 0, sizeof (*t)); TYPE_VPTR_FIELDNO (t) = -1; TYPE_NAME(t) = name; + TYPE_CPLUS_SPECIFIC(t) = &cplus_struct_default; return t; } @@ -2545,167 +2607,26 @@ make_type(code, length, uns, name) int length, uns; char *name; { - register struct type *type; - - /* FIXME, I don't think this ever gets freed. */ - type = (struct type *) xzalloc(sizeof(struct type)); - TYPE_CODE(type) = code; - TYPE_LENGTH(type) = length; - TYPE_FLAGS(type) = uns ? TYPE_FLAG_UNSIGNED : 0; - TYPE_NAME(type) = name; - TYPE_VPTR_FIELDNO (type) = -1; - - return type; -} - -/* Create and initialize a new struct or union type, a la make_type. */ - -static -struct type * -make_struct_type(code, length, uns, name) - enum type_code code; - int length, uns; - char *name; -{ - register struct type *type; - - type = make_type (code, length, uns, name); - - /* FIXME, I don't think this ever gets freed. */ - TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *) - xzalloc (sizeof (struct cplus_struct_type)); - return type; + register struct type *type; + + /* FIXME, I don't think this ever gets freed. */ + type = (struct type *) xzalloc(sizeof(struct type)); + TYPE_CODE(type) = code; + TYPE_LENGTH(type) = length; + TYPE_FLAGS(type) = uns ? TYPE_FLAG_UNSIGNED : 0; + TYPE_NAME(type) = name; + TYPE_VPTR_FIELDNO (type) = -1; + + if (code != TYPE_CODE_METHOD && code != TYPE_CODE_FUNC) + TYPE_CPLUS_SPECIFIC(type) = &cplus_struct_default; + return type; } - -/* Allocate a new field named NAME to the type TYPE */ - -static -struct field * -new_field(type,name) - struct type *type; - char *name; -{ - struct field *f; - - /* Fields are kept in an array */ - if (TYPE_NFIELDS(type)) - TYPE_FIELDS(type) = (struct field*)xrealloc(TYPE_FIELDS(type), - (TYPE_NFIELDS(type)+1) * sizeof(struct field)); - else - TYPE_FIELDS(type) = (struct field*)xzalloc(sizeof(struct field)); - f = &(TYPE_FIELD(type,TYPE_NFIELDS(type))); - TYPE_NFIELDS(type)++; - bzero(f, sizeof(struct field)); - f->name = name; /* Whether or not NAME is zero, this works. */ - return f; -} - -/* Make an enum constant for a member F of an enumerated type T */ - -static -make_enum_constant(f,t) - struct field *f; - struct type *t; -{ - struct symbol *s; - /* - * This is awful, but that`s the way it is supposed to be - * (BTW, no need to free the real 'type', it's a builtin) - */ - f->type = (struct type *) f->bitpos; - - s = new_symbol(f->name); - SYMBOL_NAMESPACE(s) = VAR_NAMESPACE; - SYMBOL_CLASS(s) = LOC_CONST; - SYMBOL_TYPE(s) = t; - SYMBOL_VALUE(s) = f->bitpos; - add_symbol(s, top_stack->cur_block); -} - - /* Things used for calling functions in the inferior. These functions are exported to our companion - mips-dep.c file and are here because they play + mips-tdep.c file and are here because they play with the symbol-table explicitly. */ -#if 0 -/* Need to make a new symbol on the fly for the dummy - frame we put on the stack. Which goes in the.. */ - -static struct symtab *dummy_symtab; - -/* Make up a dummy symbol for the code we put at END_PC, - of size SIZE, invoking a function with NARGS arguments - and using a frame of FRAMESIZE bytes */ - -mips_create_dummy_symbol(end_pc, size, nargs, framesize) -{ - struct block *bl; - struct symbol *g; - struct mips_extra_func_info *gdbinfo; - - /* Allocate symtab if not done already */ - if (dummy_symtab == 0) - dummy_symtab = new_symtab(".dummy_symtab.", 100, 0); - - /* Make a new block. Only needs one symbol */ - bl = new_block(1); - BLOCK_START(bl) = end_pc - size; - BLOCK_END(bl) = end_pc; - - BLOCK_SUPERBLOCK(bl) = - BLOCKVECTOR_BLOCK(BLOCKVECTOR(dummy_symtab),GLOBAL_BLOCK); - add_block(bl, dummy_symtab); - sort_blocks(dummy_symtab); - - BLOCK_FUNCTION(bl) = new_symbol("??"); - SYMBOL_BLOCK_VALUE(BLOCK_FUNCTION(bl)) = bl; - g = new_symbol(".gdbinfo."); - BLOCK_SYM(bl,BLOCK_NSYMS(bl)++) = g; - - SYMBOL_NAMESPACE(g) = LABEL_NAMESPACE; - SYMBOL_CLASS(g) = LOC_CONST; - SYMBOL_TYPE(g) = builtin_type_void; - gdbinfo = (struct mips_extra_func_info *) - xzalloc(sizeof(struct mips_extra_func_info)); - - SYMBOL_VALUE(g) = (long) gdbinfo; - - gdbinfo->numargs = nargs; - gdbinfo->framesize = framesize; - gdbinfo->framereg = 29; - gdbinfo->pcreg = 31; - gdbinfo->regmask = -2; - gdbinfo->regoffset = -4; - gdbinfo->fregmask = 0; /* XXX */ - gdbinfo->fregoffset = 0; /* XXX */ -} - -/* We just returned from the dummy code at END_PC, drop its symbol */ - -mips_destroy_dummy_symbol(end_pc) -{ - struct block *bl; - struct blockvector *bv = BLOCKVECTOR(dummy_symtab); - int i; - - bl = block_for_pc(end_pc); - free(BLOCK_FUNCTION(bl)); - free(SYMBOL_VALUE(BLOCK_SYM(bl,0))); - free(BLOCK_SYM(bl,0)); - - for (i = FIRST_LOCAL_BLOCK; i < BLOCKVECTOR_NBLOCKS(bv); i++) - if (BLOCKVECTOR_BLOCK(bv,i) == bl) - break; - for (; i < BLOCKVECTOR_NBLOCKS(bv) - 1; i++) - BLOCKVECTOR_BLOCK(bv,i) = BLOCKVECTOR_BLOCK(bv,i+1); - BLOCKVECTOR_NBLOCKS(bv)--; - sort_blocks(dummy_symtab); - free(bl); -} -#endif - /* Sigtramp: make sure we have all the necessary information about the signal trampoline code. Since the official code from MIPS does not do so, we make up that information ourselves. |