#include "symtab.h"
#include "symfile.h" /* Needed for "struct complaint" */
#include "objfiles.h"
+#include "complaints.h"
#include <string.h>
/* Ask buildsym.h to define the vars it normally declares `extern'. */
{"inner block not inside outer block", 0, 0};
struct complaint blockvector_complaint =
- {"block at 0x%x out of order", 0, 0};
+ {"block at 0x%lx out of order", 0, 0};
\f
/* maintain the lists of symbols and blocks */
(*listhead)->symbol[(*listhead)->nsyms++] = symbol;
}
-/* Find a symbol on a pending list. */
+/* Find a symbol named NAME on a LIST. NAME need not be '\0'-terminated;
+ LENGTH is the length of the name. */
struct symbol *
find_symbol_in_list (list, name, length)
{
if (symbol)
{
- complain (&innerblock_complaint, SYMBOL_NAME (symbol));
+ complain (&innerblock_complaint,
+ SYMBOL_SOURCE_NAME (symbol));
}
else
{
- complain (&innerblock_anon_complaint, 0);
+ complain (&innerblock_anon_complaint);
}
BLOCK_START (pblock->block) = BLOCK_START (block);
BLOCK_END (pblock->block) = BLOCK_END (block);
static struct blockvector *
make_blockvector (objfile)
- struct objfile *objfile;
+ struct objfile *objfile;
{
register struct pending_block *next;
register struct blockvector *blockvector;
> BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)))
{
complain (&blockvector_complaint,
- (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
+ (unsigned long) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
}
}
}
\f
/* Start recording information about source code that came from an included
- (or otherwise merged-in) source file with a different name. */
+ (or otherwise merged-in) source file with a different name. NAME is
+ the name of the file (cannot be NULL), DIRNAME is the directory in which
+ it resides (or NULL if not known). */
void
start_subfile (name, dirname)
for (subfile = subfiles; subfile; subfile = subfile->next)
{
- if (!strcmp (subfile->name, name))
+ if (STREQ (subfile->name, name))
{
current_subfile = subfile;
return;
current_subfile = subfile;
/* Save its name and compilation directory name */
- subfile->name = strdup (name);
- if (dirname == NULL)
+ subfile->name = (name == NULL)? NULL : strdup (name);
+ subfile->dirname = (dirname == NULL) ? NULL : strdup (dirname);
+
+ /* Initialize line-number recording for this subfile. */
+ subfile->line_vector = NULL;
+
+ /* Default the source language to whatever can be deduced from
+ the filename. If nothing can be deduced (such as for a C/C++
+ include file with a ".h" extension), then inherit whatever
+ language the previous subfile had. This kludgery is necessary
+ because there is no standard way in some object formats to
+ record the source language. Also, when symtabs are allocated
+ we try to deduce a language then as well, but it is too late
+ for us to use that information while reading symbols, since
+ symtabs aren't allocated until after all the symbols have
+ been processed for a given source file. */
+
+ subfile->language = deduce_language_from_filename (subfile->name);
+ if (subfile->language == language_unknown &&
+ subfile->next != NULL)
{
- subfile->dirname = NULL;
+ subfile->language = subfile->next->language;
}
- else
+
+ /* cfront output is a C program, so in most ways it looks like a C
+ program. But to demangle we need to set the language to C++. We
+ can distinguish cfront code by the fact that it has #line
+ directives which specify a file name ending in .C.
+
+ So if the filename of this subfile ends in .C, then change the language
+ of any pending subfiles from C to C++. We also accept any other C++
+ suffixes accepted by deduce_language_from_filename (in particular,
+ some people use .cxx with cfront). */
+
+ if (subfile->name)
{
- subfile->dirname = strdup (dirname);
+ struct subfile *s;
+
+ if (deduce_language_from_filename (subfile->name) == language_cplus)
+ for (s = subfiles; s != NULL; s = s->next)
+ if (s->language == language_c)
+ s->language = language_cplus;
+ }
+
+ /* And patch up this file if necessary. */
+ if (subfile->language == language_c
+ && subfile->next != NULL
+ && subfile->next->language == language_cplus)
+ {
+ subfile->language = language_cplus;
+ }
+}
+
+/* For stabs readers, the first N_SO symbol is assumed to be the source
+ file name, and the subfile struct is initialized using that assumption.
+ If another N_SO symbol is later seen, immediately following the first
+ one, then the first one is assumed to be the directory name and the
+ second one is really the source file name.
+
+ So we have to patch up the subfile struct by moving the old name value to
+ dirname and remembering the new name. Some sanity checking is performed
+ to ensure that the state of the subfile struct is reasonable and that the
+ old name we are assuming to be a directory name actually is (by checking
+ for a trailing '/'). */
+
+void
+patch_subfile_names (subfile, name)
+ struct subfile *subfile;
+ char *name;
+{
+ if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL
+ && subfile->name[strlen(subfile->name)-1] == '/')
+ {
+ subfile->dirname = subfile->name;
+ subfile->name = strdup (name);
+
+ /* Default the source language to whatever can be deduced from
+ the filename. If nothing can be deduced (such as for a C/C++
+ include file with a ".h" extension), then inherit whatever
+ language the previous subfile had. This kludgery is necessary
+ because there is no standard way in some object formats to
+ record the source language. Also, when symtabs are allocated
+ we try to deduce a language then as well, but it is too late
+ for us to use that information while reading symbols, since
+ symtabs aren't allocated until after all the symbols have
+ been processed for a given source file. */
+
+ subfile->language = deduce_language_from_filename (subfile->name);
+ if (subfile->language == language_unknown &&
+ subfile->next != NULL)
+ {
+ subfile->language = subfile->next->language;
+ }
}
-
- /* Initialize line-number recording for this subfile. */
- subfile->line_vector = NULL;
}
\f
}
\f
-/* Manage the vector of line numbers for each subfile. */
+/* Add a linetable entry for line number LINE and address PC to the line
+ vector for SUBFILE. */
void
record_line (subfile, line, pc)
const PTR ln1p;
const PTR ln2p;
{
- return (((struct linetable_entry *) ln1p) -> line -
- ((struct linetable_entry *) ln2p) -> line);
+ struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
+ struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
+
+ /* Note: this code does not assume that CORE_ADDRs can fit in ints.
+ Please keep it that way. */
+ if (ln1->pc < ln2->pc)
+ return -1;
+
+ if (ln1->pc > ln2->pc)
+ return 1;
+
+ /* If pc equal, sort by line. I'm not sure whether this is optimum
+ behavior (see comment at struct linetable in symtab.h). */
+ return ln1->line - ln2->line;
}
\f
(creating struct block's for them), then make the struct symtab
for that file and put it in the list of all such.
- END_ADDR is the address of the end of the file's text. */
+ END_ADDR is the address of the end of the file's text.
+ SECTION is the section number (in objfile->section_offsets) of
+ the blockvector and linetable.
+
+ Note that it is possible for end_symtab() to return NULL. In particular,
+ for the DWARF case at least, it will return NULL when it finds a
+ compilation unit that has exactly one DIE, a TAG_compile_unit DIE. This
+ can happen when we link in an object file that was compiled from an empty
+ source file. Returning NULL is probably not the correct thing to do,
+ because then gdb will never know about this empty file (FIXME). */
struct symtab *
-end_symtab (end_addr, sort_pending, sort_linevec, objfile)
+end_symtab (end_addr, sort_pending, sort_linevec, objfile, section)
CORE_ADDR end_addr;
int sort_pending;
int sort_linevec;
struct objfile *objfile;
+ int section;
{
- register struct symtab *symtab;
+ register struct symtab *symtab = NULL;
register struct blockvector *blockvector;
register struct subfile *subfile;
register struct context_stack *cstk;
}
}
- /* It is unfortunate that in aixcoff, pending blocks might not be ordered
+ /* It is unfortunate that in xcoff, 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. */
/* Cleanup any undefined types that have been left hanging around
(this needs to be done before the finish_blocks so that
file_symbols is still good).
- FIXME: Stabs specific. */
+
+ Both cleanup_undefined_types and finish_global_stabs are stabs
+ specific, but harmless for other symbol readers, since on gdb
+ startup or when finished reading stabs, the state is set so these
+ are no-ops. FIXME: Is this handled right in case of QUIT? Can
+ we make this cleaner? */
+
cleanup_undefined_types ();
finish_global_stabs (objfile);
}
#ifdef PROCESS_LINENUMBER_HOOK
- PROCESS_LINENUMBER_HOOK (); /* Needed for aixcoff. */
+ PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */
#endif
/* Now create the symtab objects proper, one for each subfile. */
for (subfile = subfiles; subfile; subfile = nextsub)
{
- int linetablesize;
+ int linetablesize = 0;
/* If we have blocks of symbols, make a symtab.
Otherwise, just ignore this file and any line number info in it. */
symtab = NULL;
{
if (subfile->line_vector)
{
- /* First, shrink the linetable to make more memory. */
linetablesize = sizeof (struct linetable) +
subfile->line_vector->nitems * sizeof (struct linetable_entry);
+#if 0
+ /* I think this is artifact from before it went on the obstack.
+ I doubt we'll need the memory between now and when we
+ free it later in this function. */
+ /* First, shrink the linetable to make more memory. */
subfile->line_vector = (struct linetable *)
xrealloc ((char *) subfile->line_vector, linetablesize);
+#endif
+ /* If sort_linevec is false, we might want just check to make
+ sure they are sorted and complain() if not, as a way of
+ tracking down compilers/symbol readers which don't get
+ them sorted right. */
if (sort_linevec)
qsort (subfile->line_vector->item,
{
symtab->linetable = NULL;
}
- symtab->dirname = subfile->dirname;
+ symtab->block_line_section = section;
+ if (subfile->dirname)
+ {
+ /* Reallocate the dirname on the symbol obstack */
+ symtab->dirname = (char *)
+ obstack_alloc (&objfile -> symbol_obstack,
+ strlen (subfile -> dirname) + 1);
+ strcpy (symtab->dirname, subfile->dirname);
+ }
+ else
+ {
+ symtab->dirname = NULL;
+ }
symtab->free_code = free_linetable;
symtab->free_ptr = NULL;
-#ifdef IBM6000_TARGET
- /* In case we need to duplicate symbol tables (to represent include
- files), and in case our system needs relocation, we want to
- relocate the main symbol table node only (for the main file,
- not for the include files). */
+ /* Use whatever language we have been using for this subfile,
+ not the one that was deduced in allocate_symtab from the
+ filename. We already did our own deducing when we created
+ the subfile, and we may have altered our opinion of what
+ language it is from things we found in the symbols. */
+ symtab->language = subfile->language;
- symtab->nonreloc = TRUE;
-#endif
+ /* All symtabs for the main file and the subfiles share a
+ blockvector, so we need to clear primary for everything but
+ the main file. */
+
+ symtab->primary = 0;
+ }
+ if (subfile->name != NULL)
+ {
+ free ((PTR) subfile->name);
+ }
+ if (subfile->dirname != NULL)
+ {
+ free ((PTR) subfile->dirname);
}
- if (subfile->line_vector)
+ if (subfile->line_vector != NULL)
{
- free ((PTR)subfile->line_vector);
+ free ((PTR) subfile->line_vector);
}
nextsub = subfile->next;
free ((PTR)subfile);
}
-#ifdef IBM6000_TARGET
- /* all include symbol tables are non-relocatable, except the main source
- file's. */
+ /* Set this for the main source file. */
if (symtab)
{
- symtab->nonreloc = FALSE;
+ symtab->primary = 1;
}
-#endif
last_source_file = NULL;
current_subfile = NULL;
return (new);
}
+\f
+/* Compute a small integer hash code for the given name. */
+
+int
+hashname (name)
+ char *name;
+{
+ register char *p = name;
+ register int total = p[0];
+ register int c;
+
+ c = p[1];
+ total += c << 2;
+ if (c)
+ {
+ c = p[2];
+ total += c << 4;
+ if (c)
+ {
+ total += p[3] << 6;
+ }
+ }
+
+ /* Ensure result is positive. */
+ if (total < 0)
+ {
+ total += (1000 << 6);
+ }
+ return (total % HASHSIZE);
+}
+
\f
/* Initialize anything that needs initializing when starting to read
a fresh piece of a symbol file, e.g. reading in the stuff corresponding