#include "bfd.h"
#include "coff/internal.h"
-#include "coff/mips.h" /* COFF-like aspects of ecoff files */
-#include "coff/ecoff-ext.h" /* External forms of ecoff sym structures */
+#include "coff/ecoff.h" /* COFF-like aspects of ecoff files */
/* FIXME: coff/internal.h and aout/aout64.h both define N_ABS. We
want the definition from aout/aout64.h. */
#undef N_ABS
-/* FIXME: coff/mips.h and aout/aout64.h both define ZMAGIC. We don't
- use it. */
-#undef ZMAGIC
#include "libaout.h" /* Private BFD a.out information. */
#include "aout/aout64.h"
#include "expression.h"
#include "language.h" /* Needed inside partial-stab.h */
+/* 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.
bfd *cur_bfd;
EXTR *extern_tab; /* Pointer to external symbols for this file. */
int extern_count; /* Size of extern_tab. */
- struct mips_pending **pending_list;
+ 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 bad_setjmp_pdr_complaint =
{"fixing bad setjmp PDR from libc", 0, 0};
+struct complaint bad_fbitfield_complaint =
+{"can't handle TIR fBitfield for %s", 0, 0};
+
+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};
+
/* Macros and extra defs */
/* Already-parsed symbols are marked specially */
static int
cross_ref PARAMS ((union aux_ext *, struct type **, enum type_code, char **,
- int));
+ int, char *));
static void
fixup_sigtramp PARAMS ((void));
new_bvect PARAMS ((int));
static struct type *
-parse_type PARAMS ((union aux_ext *, int *, int));
+parse_type PARAMS ((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 *));
{
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
/* Object files do not have the RFD table, all refs are absolute */
if (f->rfdBase == 0)
return fdrs + rf;
- ecoff_swap_rfd_in (cur_bfd,
- ecoff_data (cur_bfd)->external_rfd + f->rfdBase + rf,
- &rfd);
+ (*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;
}
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 */
- struct sym_ext *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 */
static struct mips_pending *
is_pending_symbol (fh, sh)
FDR *fh;
- struct sym_ext *sh;
+ char *sh;
{
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)
static void
add_pending (fh, sh, t)
FDR *fh;
- struct sym_ext *sh;
+ char *sh;
struct type *t;
{
int f_idx = fh - ecoff_data (cur_bfd)->fdr;
/* 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;
}
}
-
-/* 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
-
\f
/* Parsing Routines proper. */
parse_symbol (sh, ax, ext_sh, bigend)
SYMR *sh;
union aux_ext *ax;
- struct sym_ext *ext_sh;
+ 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;
enum address_class class;
TIR tir;
- if (ext_sh == (struct sym_ext *) NULL)
+ 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;
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 (ax + sh->index, 0, bigend, name);
/* Value of a data symbol is its memory address */
break;
break;
}
SYMBOL_VALUE (s) = sh->value;
- SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend);
+ SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend, name);
add_symbol (s, top_stack->cur_block);
#if 0
/* FIXME: This has not been tested. See dbxread.c */
if (sh->sc == scUndefined || sh->sc == scNil)
t = builtin_type_int;
else
- t = parse_type (ax + sh->index + 1, 0, bigend);
+ t = parse_type (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->numargs = 0;
sh->value = (long) SYMBOL_TYPE (s);
+ sh->st = stParsed;
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;
- struct sym_ext *ext_tsym;
+ char *ext_tsym;
int nfields;
long max_value;
struct field *f;
/* First count the number of fields and the highest value. */
nfields = 0;
max_value = 0;
- for (ext_tsym = ext_sh + 1; ; ext_tsym++)
+ for (ext_tsym = ext_sh + external_sym_size;
+ ;
+ ext_tsym += external_sym_size)
{
SYMR tsym;
- ecoff_swap_sym_in (cur_bfd, ext_tsym, &tsym);
-
- if (tsym.st == stEnd)
- break;
+ (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
- if (tsym.st == stMember)
+ 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
nfields++;
if (tsym.value > max_value)
max_value = tsym.value;
+ break;
+
+ case stBlock:
+ case stUnion:
+ case stEnum:
+ case stStruct:
+ case stParsed:
+ {
+#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 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)
- {
- /* 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 = (ecoff_data (cur_bfd)->external_sym
- + cur_fdr->isymBase
- + tsym.index
- - 1);
- }
- }
- 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
TYPE_FIELDS (t) = f = ((struct field *)
TYPE_ALLOC (t,
nfields * sizeof (struct field)));
+ /* Handle opaque struct definitions. */
+ if (TYPE_NFIELDS (t) == 0)
+ {
+ TYPE_FLAGS (t) |= TYPE_FLAG_STUB;
+ SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ }
if (type_code == TYPE_CODE_ENUM)
{
/* This is a non-empty enum. */
- for (ext_tsym = ext_sh + 1; ; ext_tsym++)
+ for (ext_tsym = ext_sh + external_sym_size;
+ ;
+ ext_tsym += external_sym_size)
{
SYMR tsym;
struct symbol *enum_sym;
- ecoff_swap_sym_in (cur_bfd, ext_tsym, &tsym);
+ (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
if (tsym.st != stMember)
break;
top_stack->cur_field = 0;
/* Mark that symbol has a type, and say which one */
sh->value = (long) t;
+ sh->st = stParsed;
break;
/* End of local variables shared by struct, union, enum, and
f->name = name;
f->bitpos = sh->value;
f->bitsize = 0;
- f->type = parse_type (ax + sh->index, &f->bitsize, bigend);
+ f->type = parse_type (ax + sh->index, &f->bitsize, bigend, name);
break;
case stTypedef: /* type definition */
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, 0, bigend);
+ SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend, name);
sh->value = (long) SYMBOL_TYPE (s);
+ sh->st = stParsed;
+ if (TYPE_TAG_NAME (SYMBOL_TYPE (s)) != NULL
+ && STREQ (TYPE_TAG_NAME (SYMBOL_TYPE (s)), "<undefined>"))
+ {
+ /* mips cc puts out a stTypedef for opaque struct definitions. */
+ TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_STUB;
+ }
+ /* 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 */
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 (ax, bs, bigend, sym_name)
union aux_ext *ax;
int *bs;
int bigend;
+ char *sym_name;
{
/* Null entries in this map are treated specially */
static struct type **map_bt[] =
TIR t[1];
struct type *tp = 0;
- char *fmt;
union aux_ext *tax;
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])
break;
case btTypedef:
default:
- complain (&basic_type_complaint, t->bt);
+ complain (&basic_type_complaint, t->bt, sym_name);
return builtin_type_int;
}
}
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++;
}
char *name;
/* Try to cross reference this type */
- ax += cross_ref (ax, &tp, type_code, &name, bigend);
+ ax += cross_ref (ax, &tp, type_code, &name, bigend, sym_name);
/* reading .o file ? */
if (tp == (struct type *) NULL)
tp = init_type (type_code, 0, 0, (char *) NULL,
(struct objfile *) NULL);
- /* 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)
+ /* 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 (&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;
+ }
+ /* 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);
}
- 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. */
+ 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 */
- ax += cross_ref (ax, &tp, type_code, &name, bigend);
+ ax += cross_ref (ax, &tp, type_code, &name, bigend, sym_name);
/* reading .o file ? */
if (tp == (struct type *) NULL)
tp = init_type (type_code, 0, 0, (char *) NULL,
(struct objfile *) NULL);
- /* 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)
+ /* 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 (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
- TYPE_NAME (tp) = obsavestring (name, strlen (name),
- ¤t_objfile->type_obstack);
}
/* Deal with range types */
indx = parse_type ((ecoff_data (cur_bfd)->external_aux
+ fh->iauxBase
+ id),
- (int *) NULL, bigend);
+ (int *) NULL, bigend, "<array index>");
/* Get the bounds, and create the array type. */
ax++;
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.
+ 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. */
- EFI_SYMBOL is the MIPS_EFI_SYMBOL_NAME symbol to use, or NULL which
- means to look up the name using the block in top_stack. */
-
-static void parse_procedure PARAMS ((PDR *, struct symbol *, unsigned long));
+static void parse_procedure PARAMS ((PDR *, struct symtab *, unsigned long));
static void
-parse_procedure (pr, efi_symbol, first_off)
+parse_procedure (pr, search_symtab, first_off)
PDR *pr;
- struct symbol *efi_symbol;
+ struct symtab *search_symtab;
unsigned long first_off;
{
- struct symbol *s;
+ struct symbol *s, *i;
struct block *b;
struct mips_extra_func_info *e;
char *sh_name;
/* external */
EXTR she;
- ecoff_swap_ext_in (cur_bfd,
- ecoff_data (cur_bfd)->external_ext + pr->isym,
- &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;
}
}
/* Full symbols */
SYMR sh;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + cur_fdr->isymBase
- + pr->isym),
- &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 (efi_symbol == NULL)
+ if (search_symtab != NULL)
{
- /* OK, first find the function. */
-
- s = mylookup_symbol (sh_name, top_stack->cur_block,
- VAR_NAMESPACE, LOC_BLOCK);
+#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
+ }
+ else
+ s = mylookup_symbol (sh_name, top_stack->cur_block,
+ VAR_NAMESPACE, LOC_BLOCK);
- if (s != 0)
- {
- b = SYMBOL_BLOCK_VALUE (s);
- }
- else
- {
- complain (&pdr_for_nonsymbol_complaint, sh_name);
+ if (s != 0)
+ {
+ b = SYMBOL_BLOCK_VALUE (s);
+ }
+ else
+ {
+ complain (&pdr_for_nonsymbol_complaint, sh_name);
#if 1
- return;
+ return;
#else
/* FIXME -- delete. We can't do symbol allocation now; it's all done. */
- s = new_symbol (sh_name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
- SYMBOL_CLASS (s) = LOC_BLOCK;
- /* Donno its type, hope int is ok */
- SYMBOL_TYPE (s) = lookup_function_type (builtin_type_int);
- add_symbol (s, top_stack->cur_block);
- /* Wont have symbols for this one */
- b = new_block (2);
- 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);
+ s = new_symbol (sh_name);
+ SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_CLASS (s) = LOC_BLOCK;
+ /* Donno its type, hope int is ok */
+ SYMBOL_TYPE (s) = lookup_function_type (builtin_type_int);
+ add_symbol (s, top_stack->cur_block);
+ /* Wont have symbols for this one */
+ b = new_block (2);
+ 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);
#endif
- }
-
- efi_symbol = mylookup_symbol
- (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
}
- if (efi_symbol)
+ i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
+
+ if (i)
{
- e = (struct mips_extra_func_info *) SYMBOL_VALUE (efi_symbol);
+ 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;
case stLabel:
/* Note that the case of a symbol with indexNil must be handled
anyways by parse_symbol(). */
- parse_symbol (&es->asym, ax, (struct sym_ext *) NULL, bigend);
+ parse_symbol (&es->asym, ax, (char *) NULL, bigend);
/* Note that parse_symbol changed es->asym. */
break;
default:
int delta, count, lineno = 0;
unsigned long first_off = pr->adr;
- if (fh->cbLineOffset == 0)
+ if (fh->cbLine == 0)
return;
base = ecoff_data (cur_bfd)->line + fh->cbLineOffset;
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 = &ecoff_data (cur_bfd)->symbolic_header;
/* Running pointers */
FDR *fh;
- struct ext_ext *ext_out;
- struct ext_ext *ext_out_end;
+ char *ext_out;
+ char *ext_out_end;
EXTR *ext_block;
register EXTR *ext_in;
EXTR *ext_in_end;
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);
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 = ecoff_data (cur_bfd)->external_ext;
- ext_out_end = ext_out + hdr->iextMax;
+ 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++, ext_in++)
- ecoff_swap_ext_in (cur_bfd, ext_out, ext_in);
+ 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 */
ext_in = ext_block;
case stProc:
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;
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;
-
- /* FIXME: This tampers with data from BFD. */
- fh->ioptBase = (int) pst;
-
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.
processing_gcc_compilation = 0;
if (fh->csym >= 2)
{
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + 1),
- &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))
processing_gcc_compilation = 2;
int type_code;
char *namestring;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + cur_sdx),
- &sh);
- 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)
{
(ecoff_data (cur_bfd)->external_aux
+ fh->iauxBase
+ sh.index));
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + isym
- - 1),
- &sh);
+ (*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;
char *name;
enum address_class class;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + cur_sdx),
- &sh);
+ (*swap_sym_in) (cur_bfd,
+ ((char *) ecoff_data (cur_bfd)->external_sym
+ + ((fh->isymBase + cur_sdx)
+ * external_sym_size)),
+ &sh);
- if (MIPS_IS_STAB (&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++;
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,
}
cur_sdx = new_sdx;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + cur_sdx
- - 1),
- &sh);
+ (*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;
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;
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;
}
}
- 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)
{
/* Now scan the FDRs for dependencies */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
- int s_id0 = 0;
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;
-
- ecoff_swap_rfd_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_rfd
- + fh->rfdBase
- + s_id0),
- &rh);
- 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;
- ecoff_swap_rfd_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_rfd
- + fh->rfdBase
- + s_idx),
- &rh);
+ (*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)
- 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;
-
- fh = ecoff_data (cur_bfd)->fdr + 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 (fdr_name (fh), 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;
-
- ecoff_swap_rfd_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_rfd
- + fh->rfdBase
- + s_id0),
- &rh);
- if (rh == f_idx)
{
- s_id0++; /* Skip self-dependency */
- break;
+ complain (&bad_file_number_complaint, rh);
+ continue;
}
+
+ /* Skip self dependencies of header files. */
+ if (rh == f_idx)
+ continue;
+
+ /* 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;
}
}
- 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;
-
- ecoff_swap_rfd_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_rfd
- + fh->rfdBase
- + s_idx),
- &rh);
- pst->dependencies[s_idx - s_id0] = parse_fdr (rh, lev + 1, objfile);
- }
-
- return pst;
+ do_cleanups (old_chain);
}
-#endif
static char *
mips_next_symbol_text ()
SYMR sh;
cur_sdx++;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + cur_fdr->isymBase
- + cur_sdx),
- &sh);
+ (*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;
}
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_sym_out) PARAMS ((bfd *, const SYMR *, PTR))
+ = ecoff_backend (cur_bfd)->swap_sym_out;
+ void (* const swap_pdr_in) PARAMS ((bfd *, PTR, PDR *))
+ = ecoff_backend (cur_bfd)->swap_pdr_in;
int i;
struct symtab *st;
FDR *fh;
{
SYMR sh;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + 1),
- &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))
{
if (processing_gcc_compilation != 0)
{
- /* This symbol table contains stabs-in-ecoff entries. */
-
- struct pdr_ext *pdr_ptr;
- struct pdr_ext *pdr_end;
+ char *pdr_ptr;
+ char *pdr_end;
int first_pdr;
- unsigned long first_off;
- struct cleanup *old_cleanups;
-
- /* Given a symbol index in the symbol file, find the
- MIPS_EFI_SYMBOL_NAME symbol which goes with it. If this is taking
- up too much memory, we could get fancy with hash tables or some
- such. */
- struct symbol **mips_func_info_by_isym;
+ unsigned long first_off = 0;
- mips_func_info_by_isym = (struct symbol **)
- xmalloc (fh->csym * sizeof (*mips_func_info_by_isym));
- old_cleanups = make_cleanup (free, mips_func_info_by_isym);
+ /* This symbol table contains stabs-in-ecoff entries. */
/* Parse local symbols first */
char *name;
CORE_ADDR valu;
- ecoff_swap_sym_in (cur_bfd,
- (ecoff_data (cur_bfd)->external_sym
- + fh->isymBase
- + cur_sdx),
- &sh);
+ (*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 (MIPS_IS_STAB (&sh))
+ 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)
SYMBOL_TYPE (s) = builtin_type_void;
SYMBOL_VALUE (s) = (int) e;
add_symbol_to_list (s, &local_symbols);
- mips_func_info_by_isym[cur_sdx] = s;
}
}
else if (sh.st == stLabel && sh.index != indexNil)
/* Fill in procedure info next. */
first_pdr = 1;
- pdr_ptr = ecoff_data (cur_bfd)->external_pdr + fh->ipdFirst;
- pdr_end = pdr_ptr + fh->cpd;
- for (; pdr_ptr < pdr_end; pdr_ptr++)
+ 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)
{
PDR pr;
- ecoff_swap_pdr_in (cur_bfd, pdr_ptr, &pr);
+ (*swap_pdr_in) (cur_bfd, pdr_ptr, &pr);
if (first_pdr)
{
first_off = pr.adr;
first_pdr = 0;
}
- parse_procedure (&pr, mips_func_info_by_isym [pr.isym], first_off);
+ parse_procedure (&pr, st, first_off);
}
-
- do_cleanups (old_cleanups);
}
else
{
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 = PST_PRIVATE (pst)->pending_list;
- if (pending_list == 0)
- {
- pending_list = ((struct mips_pending **)
- xzalloc (ecoff_data (cur_bfd)->symbolic_header.ifdMax
- * sizeof (struct mips_pending *)));
- PST_PRIVATE (pst)->pending_list = pending_list;
- }
/* Get a new lexical context */
if (fh)
{
- struct sym_ext *sym_ptr;
- struct sym_ext *sym_end;
+ char *sym_ptr;
+ char *sym_end;
/* Parse local symbols first */
- sym_ptr = ecoff_data (cur_bfd)->external_sym + fh->isymBase;
- sym_end = sym_ptr + 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)
{
SYMR sh;
int c;
- ecoff_swap_sym_in (cur_bfd, sym_ptr, &sh);
+ (*swap_sym_in) (cur_bfd, sym_ptr, &sh);
c = parse_symbol (&sh,
(ecoff_data (cur_bfd)->external_aux
+ fh->iauxBase),
sym_ptr, fh->fBigendian);
/* FIXME: We must swap the modified symbol back out,
although we would rather not. See parse_symbol. */
- ecoff_swap_sym_out (cur_bfd, &sh, sym_ptr);
- sym_ptr += c;
+ (*swap_sym_out) (cur_bfd, &sh, sym_ptr);
+ sym_ptr += c * external_sym_size;
}
/* Linenumbers. At the end, check if we can save memory.
{
PDR *pr_block;
struct cleanup *old_chain;
- struct pdr_ext *pdr_ptr;
- struct pdr_ext *pdr_end;
+ char *pdr_ptr;
+ char *pdr_end;
PDR *pdr_in;
PDR *pdr_in_end;
old_chain = make_cleanup (free, pr_block);
- pdr_ptr = ecoff_data (cur_bfd)->external_pdr + fh->ipdFirst;
- pdr_end = pdr_ptr + fh->cpd;
+ 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++, pdr_in++)
- ecoff_swap_pdr_in (cur_bfd, pdr_ptr, pdr_in);
+ 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)
Return value says how many aux symbols we ate. */
static int
-cross_ref (ax, tpp, type_code, pname, bigend)
+cross_ref (ax, tpp, type_code, pname, bigend, sym_name)
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;
ecoff_swap_rndx_in (bigend, &ax->a_rndx, rn);
* Find the relative file descriptor and the symbol in it
*/
FDR *fh = get_rfd (cur_fd, rf);
- struct sym_ext *esh;
+ char *esh;
SYMR sh;
struct type *t;
+ if (rn->index >= fh->csym)
+ {
+ /* File indirect entry is corrupt. */
+ *tpp = (struct type *)NULL;
+ *pname = "<illegal>";
+ complain (&bad_rfd_entry_complaint,
+ sym_name, fh - ecoff_data (cur_bfd)->fdr, rn->index);
+ return result;
+ }
+
/* 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 will be. In any event, we collect the name for the
type here. Which is why we made a first pass at strings. */
- esh = ecoff_data (cur_bfd)->external_sym + fh->isymBase + rn->index;
- ecoff_swap_sym_in (cur_bfd, esh, &sh);
+ 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);
/* Careful, we might be looking at .o files */
if (sh.iss == 0)
seems to mean that we don't know. This is said to fix a problem
with "info func opendir" on an SGI showing
"struct BSDopendir.c *BSDopendir();". */
- *pname = "<unknown>";
+ {
+ *tpp = (struct type *)NULL;
+ *pname = "<unknown>";
+ return result;
+ }
+ else if ((sh.st != stBlock && sh.st != stTypedef && sh.st != stParsed)
+ || sh.sc != scInfo)
+ {
+ /* File indirect entry is corrupt. */
+ *tpp = (struct type *)NULL;
+ *pname = "<illegal>";
+ complain (&bad_rfd_entry_complaint,
+ sym_name, fh - ecoff_data (cur_bfd)->fdr, rn->index);
+ return result;
+ }
else
*pname = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss;
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;
}
{
struct symbol *s;
struct symtab *st;
- struct block *b, *b0;
+ struct block *b, *b0 = NULL;
sigtramp_address = -1;
e->pdr.fregmask = -1;
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);