/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2015 Free Software Foundation, Inc.
Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
static struct block *new_block (enum block_type);
-static struct symtab *new_symtab (const char *, int, struct objfile *);
+static struct compunit_symtab *new_symtab (const char *, int, struct objfile *);
static struct linetable *new_linetable (int);
static void
push_parse_stack (void)
{
- struct parse_stack *new;
+ struct parse_stack *newobj;
/* Reuse frames if possible. */
if (top_stack && top_stack->prev)
- new = top_stack->prev;
+ newobj = top_stack->prev;
else
- new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
+ newobj = XCNEW (struct parse_stack);
/* Initialize new frame with previous content. */
if (top_stack)
{
- struct parse_stack *prev = new->prev;
+ struct parse_stack *prev = newobj->prev;
- *new = *top_stack;
- top_stack->prev = new;
- new->prev = prev;
- new->next = top_stack;
+ *newobj = *top_stack;
+ top_stack->prev = newobj;
+ newobj->prev = prev;
+ newobj->next = top_stack;
}
- top_stack = new;
+ top_stack = newobj;
}
/* Exit a lexical context. */
struct type *t;
struct field *f;
int count = 1;
- enum address_class class;
+ enum address_class theclass;
TIR tir;
long svalue = sh->value;
int bitsize;
break;
case stGlobal: /* External symbol, goes into global block. */
- class = LOC_STATIC;
- b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
+ theclass = LOC_STATIC;
+ b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
s = new_symbol (name);
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
goto data;
case stStatic: /* Static data, goes into current block. */
- class = LOC_STATIC;
+ theclass = LOC_STATIC;
b = top_stack->cur_block;
s = new_symbol (name);
if (SC_IS_COMMON (sh->sc))
s = new_symbol (name);
SYMBOL_VALUE (s) = svalue;
if (sh->sc == scRegister)
- class = mdebug_register_index;
+ theclass = mdebug_register_index;
else
- class = LOC_LOCAL;
+ theclass = LOC_LOCAL;
data: /* Common code for symbols describing data. */
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
- SYMBOL_ACLASS_INDEX (s) = class;
+ SYMBOL_ACLASS_INDEX (s) = theclass;
add_symbol (s, top_stack->cur_st, b);
/* Type could be missing if file is compiled without debugging info. */
b = top_stack->cur_block;
if (sh->st == stProc)
{
- const struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
+ const struct blockvector *bv
+ = SYMTAB_BLOCKVECTOR (top_stack->cur_st);
/* The next test should normally be true, but provides a
hook for nested functions (which we don't want to make
top_stack->blocktype == stStaticProc))
{
/* Finished with procedure */
- const struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
+ const struct blockvector *bv
+ = SYMTAB_BLOCKVECTOR (top_stack->cur_st);
struct mdebug_extra_func_info *e;
struct block *b = top_stack->cur_block;
struct type *ftype = top_stack->cur_type;
in question, or NULL to use top_stack->cur_block. */
static void
-parse_procedure (PDR *pr, struct symtab *search_symtab,
+parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
struct partial_symtab *pst)
{
struct symbol *s, *i;
#else
s = mylookup_symbol
(sh_name,
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
+ BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (search_symtab),
+ STATIC_BLOCK),
VAR_DOMAIN,
LOC_BLOCK);
#endif
/* Allocate the map FDR -> PST.
Minor hack: -O3 images might claim some global data belongs
to FDR -1. We`ll go along with that. */
- fdr_to_pst = (struct pst_map *)
- xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
+ fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
old_chain = make_cleanup (xfree, fdr_to_pst);
fdr_to_pst++;
{
hdr->ifdMax * sizeof (struct mdebug_pending *));
/* Pass 0 over external syms: swap them in. */
- ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
+ ext_block = XNEWVEC (EXTR, hdr->iextMax);
make_cleanup (xfree, ext_block);
ext_out = (char *) debug_info->external_ext;
}
else
textlow = 0;
- pst = start_psymtab_common (objfile, objfile->section_offsets,
+ pst = start_psymtab_common (objfile,
fdr_name (fh),
textlow,
objfile->global_psymbols.next,
prev_textlow_not_set = textlow_not_set;
/* A zero value is probably an indication for the
- SunPRO 3.0 compiler. end_psymtab explicitly tests
+ SunPRO 3.0 compiler. dbx_end_psymtab explicitly tests
for zero, so don't relocate it. */
if (sh.value == 0
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
case 'G':
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
add_psymbol_to_list (namestring, p - namestring, 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language,
+ 0, psymtab_language,
objfile);
p += 1;
}
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
check_enum:
/* If this is an enumerated type, we need to add
add_psymbol_to_list (p, q - p, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols,
- 0, 0, psymtab_language,
+ 0, psymtab_language,
objfile);
/* Point past the name. */
p = q;
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols,
- sh.value, 0, psymtab_language,
- objfile);
+ 0, psymtab_language, objfile);
continue;
case 'f':
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
add_psymbol_to_list (namestring, p - namestring, 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, sh.value,
+ sh.value,
psymtab_language, objfile);
continue;
case N_ENDM:
/* Solaris 2 end of module, finish current partial
- symbol table. END_PSYMTAB will set
+ symbol table. dbx_end_psymtab will set
pst->texthigh to the proper value, which is
necessary if a module compiled without
debugging info follows this module. */
for (cur_sdx = 0; cur_sdx < fh->csym;)
{
char *name;
- enum address_class class;
+ enum address_class theclass;
CORE_ADDR minsym_value;
(*swap_sym_in) (cur_bfd,
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
else
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
procaddr = sh.value;
mst_file_bss,
SECT_OFF_BSS (objfile),
objfile);
- class = LOC_STATIC;
+ theclass = LOC_STATIC;
break;
case stIndirect: /* Irix5 forward declaration */
structs from alpha and mips cc. */
if (sh.iss == 0 || has_opaque_xref (fh, &sh))
goto skip;
- class = LOC_TYPEDEF;
+ theclass = LOC_TYPEDEF;
break;
case stConstant: /* Constant decl */
- class = LOC_CONST;
+ theclass = LOC_CONST;
break;
case stUnion:
add_psymbol_to_list (name, strlen (name), 1,
STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0,
- psymtab_language, objfile);
+ 0, psymtab_language, objfile);
}
handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
}
/* Use this gdb symbol. */
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, class,
+ VAR_DOMAIN, theclass,
&objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
+ sh.value, psymtab_language, objfile);
skip:
cur_sdx++; /* Go to next file symbol. */
}
PST_PRIVATE (save_pst)->extern_tab = ext_ptr;
for (; --cur_sdx >= 0; ext_ptr++)
{
- enum address_class class;
+ enum address_class theclass;
SYMR *psh;
char *name;
CORE_ADDR svalue;
Ignore them, as parse_external will ignore them too. */
continue;
case stLabel:
- class = LOC_LABEL;
+ theclass = LOC_LABEL;
break;
default:
unknown_ext_complaint (debug_info->ssext + psh->iss);
if (SC_IS_COMMON (psh->sc))
continue;
- class = LOC_STATIC;
+ theclass = LOC_STATIC;
break;
}
name = debug_info->ssext + psh->iss;
add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, class,
+ VAR_DOMAIN, theclass,
&objfile->global_psymbols,
- 0, svalue,
- psymtab_language, objfile);
+ svalue, psymtab_language, objfile);
}
}
- /* Link pst to FDR. end_psymtab returns NULL if the psymtab was
+ /* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was
empty and put on the free list. */
- fdr_to_pst[f_idx].pst = end_psymtab (objfile, save_pst,
- psymtab_include_list, includes_used,
- -1, save_pst->texthigh,
- dependency_list, dependencies_used, textlow_not_set);
+ fdr_to_pst[f_idx].pst
+ = dbx_end_psymtab (objfile, save_pst,
+ psymtab_include_list, includes_used,
+ -1, save_pst->texthigh,
+ dependency_list, dependencies_used,
+ textlow_not_set);
includes_used = 0;
dependencies_used = 0;
in psymtabs, just in symtabs. */
add_psymbol_to_list (name, strlen (name), 1,
VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols, 0,
- (CORE_ADDR) 0, psymtab_language, objfile);
+ &objfile->static_psymbols,
+ 0, psymtab_language, objfile);
ext_sym += external_sym_size;
}
}
void (*swap_sym_in) (bfd *, void *, SYMR *);
void (*swap_pdr_in) (bfd *, void *, PDR *);
int i;
- struct symtab *st = NULL;
+ struct compunit_symtab *cust = NULL;
FDR *fh;
struct linetable *lines;
CORE_ADDR lowest_pdr_addr = 0;
int last_symtab_ended = 0;
+ struct section_offsets *section_offsets = objfile->section_offsets;
if (pst->readin)
return;
&& previous_stab_code != (unsigned char) N_SO
&& *name == '\000')
{
- valu += ANOFFSET (pst->section_offsets,
+ valu += ANOFFSET (section_offsets,
SECT_OFF_TEXT (objfile));
previous_stab_code = N_SO;
- st = end_symtab (valu, objfile,
- SECT_OFF_TEXT (objfile));
+ cust = end_symtab (valu, SECT_OFF_TEXT (objfile));
end_stabs ();
last_symtab_ended = 1;
}
{
last_symtab_ended = 0;
process_one_symbol (type_code, 0, valu, name,
- pst->section_offsets, objfile);
+ section_offsets, objfile);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- pst->section_offsets, objfile);
+ section_offsets, objfile);
}
if (type_code == N_FUN)
{
else
{
/* Handle encoded stab line number. */
- valu += ANOFFSET (pst->section_offsets,
+ valu += ANOFFSET (section_offsets,
SECT_OFF_TEXT (objfile));
record_line (current_subfile, sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
if (! last_symtab_ended)
{
- st = end_symtab (pst->texthigh, objfile,
- SECT_OFF_TEXT (objfile));
+ cust = end_symtab (pst->texthigh, SECT_OFF_TEXT (objfile));
end_stabs ();
}
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
pdr_ptr = ((char *) debug_info->external_pdr
pdr_in = pr_block;
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, st, pst);
+ parse_procedure (pdr_in, cust, pst);
do_cleanups (old_chain);
}
if (fh == 0)
{
maxlines = 0;
- st = new_symtab ("unknown", 0, objfile);
+ cust = new_symtab ("unknown", 0, objfile);
}
else
{
maxlines = 2 * fh->cline;
- st = new_symtab (pst->filename, maxlines, objfile);
+ cust = new_symtab (pst->filename, maxlines, objfile);
/* The proper language was already determined when building
the psymtab, use it. */
- st->language = PST_PRIVATE (pst)->pst_language;
+ COMPUNIT_FILETABS (cust)->language = PST_PRIVATE (pst)->pst_language;
}
- psymtab_language = st->language;
+ psymtab_language = COMPUNIT_FILETABS (cust)->language;
- lines = LINETABLE (st);
+ lines = SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust));
/* Get a new lexical context. */
push_parse_stack ();
- top_stack->cur_st = st;
- top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st),
- STATIC_BLOCK);
+ top_stack->cur_st = COMPUNIT_FILETABS (cust);
+ top_stack->cur_block
+ = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
BLOCK_START (top_stack->cur_block) = pst->textlow;
BLOCK_END (top_stack->cur_block) = 0;
top_stack->blocktype = stFile;
c = parse_symbol (&sh,
debug_info->external_aux + fh->iauxBase,
sym_ptr, fh->fBigendian,
- pst->section_offsets, objfile);
+ section_offsets, objfile);
sym_ptr += c * external_sym_size;
}
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
pdr_in = pr_block;
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
- parse_procedure (pdr_in, 0, pst);
+ parse_procedure (pdr_in, NULL, pst);
do_cleanups (old_chain);
}
size = lines->nitems;
if (size > 1)
--size;
- LINETABLE (st) = obstack_copy (&mdebugread_objfile->objfile_obstack,
- lines,
- (sizeof (struct linetable)
- + size * sizeof (lines->item)));
+ SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
+ = obstack_copy (&mdebugread_objfile->objfile_obstack,
+ lines,
+ (sizeof (struct linetable)
+ + size * sizeof (lines->item)));
xfree (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? */
- top_stack->cur_st = st;
+ top_stack->cur_st = COMPUNIT_FILETABS (cust);
top_stack->cur_block
- = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
+ = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
top_stack->blocktype = stFile;
ext_ptr = PST_PRIVATE (pst)->extern_tab;
for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
parse_external (ext_ptr, fh->fBigendian,
- pst->section_offsets, objfile);
+ section_offsets, objfile);
/* If there are undefined symbols, tell the user.
The alpha has an undefined symbol for every symbol that is
if (info_verbose && n_undef_symbols)
{
printf_filtered (_("File %s contains %d unresolved references:"),
- symtab_to_filename_for_display (st),
+ symtab_to_filename_for_display
+ (COMPUNIT_FILETABS (cust)),
n_undef_symbols);
printf_filtered ("\n\t%4d variables\n\t%4d "
"procedures\n\t%4d labels\n",
}
pop_parse_stack ();
- set_symtab_primary (st, 1);
-
- sort_blocks (st);
+ sort_blocks (COMPUNIT_FILETABS (cust));
}
/* Now link the psymtab and the symtab. */
- pst->symtab = st;
+ pst->compunit_symtab = cust;
mdebugread_objfile = NULL;
}
int xref_fd;
struct mdebug_pending *pend;
- *tpp = (struct type *) NULL;
+ *tpp = NULL;
(*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn);
static struct symbol *
mylookup_symbol (char *name, const struct block *block,
- domain_enum domain, enum address_class class)
+ domain_enum domain, enum address_class theclass)
{
struct block_iterator iter;
int inc;
{
if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
&& SYMBOL_DOMAIN (sym) == domain
- && SYMBOL_CLASS (sym) == class
+ && SYMBOL_CLASS (sym) == theclass
&& strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
return sym;
}
block = BLOCK_SUPERBLOCK (block);
if (block)
- return mylookup_symbol (name, block, domain, class);
+ return mylookup_symbol (name, block, domain, theclass);
return 0;
}
static void
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
- SYMBOL_SYMTAB (s) = symtab;
+ symbol_set_symtab (s, symtab);
dict_add_symbol (BLOCK_DICT (b), s);
}
{
/* Cast away "const", but that's ok because we're building the
symtab and blockvector here. */
- struct blockvector *bv = (struct blockvector *) BLOCKVECTOR (s);
+ struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
bv = (struct blockvector *) xrealloc ((void *) bv,
(sizeof (struct blockvector)
+ BLOCKVECTOR_NBLOCKS (bv)
* sizeof (bv->block)));
- if (bv != BLOCKVECTOR (s))
- BLOCKVECTOR (s) = bv;
+ if (bv != SYMTAB_BLOCKVECTOR (s))
+ SYMTAB_BLOCKVECTOR (s) = bv;
BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b;
}
{
/* We have to cast away const here, but this is ok because we're
constructing the blockvector in this code. */
- struct blockvector *bv = (struct blockvector *) BLOCKVECTOR (s);
+ struct blockvector *bv = (struct blockvector *) SYMTAB_BLOCKVECTOR (s);
if (BLOCKVECTOR_NBLOCKS (bv) <= FIRST_LOCAL_BLOCK)
{
/* Allocate a new symtab for NAME. Needs an estimate of how many
linenumbers MAXLINES we'll put in it. */
-static struct symtab *
+static struct compunit_symtab *
new_symtab (const char *name, int maxlines, struct objfile *objfile)
{
- struct symtab *s = allocate_symtab (name, objfile);
+ struct compunit_symtab *cust = allocate_compunit_symtab (objfile, name);
+ struct symtab *symtab;
struct blockvector *bv;
- LINETABLE (s) = new_linetable (maxlines);
+ add_compunit_symtab_to_objfile (cust);
+ symtab = allocate_symtab (cust, name);
+
+ SYMTAB_LINETABLE (symtab) = new_linetable (maxlines);
/* All symtabs must have at least two blocks. */
bv = new_bvect (2);
BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK);
BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- BLOCKVECTOR (s) = bv;
+ COMPUNIT_BLOCKVECTOR (cust) = bv;
- s->debugformat = "ECOFF";
- return (s);
+ COMPUNIT_DEBUGFORMAT (cust) = "ECOFF";
+ return cust;
}
/* Allocate a new partial_symtab NAME. */
struct partial_symtab *psymtab;
psymtab = allocate_psymtab (name, objfile);
- psymtab->section_offsets = objfile->section_offsets;
/* Keep a backpointer to the file's symbols. */
/* FIXME: carlton/2003-09-11: This should use allocate_block to
allocate the block. Which, in turn, suggests that the block
should be allocated on an obstack. */
- struct block *retval = xzalloc (sizeof (struct block));
+ struct block *retval = XCNEW (struct block);
if (type == FUNCTION_BLOCK)
BLOCK_DICT (retval) = dict_create_linear_expandable ();