riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

* config/vax/tm-vax.h (BELIEVE_PCC_PROMOTION): Define. 

* mipsread.c (parse_symbol, parse_type, cross_ref):  Handle corrupt
	file indirect entries with complaints instead of core dumps. Remove
	complaint for stTypedef within aggregates.
gdb-4_18-branch
Peter Schauer 33 years ago
parent
486c47b94f
commit
6ac14d259e
2 changed files with 343 additions and 176 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      gdb/ChangeLog
  2. 512
      gdb/mipsread.c

7
gdb/ChangeLog
View File

@ -1,3 +1,10 @@
Thu Aug 19 22:08:09 1993 Peter Schauer (pes@regent.e-technik.tu-muenchen.de)
* config/vax/tm-vax.h (BELIEVE_PCC_PROMOTION): Define.
* mipsread.c (parse_symbol, parse_type, cross_ref): Handle corrupt
file indirect entries with complaints instead of core dumps. Remove
complaint for stTypedef within aggregates.
Thu Aug 19 17:58:39 1993 Jim Kingdon (kingdon@lioth.cygnus.com)
* coffread.c (process_coff_symbol): Ignore tagnames like .0fake.

512
gdb/mipsread.c
View File

@ -89,8 +89,7 @@ typedef struct mips_extra_func_info {
#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. */
@ -195,6 +194,15 @@ struct complaint pdr_static_symbol_complaint =
struct complaint bad_setjmp_pdr_complaint =
{"fixing bad setjmp PDR from libc", 0, 0};
struct complaint bad_fbitfield_complaint =
{"can't handle TIR fBitfield", 0, 0};
struct complaint bad_rfd_entry_complaint =
{"bad rfd entry for 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 */
@ -367,8 +375,10 @@ mipscoff_symfile_read (objfile, section_offsets, mainline)
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. */
@ -379,6 +389,8 @@ mipscoff_symfile_read (objfile, section_offsets, mainline)
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
@ -480,9 +492,11 @@ get_rfd (cf, rf)
/* 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;
}
@ -606,7 +620,7 @@ pop_parse_stack ()
static 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;
@ -616,7 +630,7 @@ static struct mips_pending
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;
@ -633,7 +647,7 @@ is_pending_symbol (fh, sh)
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;
@ -691,9 +705,13 @@ static int
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;
@ -704,7 +722,7 @@ parse_symbol (sh, ax, ext_sh, bigend)
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;
@ -817,14 +835,8 @@ parse_symbol (sh, ax, ext_sh, bigend)
add_symbol (s, top_stack->cur_block);
break;
case stStaticProc:
/* 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: /* Procedure, usually goes into global block */
case stStaticProc: /* Static procedure, goes into current block */
s = new_symbol (name);
SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
SYMBOL_CLASS (s) = LOC_BLOCK;
@ -877,13 +889,14 @@ parse_symbol (sh, ax, ext_sh, bigend)
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;
@ -922,11 +935,13 @@ parse_symbol (sh, ax, ext_sh, bigend)
/* 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);
(*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
switch (tsym.st)
{
@ -954,20 +969,6 @@ parse_symbol (sh, ax, ext_sh, bigend)
max_value = tsym.value;
break;
#if 0
/* This does not fix the bug which it intended to fix,
and makes GDB hang when reading its own symbol table on
the SGI, when compiled with the SGI compiler. */
case stTypedef:
case stConstant:
case stStaticProc:
complain (&block_member_complaint, tsym.st);
/* These are said to show up in cfront-generated programs.
Apparently processing them like the following prevents
core dumps. */
/* FALLTHROUGH */
#endif
case stBlock:
case stUnion:
case stEnum:
@ -985,14 +986,20 @@ parse_symbol (sh, ax, ext_sh, bigend)
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);
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);
}
@ -1053,16 +1060,24 @@ parse_symbol (sh, ax, ext_sh, bigend)
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;
@ -1096,6 +1111,7 @@ parse_symbol (sh, ax, ext_sh, bigend)
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
@ -1197,6 +1213,44 @@ parse_symbol (sh, ax, ext_sh, bigend)
add_symbol (s, top_stack->cur_block);
SYMBOL_TYPE (s) = parse_type (ax + sh->index, 0, bigend);
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 */
@ -1216,8 +1270,6 @@ parse_symbol (sh, ax, ext_sh, bigend)
break;
}
sh->st = stParsed;
return count;
}
@ -1268,7 +1320,6 @@ parse_type (ax, bs, bigend)
TIR t[1];
struct type *tp = 0;
char *fmt;
union aux_ext *tax;
enum type_code type_code = TYPE_CODE_UNDEF;
@ -1333,6 +1384,13 @@ parse_type (ax, bs, bigend)
if (t->fBitfield)
{
/* Inhibit core dumps with some cfront generated objects that
corrupt the TIR. */
if (bs == (int *)NULL)
{
complain (&bad_fbitfield_complaint, t->bt);
return builtin_type_int;
}
*bs = AUX_GET_WIDTH (bigend, ax);
ax++;
}
@ -1357,25 +1415,41 @@ parse_type (ax, bs, bigend)
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, 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, 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),
&current_objfile->type_obstack);
}
/* Do not set the tag name if it is a compiler generated tag name
(.Fxx or .xxfake) for unnamed struct/union/enums. */
if (name[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),
&current_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)
{
@ -1388,16 +1462,26 @@ parse_type (ax, bs, bigend)
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 (&unexpected_type_code_complaint, name);
}
else
{
complain (&bad_tag_guess_complaint, name);
TYPE_CODE (tp) = type_code;
/* 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, name);
TYPE_CODE (tp) = type_code;
}
if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
TYPE_NAME (tp) = obsavestring (name, strlen (name),
&current_objfile->type_obstack);
}
if (TYPE_NAME (tp) == NULL || !STREQ (TYPE_NAME (tp), name))
TYPE_NAME (tp) = obsavestring (name, strlen (name),
&current_objfile->type_obstack);
}
/* Deal with range types */
@ -1580,9 +1664,11 @@ parse_procedure (pr, search_symtab, first_off)
/* 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;
}
}
@ -1591,11 +1677,12 @@ parse_procedure (pr, search_symtab, first_off)
/* 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;
}
@ -1752,7 +1839,7 @@ parse_external (es, skip_procedures, bigend)
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:
@ -1840,12 +1927,22 @@ parse_partial_symbols (objfile, section_offsets)
struct objfile *objfile;
struct section_offsets *section_offsets;
{
const struct ecoff_backend_data * const backend = ecoff_backend (cur_bfd);
const bfd_size_type external_sym_size = backend->external_sym_size;
const bfd_size_type external_rfd_size = backend->external_rfd_size;
const bfd_size_type external_ext_size = backend->external_ext_size;
void (* const swap_ext_in) PARAMS ((bfd *, PTR, EXTR *))
= backend->swap_ext_in;
void (* const swap_sym_in) PARAMS ((bfd *, PTR, SYMR *))
= backend->swap_sym_in;
void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
= backend->swap_rfd_in;
int f_idx, s_idx;
HDRR *hdr = &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;
@ -1911,11 +2008,11 @@ parse_partial_symbols (objfile, section_offsets)
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;
@ -1951,9 +2048,24 @@ parse_partial_symbols (objfile, section_offsets)
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;
@ -2009,11 +2121,10 @@ parse_partial_symbols (objfile, section_offsets)
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;
@ -2026,13 +2137,12 @@ parse_partial_symbols (objfile, section_offsets)
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)
{
@ -2044,12 +2154,12 @@ parse_partial_symbols (objfile, section_offsets)
(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;
@ -2078,20 +2188,22 @@ parse_partial_symbols (objfile, section_offsets)
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++;
@ -2106,8 +2218,14 @@ parse_partial_symbols (objfile, section_offsets)
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,
@ -2135,12 +2253,11 @@ parse_partial_symbols (objfile, section_offsets)
}
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;
@ -2149,6 +2266,10 @@ parse_partial_symbols (objfile, section_offsets)
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;
@ -2218,7 +2339,6 @@ parse_partial_symbols (objfile, section_offsets)
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;
@ -2279,11 +2399,10 @@ parse_partial_symbols (objfile, section_offsets)
{
RFDT rh;
ecoff_swap_rfd_in (cur_bfd,
(ecoff_data (cur_bfd)->external_rfd
+ fh->rfdBase
+ s_id0),
&rh);
(*swap_rfd_in) (cur_bfd,
((char *) ecoff_data (cur_bfd)->external_rfd
+ (fh->rfdBase + s_id0) * external_rfd_size),
&rh);
if (rh == f_idx)
{
s_id0++; /* Skip self-dependency */
@ -2301,11 +2420,10 @@ parse_partial_symbols (objfile, section_offsets)
{
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
@ -2328,6 +2446,10 @@ parse_fdr (f_idx, lev, objfile)
int lev;
struct objfile *objfile;
{
const bfd_size_type external_rfd_size
= ecoff_backend (cur_bfd)->external_rfd_size;
void (* const swap_rfd_in) PARAMS ((bfd *, PTR, RFDT *))
= ecoff_backend (cur_bfd)->swap_rfd_in;
register FDR *fh;
register struct partial_symtab *pst;
int s_idx, s_id0;
@ -2372,11 +2494,10 @@ parse_fdr (f_idx, lev, objfile)
{
RFDT rh;
ecoff_swap_rfd_in (cur_bfd,
(ecoff_data (cur_bfd)->external_rfd
+ fh->rfdBase
+ s_id0),
&rh);
(*swap_rfd_in) (cur_bfd,
((char *) ecoff_data (cur_bfd)->external_rfd
+ (fh->rfdBase + s_id0) * external_rfd_size),
&rh);
if (rh == f_idx)
{
s_id0++; /* Skip self-dependency */
@ -2393,11 +2514,10 @@ parse_fdr (f_idx, lev, objfile)
{
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);
pst->dependencies[s_idx - s_id0] = parse_fdr (rh, lev + 1, objfile);
}
@ -2412,11 +2532,12 @@ 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;
}
@ -2435,6 +2556,16 @@ psymtab_to_symtab_1 (pst, filename)
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;
@ -2488,11 +2619,10 @@ psymtab_to_symtab_1 (pst, filename)
{
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))
{
@ -2504,8 +2634,8 @@ psymtab_to_symtab_1 (pst, filename)
if (processing_gcc_compilation != 0)
{
struct pdr_ext *pdr_ptr;
struct pdr_ext *pdr_end;
char *pdr_ptr;
char *pdr_end;
int first_pdr;
unsigned long first_off;
@ -2524,16 +2654,15 @@ psymtab_to_symtab_1 (pst, filename)
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)
@ -2575,13 +2704,14 @@ psymtab_to_symtab_1 (pst, filename)
/* 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;
@ -2641,26 +2771,27 @@ psymtab_to_symtab_1 (pst, filename)
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.
@ -2670,8 +2801,8 @@ psymtab_to_symtab_1 (pst, filename)
{
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;
@ -2679,11 +2810,14 @@ psymtab_to_symtab_1 (pst, filename)
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)
@ -2756,7 +2890,7 @@ cross_ref (ax, tpp, type_code, pname, bigend)
int bigend;
{
RNDXR rn[1];
unsigned rf;
unsigned int rf;
int result = 1;
ecoff_swap_rndx_in (bigend, &ax->a_rndx, rn);
@ -2783,18 +2917,30 @@ cross_ref (ax, tpp, type_code, pname, bigend)
* 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,
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)
@ -2805,7 +2951,21 @@ cross_ref (ax, tpp, type_code, pname, bigend)
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,
fh - ecoff_data (cur_bfd)->fdr, rn->index);
return result;
}
else
*pname = ecoff_data (cur_bfd)->ss + fh->issBase + sh.iss;

Write Preview
Loading…
Cancel
Save