static struct symbol *opaque_type_chain[HASHSIZE];
-/* Record the symbols defined for each context in a list.
- We don't create a struct block for the context until we
- know how long to make it. */
-
-struct coff_pending
-{
- struct coff_pending *next;
- struct symbol *symbol;
-};
-
-/* Here are the three lists that symbols are put on. */
-
-struct coff_pending *coff_file_symbols; /* static at top level, and types */
-
-struct coff_pending *coff_global_symbols; /* global functions and variables */
-
-struct coff_pending *coff_local_symbols; /* everything local to lexical context */
-
-/* List of unclosed lexical contexts
- (that will become blocks, eventually). */
-
-struct coff_context_stack
-{
- struct coff_context_stack *next;
- struct coff_pending *locals;
- struct pending_block *old_blocks;
- struct symbol *name;
- CORE_ADDR start_addr;
- int depth;
-};
-
-struct coff_context_stack *coff_context_stack;
-
-/* Nonzero if within a function (so symbols should be local,
- if nothing says specifically). */
-
-int within_function;
-
#if 0
/* The type of the function we are currently reading in. This is
used by define_symbol to record the type of arguments to a function. */
static struct type *
coff_read_enum_type PARAMS ((int, int, int));
-static struct blockvector *
-make_blockvector PARAMS ((struct objfile *));
-
static struct symbol *
process_coff_symbol PARAMS ((struct coff_symbol *, union internal_auxent *,
struct objfile *));
static void
coff_record_line PARAMS ((int, CORE_ADDR));
-static void
-coff_finish_block PARAMS ((struct symbol *, struct coff_pending **,
- struct pending_block *, CORE_ADDR, CORE_ADDR,
- struct objfile *));
-
-static void
-coff_add_symbol_to_list PARAMS ((struct symbol *, struct coff_pending **));
-
static struct type *
coff_alloc_type PARAMS ((int));
return type;
}
\f
-/* maintain the lists of symbols and blocks */
-
-/* Add a symbol to one of the lists of symbols. */
-static void
-coff_add_symbol_to_list (symbol, listhead)
- struct symbol *symbol;
- struct coff_pending **listhead;
-{
- register struct coff_pending *link
- = (struct coff_pending *) xmalloc (sizeof (struct coff_pending));
-
- link->next = *listhead;
- link->symbol = symbol;
- *listhead = link;
-}
-
-/* Take one of the lists of symbols and make a block from it.
- Put the block on the list of pending blocks. */
-
-static void
-coff_finish_block (symbol, listhead, old_blocks, start, end, objfile)
- struct symbol *symbol;
- struct coff_pending **listhead;
- struct pending_block *old_blocks;
- CORE_ADDR start, end;
- struct objfile *objfile;
-{
- register struct coff_pending *next, *next1;
- register struct block *block;
- register struct pending_block *pblock;
- struct pending_block *opblock;
- register int i;
-
- /* Count the length of the list of symbols. */
-
- for (next = *listhead, i = 0; next; next = next->next, i++);
-
- block = (struct block *)
- obstack_alloc (&objfile->symbol_obstack, sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
-
- /* Copy the symbols into the block. */
-
- BLOCK_NSYMS (block) = i;
- for (next = *listhead; next; next = next->next)
- BLOCK_SYM (block, --i) = next->symbol;
-
- BLOCK_START (block) = start;
- BLOCK_END (block) = end;
- BLOCK_SUPERBLOCK (block) = 0; /* Filled in when containing block is made */
-
- /* Put the block in as the value of the symbol that names it. */
-
- if (symbol)
- {
- SYMBOL_BLOCK_VALUE (symbol) = block;
- BLOCK_FUNCTION (block) = symbol;
- }
- else
- BLOCK_FUNCTION (block) = 0;
-
- /* Now free the links of the list, and empty the list. */
-
- for (next = *listhead; next; next = next1)
- {
- next1 = next->next;
- free ((PTR)next);
- }
- *listhead = 0;
-
- /* Install this block as the superblock
- of all blocks made since the start of this scope
- that don't have superblocks yet. */
-
- opblock = 0;
- for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
- {
- if (BLOCK_SUPERBLOCK (pblock->block) == 0)
- BLOCK_SUPERBLOCK (pblock->block) = block;
- opblock = pblock;
- }
-
- /* Record this block on the list of all blocks in the file.
- Put it after opblock, or at the beginning if opblock is 0.
- This puts the block in the list after all its subblocks. */
-
- pblock = (struct pending_block *) xmalloc (sizeof (struct pending_block));
- pblock->block = block;
- if (opblock)
- {
- pblock->next = opblock->next;
- opblock->next = pblock;
- }
- else
- {
- pblock->next = pending_blocks;
- pending_blocks = pblock;
- }
-}
-
-static struct blockvector *
-make_blockvector (objfile)
- struct objfile *objfile;
-{
- register struct pending_block *next, *next1;
- register struct blockvector *blockvector;
- register int i;
-
- /* Count the length of the list of blocks. */
-
- for (next = pending_blocks, i = 0; next; next = next->next, i++);
-
- blockvector = (struct blockvector *)
- obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
-
- /* Copy the blocks into the blockvector.
- This is done in reverse order, which happens to put
- the blocks into the proper order (ascending starting address).
- coff_finish_block has hair to insert each block into the list
- after its subblocks in order to make sure this is true. */
-
- BLOCKVECTOR_NBLOCKS (blockvector) = i;
- for (next = pending_blocks; next; next = next->next)
- BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
-
- /* Now free the links of the list, and empty the list. */
-
- for (next = pending_blocks; next; next = next1)
- {
- next1 = next->next;
- free ((PTR)next);
- }
- pending_blocks = 0;
-
- return blockvector;
-}
-
/* Manage the vector of line numbers. */
static void
static void
coff_start_symtab ()
{
- coff_file_symbols = 0;
- coff_global_symbols = 0;
- coff_context_stack = 0;
- within_function = 0;
- last_source_file = NULL;
+ start_symtab (
+ /* We fill in the filename later. */
+ "",
+ /* We never know the directory name for COFF. */
+ NULL,
+ /* The start address is irrelevant, since we set
+ last_source_start_addr in coff_end_symtab. */
+ 0);
/* Initialize the source file line number information for this file. */
coff_end_symtab (objfile)
struct objfile *objfile;
{
- register struct symtab *symtab;
- register struct coff_context_stack *cstk;
- register struct blockvector *blockvector;
- register struct linetable *lv;
+ struct symtab *symtab;
- /* Finish the lexical context of the last function in the file. */
+ last_source_start_addr = cur_src_start_addr;
- if (coff_context_stack)
- {
- cstk = coff_context_stack;
- coff_context_stack = 0;
- /* Make a block for the local symbols within. */
- coff_finish_block (cstk->name, &coff_local_symbols, cstk->old_blocks,
- cstk->start_addr, cur_src_end_addr, objfile);
- free ((PTR)cstk);
- }
+ /* For COFF, we only have one subfile, so we can just look at
+ subfiles and not worry about there being other elements in the
+ chain. We fill in various fields now because we didn't know them
+ before (or because doing it now is simply an artifact of how this
+ file used to be written). */
+ subfiles->line_vector = line_vector;
+ subfiles->name = last_source_file;
- /* Ignore a file that has no functions with real debugging info. */
- if (pending_blocks == 0 && coff_file_symbols == 0 && coff_global_symbols == 0)
- {
- free ((PTR)line_vector);
- line_vector = 0;
- line_vector_length = -1;
- last_source_file = NULL;
- return;
- }
+ /* sort_pending is needed for amdcoff, at least.
+ sort_linevec is needed for the SCO compiler. */
+ symtab = end_symtab (cur_src_end_addr, 1, 1, objfile, 0);
- /* It is unfortunate that in amdcoff, pending blocks might not be ordered
- in this stage. Especially, blocks for static functions will show up at
- the end. We need to sort them, so tools like `find_pc_function' and
- `find_pc_block' can work reliably. */
- if (pending_blocks) {
- /* FIXME! Remove this horrid bubble sort and use qsort!!! */
- int swapped;
- do {
- struct pending_block *pb, *pbnext;
-
- pb = pending_blocks, pbnext = pb->next;
- swapped = 0;
-
- while ( pbnext ) {
-
- /* swap blocks if unordered! */
-
- if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) {
- struct block *tmp = pb->block;
- complain (&misordered_blocks_complaint, BLOCK_START (pb->block));
- pb->block = pbnext->block;
- pbnext->block = tmp;
- swapped = 1;
- }
- pb = pbnext;
- pbnext = pbnext->next;
- }
- } while (swapped);
- }
-
- /* Create the two top-level blocks for this file (STATIC_BLOCK and
- GLOBAL_BLOCK). */
- coff_finish_block (0, &coff_file_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
- coff_finish_block (0, &coff_global_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
-
- /* Create the blockvector that points to all the file's blocks. */
- blockvector = make_blockvector (objfile);
-
- /* Now create the symtab object for this source file. */
- symtab = allocate_symtab (last_source_file, objfile);
-
- /* Fill in its components. */
- symtab->blockvector = blockvector;
- symtab->free_code = free_linetable;
- symtab->free_ptr = 0;
- symtab->filename = last_source_file;
- symtab->dirname = NULL;
- lv = line_vector;
- lv->nitems = line_vector_index;
- symtab->linetable = (struct linetable *)
- xrealloc ((char *) lv, (sizeof (struct linetable)
- + lv->nitems * sizeof (struct linetable_entry)));
-
- free_named_symtabs (symtab->filename);
+ if (symtab != NULL)
+ free_named_symtabs (symtab->filename);
/* Reinitialize for beginning of new file. */
line_vector = 0;
struct objfile *objfile;
{
FILE *stream;
- register struct coff_context_stack *new;
+ register struct context_stack *new;
struct coff_symbol coff_symbol;
register struct coff_symbol *cs = &coff_symbol;
static struct internal_syment main_sym;
complain (&bf_no_aux_complaint, cs->c_symnum);
fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
- new = (struct coff_context_stack *)
- xmalloc (sizeof (struct coff_context_stack));
- new->depth = depth = 0;
- new->next = 0;
- coff_context_stack = new;
- new->locals = 0;
- new->old_blocks = pending_blocks;
- new->start_addr = fcn_start_addr;
+ /* Might want to check that locals are 0 and
+ context_stack_depth is zero, and complain if not. */
+
+ depth = 0;
+ new = push_context (depth, fcn_start_addr);
fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
new->name = process_coff_symbol (&fcn_cs_saved,
&fcn_aux_saved, objfile);
}
else if (STREQ (cs->c_name, ".ef"))
{
- /* the value of .ef is the address of epilogue code;
- * not useful for gdb
- */
+ /* the value of .ef is the address of epilogue code;
+ not useful for gdb. */
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
contains number of lines to '}' */
- new = coff_context_stack;
- if (new == 0)
+ new = pop_context ();
+ /* Stack must be empty now. */
+ if (context_stack_depth > 0 || new == NULL)
{
complain (&ef_complaint, cs->c_symnum);
within_function = 0;
break;
}
- if (cs->c_naux != 1) {
- complain (&ef_no_aux_complaint, cs->c_symnum);
- fcn_last_line = 0x7FFFFFFF;
- } else {
- fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
- }
+ if (cs->c_naux != 1)
+ {
+ complain (&ef_no_aux_complaint, cs->c_symnum);
+ fcn_last_line = 0x7FFFFFFF;
+ }
+ else
+ {
+ fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+ }
enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line);
- coff_finish_block (new->name, &coff_local_symbols, new->old_blocks,
+ finish_block (new->name, &local_symbols, new->old_blocks,
new->start_addr,
#if defined (FUNCTION_EPILOGUE_SIZE)
/* This macro should be defined only on
#endif
objfile
);
- coff_context_stack = 0;
within_function = 0;
- free ((PTR)new);
}
break;
case C_BLOCK:
if (STREQ (cs->c_name, ".bb"))
{
- new = (struct coff_context_stack *)
- xmalloc (sizeof (struct coff_context_stack));
- depth++;
- new->depth = depth;
- new->next = coff_context_stack;
- coff_context_stack = new;
- new->locals = coff_local_symbols;
- new->old_blocks = pending_blocks;
- new->start_addr = cs->c_value;
- new->name = 0;
- coff_local_symbols = 0;
+ push_context (++depth, cs->c_value);
}
else if (STREQ (cs->c_name, ".eb"))
{
- new = coff_context_stack;
- if (new == 0 || depth != new->depth)
+ new = pop_context ();
+ if (depth-- != new->depth)
{
complain (&eb_complaint, (char *)symnum);
break;
}
- if (coff_local_symbols && coff_context_stack->next)
+ if (local_symbols && context_stack_depth > 0)
{
/* Make a block for the local symbols within. */
- coff_finish_block (0, &coff_local_symbols, new->old_blocks,
+ finish_block (0, &local_symbols, new->old_blocks,
new->start_addr, cs->c_value, objfile);
}
- depth--;
- coff_local_symbols = new->locals;
- coff_context_stack = new->next;
- free ((PTR)new);
+ /* Now pop locals of block just finished. */
+ local_symbols = new->locals;
}
break;
return 0;
stringtab = (char *) xmalloc (length);
- if (stringtab == NULL)
- return -1;
-
memcpy (stringtab, &length, sizeof length);
if (length == sizeof length) /* Empty table -- just the count */
return 0;
/* Allocate the desired table, plus a sentinel */
linetab = (char *) xmalloc (size + local_linesz);
- if (linetab == NULL)
- return -1;
-
val = myread (chan, linetab, size);
if (val != size)
return -1;
SYMBOL_CLASS (sym) = LOC_BLOCK;
if (cs->c_sclass == C_STAT)
- coff_add_symbol_to_list (sym, &coff_file_symbols);
+ add_symbol_to_list (sym, &file_symbols);
else if (cs->c_sclass == C_EXT)
- coff_add_symbol_to_list (sym, &coff_global_symbols);
+ add_symbol_to_list (sym, &global_symbols);
}
else
{
case C_AUTO:
SYMBOL_CLASS (sym) = LOC_LOCAL;
- coff_add_symbol_to_list (sym, &coff_local_symbols);
+ add_symbol_to_list (sym, &local_symbols);
break;
case C_EXT:
SYMBOL_CLASS (sym) = LOC_STATIC;
SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
- coff_add_symbol_to_list (sym, &coff_global_symbols);
+ add_symbol_to_list (sym, &global_symbols);
break;
case C_STAT:
SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
if (within_function) {
/* Static symbol of local scope */
- coff_add_symbol_to_list (sym, &coff_local_symbols);
+ add_symbol_to_list (sym, &local_symbols);
}
else {
/* Static symbol at top level of file */
- coff_add_symbol_to_list (sym, &coff_file_symbols);
+ add_symbol_to_list (sym, &file_symbols);
}
break;
case C_REG:
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
- coff_add_symbol_to_list (sym, &coff_local_symbols);
+ add_symbol_to_list (sym, &local_symbols);
break;
case C_LABEL:
/* Add parameter to function. */
add_param_to_type(&in_function_type,sym);
#endif
- coff_add_symbol_to_list (sym, &coff_local_symbols);
+ add_symbol_to_list (sym, &local_symbols);
#if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
/* If PCC says a parameter is a short or a char,
aligned on an int boundary, realign it to the "little end"
case C_REGPARM:
SYMBOL_CLASS (sym) = LOC_REGPARM;
SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
- coff_add_symbol_to_list (sym, &coff_local_symbols);
+ add_symbol_to_list (sym, &local_symbols);
#if !defined (BELIEVE_PCC_PROMOTION)
/* FIXME: This should retain the current type, since it's just
a register value. gnu@adobe, 26Feb93 */
SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
opaque_type_chain[i] = sym;
}
- coff_add_symbol_to_list (sym, &coff_file_symbols);
+ add_symbol_to_list (sym, &file_symbols);
break;
case C_STRTAG:
TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
concat (SYMBOL_NAME (sym), NULL);
- coff_add_symbol_to_list (sym, &coff_file_symbols);
+ add_symbol_to_list (sym, &file_symbols);
break;
default:
register struct type *type;
int nsyms = 0;
int done = 0;
- struct coff_pending **symlist;
+ struct pending **symlist;
struct coff_symbol member_sym;
register struct coff_symbol *ms = &member_sym;
struct internal_syment sub_sym;
union internal_auxent sub_aux;
- struct coff_pending *osyms, *syms;
+ struct pending *osyms, *syms;
+ int o_nsyms;
register int n;
char *name;
type = coff_alloc_type (index);
if (within_function)
- symlist = &coff_local_symbols;
+ symlist = &local_symbols;
else
- symlist = &coff_file_symbols;
+ symlist = &file_symbols;
osyms = *symlist;
+ o_nsyms = osyms ? osyms->nsyms : 0;
while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
{
SYMBOL_CLASS (sym) = LOC_CONST;
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_VALUE (sym) = ms->c_value;
- coff_add_symbol_to_list (sym, symlist);
+ add_symbol_to_list (sym, symlist);
nsyms++;
break;
The symbols can be found in the symlist that we put them on
to cause them to be defined. osyms contains the old value
of that symlist; everything up to there was defined by us. */
+ /* Note that we preserve the order of the enum constants, so
+ that in something like "enum {FOO, LAST_THING=FOO}" we print
+ FOO, not LAST_THING. */
- for (syms = *symlist, n = nsyms; syms != osyms; syms = syms->next)
+ for (syms = *symlist, n = 0; syms; syms = syms->next)
{
- SYMBOL_TYPE (syms->symbol) = type;
- TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (syms->symbol);
- TYPE_FIELD_VALUE (type, n) = 0;
- TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (syms->symbol);
- TYPE_FIELD_BITSIZE (type, n) = 0;
+ int j = 0;
+ if (syms == osyms)
+ j = o_nsyms;
+ for (; j < syms->nsyms; j++,n++)
+ {
+ struct symbol *xsym = syms->symbol[j];
+ SYMBOL_TYPE (xsym) = type;
+ TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
+ TYPE_FIELD_VALUE (type, n) = 0;
+ TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+ TYPE_FIELD_BITSIZE (type, n) = 0;
+ }
+ if (syms == osyms)
+ break;
}
+
#if 0
/* This screws up perfectly good C programs with enums. FIXME. */
/* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
projects / binutils-gdb.git / commitdiff