/* Read coff symbol tables and convert to internal format, for GDB.
Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
- Copyright 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+ Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1993
+ Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-\f
+
#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include <string.h>
+#include <time.h> /* For time_t in libbfd.h. */
+#include "libbfd.h" /* FIXME secret internal data from BFD */
#include "coff/internal.h" /* Internal format of COFF symbols in BFD */
#include "libcoff.h" /* FIXME secret internal data from BFD */
+/* Translate an external name string into a user-visible name. */
+#define EXTERNAL_NAME(string, abfd) \
+ (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string)
+
/* To be an sdb debug type, type must have at least a basic or primary
derived type. Using this rather than checking against T_NULL is
said to prevent core dumps if we try to operate on Michael Bloom
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. */
struct complaint tagndx_bad_complaint =
{"Symbol table entry for %s has bad tagndx value", 0, 0};
+struct complaint eb_complaint =
+ {"Mismatched .eb symbol ignored starting at symnum %d", 0, 0};
+
/* Simplified internal version of coff symbol table information */
struct coff_symbol {
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
enter_linenos PARAMS ((long, int, int));
+static void
+free_linetab PARAMS ((void));
+
static int
init_lineno PARAMS ((int, long, int));
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));
int old_vector_length = type_vector_length;
type_vector_length *= 2;
- if (type_vector_length < index) {
+ if (index /* is still */ >= type_vector_length) {
type_vector_length = index * 2;
}
type_vector = (struct type **)
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. */
+/* Manage the vector of line numbers. FIXME: Use record_line instead. */
static void
coff_record_line (line, pc)
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. start_symtab
+ puts this pointer into last_source file and in
+ coff_end_symtab we assume we can free() it.
+ FIXME: leaks memory. */
+ savestring ("", 0),
+ /* 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 no good reason, this file stores the number of entries in a
+ separate variable instead of in line_vector->nitems. Fix it. */
+ if (line_vector)
+ line_vector->nitems = line_vector_index;
- /* 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;
- }
+ /* 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;
- /* 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);
+ /* 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);
+
+ if (symtab != NULL)
+ free_named_symtabs (symtab->filename);
/* Reinitialize for beginning of new file. */
line_vector = 0;
/* We don't want TDESC entry points in the minimal symbol table */
if (name[0] == '@') return;
- /* mst_text isn't true, but apparently COFF doesn't tell us what it really
- is, so this guess is more useful than mst_unknown. */
- prim_record_minimal_symbol (savestring (name, strlen (name)),
- address,
- type);
+ prim_record_minimal_symbol (savestring (name, strlen (name)), address, type);
}
\f
/* coff_symfile_init ()
int num_symbols;
int symtab_offset;
int stringtab_offset;
+ struct cleanup *back_to;
info = (struct coff_symfile_info *) objfile -> sym_private;
symfile_bfd = abfd; /* Kludge for swap routines */
temp_sym = (char *) xmalloc
(cdata->local_symesz + cdata->local_auxesz);
temp_aux = temp_sym + cdata->local_symesz;
- make_cleanup (free_current_contents, &temp_sym);
+ back_to = make_cleanup (free_current_contents, &temp_sym);
/* End of warning */
/* Read the line number table, all at once. */
info->max_lineno_offset = 0;
bfd_map_over_sections (abfd, find_linenos, (PTR)info);
+ make_cleanup (free_linetab, 0);
val = init_lineno (desc, info->min_lineno_offset,
info->max_lineno_offset - info->min_lineno_offset);
if (val < 0)
/* Now read the string table, all at once. */
+ make_cleanup (free_stringtab, 0);
val = init_stringtab (desc, stringtab_offset);
if (val < 0)
error ("\"%s\": can't get string table", name);
- make_cleanup (free_stringtab, 0);
init_minimal_symbol_collection ();
make_cleanup (discard_minimal_symbols, 0);
minimal symbols for this objfile. */
install_minimal_symbols (objfile);
+
+ do_cleanups (back_to);
}
static void
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;
int fcn_last_line = 0;
int fcn_start_addr = 0;
long fcn_line_ptr = 0;
- struct cleanup *old_chain;
int val;
- stream = fopen (objfile->name, FOPEN_RB);
+ stream = bfd_cache_lookup(objfile->obfd);
if (!stream)
perror_with_name(objfile->name);
+ /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
+ it's hard to know I've really worked around it. The fix should be
+ harmless, anyway). The symptom of the bug is that the first
+ fread (in read_one_sym), will (in my example) actually get data
+ from file offset 268, when the fseek was to 264 (and ftell shows
+ 264). This causes all hell to break loose. I was unable to
+ reproduce this on a short test program which operated on the same
+ file, performing (I think) the same sequence of operations.
+
+ It stopped happening when I put in this rewind().
+
+ FIXME: Find out if this has been reported to Sun, whether it has
+ been fixed in a later release, etc. */
+
+ rewind (stream);
+
/* Position to read the symbol table. */
val = fseek (stream, (long)symtab_offset, 0);
if (val < 0)
perror_with_name (objfile->name);
- /* These cleanups will be discarded below if we succeed. */
- old_chain = make_cleanup (free_objfile, objfile);
- make_cleanup (fclose, stream);
-
current_objfile = objfile;
nlist_stream_global = stream;
nlist_nsyms_global = nsyms;
/* Typedefs should not be treated as symbol definitions. */
if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
{
- /* record as a minimal symbol. if we get '.bf' next,
- * then we undo this step
- */
+ /* Record all functions -- external and static -- in minsyms. */
record_minimal_symbol (cs->c_name, cs->c_value, mst_text);
fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
case C_STAT:
if (cs->c_name[0] == '.') {
- if (strcmp (cs->c_name, ".text") == 0) {
+ if (STREQ (cs->c_name, ".text")) {
/* FIXME: don't wire in ".text" as section name
or symbol name! */
if (++num_object_files == 1) {
break;
/* fall in for static symbols that don't start with '.' */
case C_EXT:
+ /* Record external symbols in minsyms if we don't have debug
+ info for them. FIXME, this is probably the wrong thing
+ to do. Why don't we record them even if we do have
+ debug symbol info? What really belongs in the minsyms
+ anyway? Fred!?? */
if (!SDB_TYPE (cs->c_type)) {
/* FIXME: This is BOGUS Will Robinson!
Coff should provide the SEC_CODE flag for executable sections,
break;
case C_FCN:
- if (strcmp (cs->c_name, ".bf") == 0)
+ if (STREQ (cs->c_name, ".bf"))
{
within_function = 1;
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 (strcmp (cs->c_name, ".ef") == 0)
+ 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 (strcmp (cs->c_name, ".bb") == 0)
+ 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 (strcmp (cs->c_name, ".eb") == 0)
+ else if (STREQ (cs->c_name, ".eb"))
{
- new = coff_context_stack;
- if (new == 0 || depth != new->depth)
- error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
- symnum);
- if (coff_local_symbols && coff_context_stack->next)
+ new = pop_context ();
+ if (depth-- != new->depth)
+ {
+ complain (&eb_complaint, (char *)symnum);
+ break;
+ }
+ 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;
if (last_source_file)
coff_end_symtab (objfile);
- fclose (stream);
/* Patch up any opaque types (references to types that are not defined
in the file where they are referenced, e.g. "struct foo *bar"). */
ALL_OBJFILE_SYMTABS (objfile, s)
patch_opaque_types (s);
- discard_cleanups (old_chain);
current_objfile = NULL;
}
\f
int val;
unsigned char lengthbuf[4];
- if (stringtab)
- {
- free (stringtab);
- stringtab = NULL;
- }
+ free_stringtab ();
if (lseek (chan, offset, 0) < 0)
return -1;
/* If no string table is needed, then the file may end immediately
after the symbols. Just return with `stringtab' set to null. */
- if (val != sizeof length || length < sizeof length)
+ if (val != sizeof lengthbuf || length < sizeof lengthbuf)
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;
- val = myread (chan, stringtab + sizeof length, length - sizeof length);
- if (val != length - sizeof length || stringtab[length - 1] != '\0')
+ val = myread (chan, stringtab + sizeof lengthbuf, length - sizeof lengthbuf);
+ if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
return -1;
return 0;
return result;
}
+/* Extract the file name from the aux entry of a C_FILE symbol. Return
+ only the last component of the name. Result is in static storage and
+ is only good for temporary use. */
+
static char *
getfilename (aux_entry)
union internal_auxent *aux_entry;
register char *temp;
char *result;
-#ifndef COFF_NO_LONG_FILE_NAMES
-#if defined (x_zeroes)
- /* Data General. */
- if (aux_entry->x_zeroes == 0)
- strcpy (buffer, stringtab + aux_entry->x_offset);
-#else /* no x_zeroes */
if (aux_entry->x_file.x_n.x_zeroes == 0)
strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
-#endif /* no x_zeroes */
else
-#endif /* COFF_NO_LONG_FILE_NAMES */
{
-#if defined (x_name)
- /* Data General. */
- strncpy (buffer, aux_entry->x_name, FILNMLEN);
-#else
strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
-#endif
buffer[FILNMLEN] = '\0';
}
result = buffer;
linetab_offset = offset;
linetab_size = size;
+ free_linetab();
+
if (size == 0)
return 0;
/* Terminate it with an all-zero sentinel record */
memset (linetab + size, 0, local_linesz);
- make_cleanup (free, linetab); /* Be sure it gets de-allocated. */
return 0;
}
+static void
+free_linetab ()
+{
+ if (linetab)
+ free (linetab);
+ linetab = NULL;
+}
+
#if !defined (L_LNNO32)
#define L_LNNO32(lp) ((lp)->l_lnno)
#endif
for (sym = opaque_type_chain[hash]; sym;)
{
if (name[0] == SYMBOL_NAME (sym)[0] &&
- !strcmp (name + 1, SYMBOL_NAME (sym) + 1))
+ STREQ (name + 1, SYMBOL_NAME (sym) + 1))
{
if (prev)
{
struct objfile *objfile;
{
register struct symbol *sym
- = (struct symbol *) obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
+ = (struct symbol *) obstack_alloc (&objfile->symbol_obstack,
+ sizeof (struct symbol));
char *name;
-#ifdef NAMES_HAVE_UNDERSCORE
- int offset = 1;
-#else
- int offset = 0;
-#endif
struct type *temptype;
memset (sym, 0, sizeof (struct symbol));
name = cs->c_name;
- name = (name[0] == '_' ? name + offset : name);
- SYMBOL_NAME (sym) = obstack_copy0 (&objfile->symbol_obstack, name, strlen (name));
+ name = EXTERNAL_NAME (name, objfile->obfd);
+ SYMBOL_NAME (sym) = obstack_copy0 (&objfile->symbol_obstack, name,
+ strlen (name));
/* default assumptions */
SYMBOL_VALUE (sym) = cs->c_value;
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);
-#if !defined (BELIEVE_PCC_PROMOTION)
+ 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,
- it is really an int. */
+ aligned on an int boundary, realign it to the "little end"
+ of the int. */
temptype = lookup_fundamental_type (current_objfile, FT_INTEGER);
if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (temptype)
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
+ && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
+ && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (temptype))
{
- SYMBOL_TYPE (sym) = TYPE_UNSIGNED (SYMBOL_TYPE (sym))
- ? lookup_fundamental_type (current_objfile,
- FT_UNSIGNED_INTEGER)
- : temptype;
+ SYMBOL_VALUE (sym) += TYPE_LENGTH (temptype)
+ - TYPE_LENGTH (SYMBOL_TYPE (sym));
}
#endif
break;
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 */
/* If PCC says a parameter is a short or a char,
it is really an int. */
temptype = lookup_fundamental_type (current_objfile, FT_INTEGER);
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:
case C_ENTAG:
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- TYPE_NAME (SYMBOL_TYPE (sym))
- = concat ("",
- (cs->c_sclass == C_ENTAG
- ? "enum "
- : (cs->c_sclass == C_STRTAG
- ? "struct " : "union ")),
- SYMBOL_NAME (sym), NULL);
- coff_add_symbol_to_list (sym, &coff_file_symbols);
+
+ /* Some compilers try to be helpful by inventing "fake"
+ names for anonymous enums, structures, and unions, like
+ "~0fake" or ".0fake". Thanks, but no thanks... */
+ if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
+ if (SYMBOL_NAME(sym) != NULL
+ && *SYMBOL_NAME(sym) != '~'
+ && *SYMBOL_NAME(sym) != '.')
+ TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
+ concat (SYMBOL_NAME (sym), NULL);
+
+ add_symbol_to_list (sym, &file_symbols);
break;
default:
{
int i, n;
register unsigned short *dim;
- struct type *base_type, *index_type;
+ struct type *base_type, *index_type, *range_type;
/* Define an array type. */
/* auxent refers to array, not base type */
base_type = decode_type (cs, new_c_type, aux);
index_type = lookup_fundamental_type (current_objfile, FT_INTEGER);
- type = create_array_type ((struct type *) NULL, base_type,
- index_type, 0, n - 1);
+ range_type =
+ create_range_type ((struct type *) NULL, index_type, 0, n - 1);
+ type =
+ create_array_type ((struct type *) NULL, base_type, range_type);
}
return type;
}
/* anonymous structure type */
type = coff_alloc_type (cs->c_symnum);
TYPE_CODE (type) = TYPE_CODE_STRUCT;
- TYPE_NAME (type) = concat ("struct ", "<opaque>", NULL);
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "struct {...}". */
+ TYPE_TAG_NAME (type) = NULL;
INIT_CPLUS_SPECIFIC(type);
TYPE_LENGTH (type) = 0;
TYPE_FIELDS (type) = 0;
{
/* anonymous union type */
type = coff_alloc_type (cs->c_symnum);
- TYPE_NAME (type) = concat ("union ", "<opaque>", NULL);
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "union {...}". */
+ TYPE_TAG_NAME (type) = NULL;
INIT_CPLUS_SPECIFIC(type);
TYPE_LENGTH (type) = 0;
- TYPE_LENGTH (type) = 0;
TYPE_FIELDS (type) = 0;
TYPE_NFIELDS (type) = 0;
}
return type;
case T_ENUM:
- return coff_read_enum_type (cs->c_symnum,
- aux->x_sym.x_misc.x_lnsz.x_size,
- aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ if (cs->c_naux != 1)
+ {
+ /* anonymous enum type */
+ type = coff_alloc_type (cs->c_symnum);
+ TYPE_CODE (type) = TYPE_CODE_ENUM;
+ TYPE_NAME (type) = NULL;
+ /* This used to set the tag to "<opaque>". But I think setting it
+ to NULL is right, and the printing code can print it as
+ "enum {...}". */
+ TYPE_TAG_NAME (type) = NULL;
+ TYPE_LENGTH (type) = 0;
+ TYPE_FIELDS (type) = 0;
+ TYPE_NFIELDS(type) = 0;
+ }
+ else
+ {
+ type = coff_read_enum_type (cs->c_symnum,
+ aux->x_sym.x_misc.x_lnsz.x_size,
+ aux->x_sym.x_fcnary.x_fcn.x_endndx.l);
+ }
+ return type;
case T_MOE:
/* shouldn't show up here */
int nfields = 0;
register int n;
char *name;
-#ifdef NAMES_HAVE_UNDERSCORE
- int offset = 1;
-#else
- int offset = 0;
-#endif
struct coff_symbol member_sym;
register struct coff_symbol *ms = &member_sym;
struct internal_syment sub_sym;
{
read_one_sym (ms, &sub_sym, &sub_aux);
name = ms->c_name;
- name = (name[0] == '_' ? name + offset : name);
+ name = EXTERNAL_NAME (name, current_objfile->obfd);
switch (ms->c_sclass)
{
/* Read a definition of an enumeration type,
and create and return a suitable type object.
Also defines the symbols that represent the values of the type. */
-/* Currently assumes it's sizeof (int) and doesn't use length. */
/* ARGSUSED */
static struct type *
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;
-#ifdef NAMES_HAVE_UNDERSCORE
- int offset = 1;
-#else
- int offset = 0;
-#endif
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)
{
read_one_sym (ms, &sub_sym, &sub_aux);
name = ms->c_name;
- name = (name[0] == '_' ? name + offset : name);
+ name = EXTERNAL_NAME (name, current_objfile->obfd);
switch (ms->c_sclass)
{
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;
/* Now fill in the fields of the type-structure. */
- TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT;
+ if (length > 0)
+ TYPE_LENGTH (type) = length;
+ else
+ TYPE_LENGTH (type) = TARGET_INT_BIT / TARGET_CHAR_BIT; /* Assume ints */
TYPE_CODE (type) = TYPE_CODE_ENUM;
TYPE_NFIELDS (type) = nsyms;
TYPE_FIELDS (type) = (struct field *)
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. */
if(TYPE_NFIELDS(type) == 2 &&
- ((!strcmp(TYPE_FIELD_NAME(type,0),"TRUE") &&
- !strcmp(TYPE_FIELD_NAME(type,1),"FALSE")) ||
- (!strcmp(TYPE_FIELD_NAME(type,1),"TRUE") &&
- !strcmp(TYPE_FIELD_NAME(type,0),"FALSE"))))
+ ((STREQ(TYPE_FIELD_NAME(type,0),"TRUE") &&
+ STREQ(TYPE_FIELD_NAME(type,1),"FALSE")) ||
+ (STREQ(TYPE_FIELD_NAME(type,1),"TRUE") &&
+ STREQ(TYPE_FIELD_NAME(type,0),"FALSE"))))
TYPE_CODE(type) = TYPE_CODE_BOOL;
+#endif
return type;
}
/* Fake up support for relocating symbol addresses. FIXME. */
-struct section_offsets coff_symfile_faker = {0};
+struct section_offsets coff_symfile_faker = {{0}};
struct section_offsets *
coff_symfile_offsets (objfile, addr)