X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fbuildsym.c;h=d7e99c054e1c3afded4b5ded4d072eec0ddc7b4d;hb=14a5e76714708e70c7a7a962a60b5a2bf68602db;hp=a25190a6168054fd9b1e698bb85e84cf23984ce5;hpb=9b280a7f5363e4b2ebd8c0a9b2e1782e9769880c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/buildsym.c b/gdb/buildsym.c index a25190a616..d7e99c054e 100644 --- a/gdb/buildsym.c +++ b/gdb/buildsym.c @@ -1,22 +1,23 @@ /* Support routines for building symbol tables in GDB's internal format. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992 - Free Software Foundation, Inc. + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -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. */ + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ /* This module provides subroutines used for creating and adding to the symbol table. These routines are called from various symbol- @@ -31,52 +32,90 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "symtab.h" #include "symfile.h" /* Needed for "struct complaint" */ #include "objfiles.h" -#include - +#include "gdbtypes.h" +#include "complaints.h" +#include "gdb_string.h" +#include "expression.h" /* For "enum exp_opcode" used by... */ +#include "language.h" /* For "local_hex_string" */ +#include "bcache.h" +#include "filenames.h" /* For DOSish file names */ /* Ask buildsym.h to define the vars it normally declares `extern'. */ -#define EXTERN /**/ +#define EXTERN +/**/ #include "buildsym.h" /* Our own declarations */ #undef EXTERN -static int -compare_line_numbers PARAMS ((const void *, const void *)); +/* For cleanup_undefined_types and finish_global_stabs (somewhat + questionable--see comment where we call them). */ + +#include "stabsread.h" + +/* List of free `struct pending' structures for reuse. */ + +static struct pending *free_pendings; -static struct blockvector * -make_blockvector PARAMS ((struct objfile *)); +/* Non-zero if symtab has line number info. This prevents an + otherwise empty symtab from being tossed. */ +static int have_line_numbers; -/* Initial sizes of data structures. These are realloc'd larger if needed, - and realloc'd down to the size actually used, when completed. */ +static int compare_line_numbers (const void *ln1p, const void *ln2p); + + +/* Initial sizes of data structures. These are realloc'd larger if + needed, and realloc'd down to the size actually used, when + completed. */ #define INITIAL_CONTEXT_STACK_SIZE 10 #define INITIAL_LINE_VECTOR_LENGTH 1000 - + /* Complaints about the symbols we have encountered. */ +struct complaint block_end_complaint = +{"block end address less than block start address in %s (patched it)", 0, 0}; + +struct complaint anon_block_end_complaint = +{"block end address 0x%lx less than block start address 0x%lx (patched it)", 0, 0}; + struct complaint innerblock_complaint = - {"inner block not inside outer block in %s", 0, 0}; +{"inner block not inside outer block in %s", 0, 0}; struct complaint innerblock_anon_complaint = - {"inner block not inside outer block", 0, 0}; - -struct complaint blockvector_complaint = - {"block at 0x%x out of order", 0, 0}; +{"inner block (0x%lx-0x%lx) not inside outer block (0x%lx-0x%lx)", 0, 0}; +struct complaint blockvector_complaint = +{"block at %s out of order", 0, 0}; /* maintain the lists of symbols and blocks */ +/* Add a pending list to free_pendings. */ +void +add_free_pendings (struct pending *list) +{ + register struct pending *link = list; + + if (list) + { + while (link->next) link = link->next; + link->next = free_pendings; + free_pendings = list; + } +} + /* Add a symbol to one of the lists of symbols. */ void -add_symbol_to_list (symbol, listhead) - struct symbol *symbol; - struct pending **listhead; +add_symbol_to_list (struct symbol *symbol, struct pending **listhead) { register struct pending *link; - - /* We keep PENDINGSIZE symbols in each link of the list. - If we don't have a link with room in it, add a new link. */ + + /* If this is an alias for another symbol, don't add it. */ + if (symbol->ginfo.name && symbol->ginfo.name[0] == '#') + return; + + /* We keep PENDINGSIZE symbols in each link of the list. If we + don't have a link with room in it, add a new link. */ if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE) { if (free_pendings) @@ -97,20 +136,18 @@ add_symbol_to_list (symbol, listhead) (*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) - struct pending *list; - char *name; - int length; +find_symbol_in_list (struct pending *list, char *name, int length) { int j; char *pp; while (list != NULL) { - for (j = list->nsyms; --j >= 0; ) + for (j = list->nsyms; --j >= 0;) { pp = SYMBOL_NAME (list->symbol[j]); if (*pp == *name && strncmp (pp, name, length) == 0 && @@ -124,61 +161,67 @@ find_symbol_in_list (list, name, length) return (NULL); } -/* At end of reading syms, or in case of quit, - really free as many `struct pending's as we can easily find. */ +/* At end of reading syms, or in case of quit, really free as many + `struct pending's as we can easily find. */ /* ARGSUSED */ void -really_free_pendings (foo) - int foo; +really_free_pendings (PTR dummy) { struct pending *next, *next1; -#if 0 - struct pending_block *bnext, *bnext1; -#endif for (next = free_pendings; next; next = next1) { next1 = next->next; - free ((PTR)next); + xfree ((void *) next); } free_pendings = NULL; -#if 0 /* Now we make the links in the symbol_obstack, so don't free them. */ - for (bnext = pending_blocks; bnext; bnext = bnext1) - { - bnext1 = bnext->next; - free ((PTR)bnext); - } -#endif - pending_blocks = NULL; + free_pending_blocks (); for (next = file_symbols; next != NULL; next = next1) { next1 = next->next; - free ((PTR)next); + xfree ((void *) next); } file_symbols = NULL; for (next = global_symbols; next != NULL; next = next1) { next1 = next->next; - free ((PTR)next); + xfree ((void *) next); } global_symbols = NULL; } -/* Take one of the lists of symbols and make a block from it. - Keep the order the symbols have in the list (reversed from the input file). - Put the block on the list of pending blocks. */ +/* This function is called to discard any pending blocks. */ + +void +free_pending_blocks (void) +{ +#if 0 /* Now we make the links in the + symbol_obstack, so don't free + them. */ + struct pending_block *bnext, *bnext1; + + for (bnext = pending_blocks; bnext; bnext = bnext1) + { + bnext1 = bnext->next; + xfree ((void *) bnext); + } +#endif + pending_blocks = NULL; +} + +/* Take one of the lists of symbols and make a block from it. Keep + the order the symbols have in the list (reversed from the input + file). Put the block on the list of pending blocks. */ void -finish_block (symbol, listhead, old_blocks, start, end, objfile) - struct symbol *symbol; - struct pending **listhead; - struct pending_block *old_blocks; - CORE_ADDR start, end; - struct objfile *objfile; +finish_block (struct symbol *symbol, struct pending **listhead, + struct pending_block *old_blocks, + CORE_ADDR start, CORE_ADDR end, + struct objfile *objfile) { register struct pending *next, *next1; register struct block *block; @@ -193,11 +236,11 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) next; i += next->nsyms, next = next->next) { - /*EMPTY*/; + /* EMPTY */ ; } - block = (struct block *) obstack_alloc (&objfile -> symbol_obstack, - (sizeof (struct block) + ((i - 1) * sizeof (struct symbol *)))); + block = (struct block *) obstack_alloc (&objfile->symbol_obstack, + (sizeof (struct block) + ((i - 1) * sizeof (struct symbol *)))); /* Copy the symbols into the block. */ @@ -212,16 +255,95 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) BLOCK_START (block) = start; BLOCK_END (block) = end; - /* Superblock filled in when containing block is made */ + /* Superblock filled in when containing block is made */ BLOCK_SUPERBLOCK (block) = NULL; + BLOCK_GCC_COMPILED (block) = processing_gcc_compilation; /* Put the block in as the value of the symbol that names it. */ if (symbol) { + struct type *ftype = SYMBOL_TYPE (symbol); SYMBOL_BLOCK_VALUE (symbol) = block; BLOCK_FUNCTION (block) = symbol; + + if (TYPE_NFIELDS (ftype) <= 0) + { + /* No parameter type information is recorded with the + function's type. Set that from the type of the + parameter symbols. */ + int nparams = 0, iparams; + struct symbol *sym; + ALL_BLOCK_SYMBOLS (block, i, sym) + { + switch (SYMBOL_CLASS (sym)) + { + case LOC_ARG: + case LOC_REF_ARG: + case LOC_REGPARM: + case LOC_REGPARM_ADDR: + case LOC_BASEREG_ARG: + case LOC_LOCAL_ARG: + nparams++; + break; + case LOC_UNDEF: + case LOC_CONST: + case LOC_STATIC: + case LOC_INDIRECT: + case LOC_REGISTER: + case LOC_LOCAL: + case LOC_TYPEDEF: + case LOC_LABEL: + case LOC_BLOCK: + case LOC_CONST_BYTES: + case LOC_BASEREG: + case LOC_UNRESOLVED: + case LOC_OPTIMIZED_OUT: + default: + break; + } + } + if (nparams > 0) + { + TYPE_NFIELDS (ftype) = nparams; + TYPE_FIELDS (ftype) = (struct field *) + TYPE_ALLOC (ftype, nparams * sizeof (struct field)); + + for (i = iparams = 0; iparams < nparams; i++) + { + sym = BLOCK_SYM (block, i); + switch (SYMBOL_CLASS (sym)) + { + case LOC_ARG: + case LOC_REF_ARG: + case LOC_REGPARM: + case LOC_REGPARM_ADDR: + case LOC_BASEREG_ARG: + case LOC_LOCAL_ARG: + TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); + TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; + iparams++; + break; + case LOC_UNDEF: + case LOC_CONST: + case LOC_STATIC: + case LOC_INDIRECT: + case LOC_REGISTER: + case LOC_LOCAL: + case LOC_TYPEDEF: + case LOC_LABEL: + case LOC_BLOCK: + case LOC_CONST_BYTES: + case LOC_BASEREG: + case LOC_UNRESOLVED: + case LOC_OPTIMIZED_OUT: + default: + break; + } + } + } + } } else { @@ -238,9 +360,27 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) } *listhead = NULL; - /* Install this block as the superblock - of all blocks made since the start of this scope - that don't have superblocks yet. */ +#if 1 + /* Check to be sure that the blocks have an end address that is + greater than starting address */ + + if (BLOCK_END (block) < BLOCK_START (block)) + { + if (symbol) + { + complain (&block_end_complaint, SYMBOL_SOURCE_NAME (symbol)); + } + else + { + complain (&anon_block_end_complaint, BLOCK_END (block), BLOCK_START (block)); + } + /* Better than nothing */ + BLOCK_END (block) = BLOCK_START (block); + } +#endif + + /* Install this block as the superblock of all blocks made since the + start of this scope that don't have superblocks yet. */ opblock = NULL; for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next) @@ -248,22 +388,27 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) if (BLOCK_SUPERBLOCK (pblock->block) == NULL) { #if 1 - /* Check to be sure the blocks are nested as we receive them. - If the compiler/assembler/linker work, this just burns a small - amount of time. */ + /* Check to be sure the blocks are nested as we receive + them. If the compiler/assembler/linker work, this just + burns a small amount of time. */ if (BLOCK_START (pblock->block) < BLOCK_START (block) || - BLOCK_END (pblock->block) > BLOCK_END (block)) + BLOCK_END (pblock->block) > BLOCK_END (block)) { 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_END (pblock->block), BLOCK_START (block), + BLOCK_END (block)); } - BLOCK_START (pblock->block) = BLOCK_START (block); - BLOCK_END (pblock->block) = BLOCK_END (block); + if (BLOCK_START (pblock->block) < BLOCK_START (block)) + BLOCK_START (pblock->block) = BLOCK_START (block); + if (BLOCK_END (pblock->block) > BLOCK_END (block)) + BLOCK_END (pblock->block) = BLOCK_END (block); } #endif BLOCK_SUPERBLOCK (pblock->block) = block; @@ -271,15 +416,24 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) 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. */ + record_pending_block (objfile, block, opblock); +} + +/* Record BLOCK on the list of all blocks in the file. Put it after + OPBLOCK, or at the beginning if opblock is NULL. This puts the + block in the list after all its subblocks. + + Allocate the pending block struct in the symbol_obstack to save + time. This wastes a little space. FIXME: Is it worth it? */ + +void +record_pending_block (struct objfile *objfile, struct block *block, + struct pending_block *opblock) +{ + register struct pending_block *pblock; - /* Allocate in the symbol_obstack to save time. - It wastes a little space. */ pblock = (struct pending_block *) - obstack_alloc (&objfile -> symbol_obstack, - sizeof (struct pending_block)); + obstack_alloc (&objfile->symbol_obstack, sizeof (struct pending_block)); pblock->block = block; if (opblock) { @@ -293,9 +447,12 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) } } -static struct blockvector * -make_blockvector (objfile) - struct objfile *objfile; +/* Note that this is only used in this file and in dstread.c, which + should be fixed to not need direct access to this function. When + that is done, it can be made static again. */ + +struct blockvector * +make_blockvector (struct objfile *objfile) { register struct pending_block *next; register struct blockvector *blockvector; @@ -303,18 +460,20 @@ make_blockvector (objfile) /* Count the length of the list of blocks. */ - for (next = pending_blocks, i = 0; next; next = next->next, i++) {;} + for (next = pending_blocks, i = 0; next; next = next->next, i++) + {; + } blockvector = (struct blockvector *) - obstack_alloc (&objfile -> symbol_obstack, + 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). - finish_block has hair to insert each block into the list - after its subblocks in order to make sure this is true. */ + /* 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). 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) @@ -322,30 +481,35 @@ make_blockvector (objfile) BLOCKVECTOR_BLOCK (blockvector, --i) = next->block; } -#if 0 /* Now we make the links in the obstack, so don't free them. */ +#if 0 /* Now we make the links in the + obstack, so don't free them. */ /* Now free the links of the list, and empty the list. */ for (next = pending_blocks; next; next = next1) { next1 = next->next; - free (next); + xfree (next); } #endif pending_blocks = NULL; -#if 1 /* FIXME, shut this off after a while to speed up symbol reading. */ - /* Some compilers output blocks in the wrong order, but we depend - on their being in the right order so we can binary search. - Check the order and moan about it. FIXME. */ +#if 1 /* FIXME, shut this off after a while + to speed up symbol reading. */ + /* Some compilers output blocks in the wrong order, but we depend on + their being in the right order so we can binary search. Check the + order and moan about it. FIXME. */ if (BLOCKVECTOR_NBLOCKS (blockvector) > 1) { for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++) { - if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1)) - > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))) + if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1)) + > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i))) { - complain (&blockvector_complaint, - (char *) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))); + CORE_ADDR start + = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)); + + complain (&blockvector_complaint, + local_hex_string ((LONGEST) start)); } } } @@ -353,117 +517,184 @@ make_blockvector (objfile) return (blockvector); } - -/* Start recording information about source code that came from an included - (or otherwise merged-in) source file with a different name. */ +/* Start recording information about source code that came from an + included (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) - char *name; - char *dirname; +start_subfile (char *name, char *dirname) { register struct subfile *subfile; - /* See if this subfile is already known as a subfile of the - current main source file. */ + /* See if this subfile is already known as a subfile of the current + main source file. */ for (subfile = subfiles; subfile; subfile = subfile->next) { - if (!strcmp (subfile->name, name)) + if (FILENAME_CMP (subfile->name, name) == 0) { current_subfile = subfile; return; } } - /* This subfile is not known. Add an entry for it. - Make an entry for this subfile in the list of all subfiles - of the current main source file. */ + /* This subfile is not known. Add an entry for it. Make an entry + for this subfile in the list of all subfiles of the current main + source file. */ subfile = (struct subfile *) xmalloc (sizeof (struct subfile)); + memset ((char *) subfile, 0, sizeof (struct subfile)); subfile->next = subfiles; subfiles = subfile; current_subfile = subfile; /* Save its name and compilation directory name */ - subfile->name = strdup (name); - subfile->dirname = (dirname == NULL) ? NULL : strdup (dirname); - + subfile->name = (name == NULL) ? NULL : savestring (name, strlen (name)); + subfile->dirname = + (dirname == NULL) ? NULL : savestring (dirname, strlen (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->language = subfile->next->language; + } + + /* Initialize the debug format string to NULL. We may supply it + later via a call to record_debugformat. */ + subfile->debugformat = NULL; + + /* 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). */ + /* Likewise for f2c. */ + + if (subfile->name) + { + struct subfile *s; + enum language sublang = deduce_language_from_filename (subfile->name); + + if (sublang == language_cplus || sublang == language_fortran) + for (s = subfiles; s != NULL; s = s->next) + if (s->language == language_c) + s->language = sublang; + } + + /* And patch up this file if necessary. */ + if (subfile->language == language_c + && subfile->next != NULL + && (subfile->next->language == language_cplus + || subfile->next->language == language_fortran)) + { + subfile->language = subfile->next->language; + } } -/* 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. +/* 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 '/'). */ + 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; +patch_subfile_names (struct subfile *subfile, char *name) { if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL - && subfile->name[strlen(subfile->name)-1] == '/') + && subfile->name[strlen (subfile->name) - 1] == '/') { subfile->dirname = subfile->name; - subfile->name = strdup (name); + subfile->name = savestring (name, strlen (name)); + last_source_file = 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; + } } } - -/* Handle the N_BINCL and N_EINCL symbol types - that act like N_SOL for switching source files - (different subfiles, as we call them) within one object file, - but using a stack rather than in an arbitrary order. */ +/* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for + switching source files (different subfiles, as we call them) within + one object file, but using a stack rather than in an arbitrary + order. */ void -push_subfile () +push_subfile (void) { register struct subfile_stack *tem - = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack)); + = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack)); tem->next = subfile_stack; subfile_stack = tem; if (current_subfile == NULL || current_subfile->name == NULL) { - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); } tem->name = current_subfile->name; } char * -pop_subfile () +pop_subfile (void) { register char *name; register struct subfile_stack *link = subfile_stack; if (link == NULL) { - abort (); + internal_error (__FILE__, __LINE__, "failed internal consistency check"); } name = link->name; subfile_stack = link->next; - free ((PTR)link); + xfree ((void *) link); return (name); } - -/* 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) - register struct subfile *subfile; - int line; - CORE_ADDR pc; +record_line (register struct subfile *subfile, int line, CORE_ADDR pc) { struct linetable_entry *e; /* Ignore the dummy line number in libg.o */ @@ -479,45 +710,54 @@ record_line (subfile, line, pc) subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH; subfile->line_vector = (struct linetable *) xmalloc (sizeof (struct linetable) - + subfile->line_vector_length * sizeof (struct linetable_entry)); + + subfile->line_vector_length * sizeof (struct linetable_entry)); subfile->line_vector->nitems = 0; + have_line_numbers = 1; } if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length) { subfile->line_vector_length *= 2; subfile->line_vector = (struct linetable *) - xrealloc ((char *) subfile->line_vector, (sizeof (struct linetable) - + subfile->line_vector_length * sizeof (struct linetable_entry))); + xrealloc ((char *) subfile->line_vector, + (sizeof (struct linetable) + + (subfile->line_vector_length + * sizeof (struct linetable_entry)))); } e = subfile->line_vector->item + subfile->line_vector->nitems++; - e->line = line; e->pc = pc; + e->line = line; + e->pc = ADDR_BITS_REMOVE(pc); } - /* Needed in order to sort line tables from IBM xcoff files. Sigh! */ static int -compare_line_numbers (ln1p, ln2p) - const PTR ln1p; - const PTR ln2p; +compare_line_numbers (const void *ln1p, const void *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; +} -/* Start a new symtab for a new source file. - Called, for example, when a stabs symbol of type N_SO is seen, or when - a DWARF TAG_compile_unit DIE is seen. - It indicates the start of data for one original source file. */ +/* Start a new symtab for a new source file. Called, for example, + when a stabs symbol of type N_SO is seen, or when a DWARF + TAG_compile_unit DIE is seen. It indicates the start of data for + one original source file. */ void -start_symtab (name, dirname, start_addr) - char *name; - char *dirname; - CORE_ADDR start_addr; +start_symtab (char *name, char *dirname, CORE_ADDR start_addr) { last_source_file = name; @@ -525,9 +765,10 @@ start_symtab (name, dirname, start_addr) file_symbols = NULL; global_symbols = NULL; within_function = 0; + have_line_numbers = 0; - /* Context stack is initially empty. Allocate first one with room for - 10 levels; reuse it forever afterward. */ + /* Context stack is initially empty. Allocate first one with room + for 10 levels; reuse it forever afterward. */ if (context_stack == NULL) { context_stack_size = INITIAL_CONTEXT_STACK_SIZE; @@ -536,73 +777,74 @@ start_symtab (name, dirname, start_addr) } context_stack_depth = 0; - /* Initialize the list of sub source files with one entry - for this file (the top-level source file). */ + /* Initialize the list of sub source files with one entry for this + file (the top-level source file). */ subfiles = NULL; current_subfile = NULL; start_subfile (name, dirname); } -/* Finish the symbol definitions for one main source file, - close off all the lexical contexts for that file - (creating struct block's for them), then make the struct symtab - for that file and put it in the list of all such. +/* Finish the symbol definitions for one main source file, close off + all the lexical contexts for that file (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). */ + 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) - CORE_ADDR end_addr; - int sort_pending; - int sort_linevec; - struct objfile *objfile; +end_symtab (CORE_ADDR end_addr, 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; struct subfile *nextsub; - /* Finish the lexical context of the last function in the file; - pop the context stack. */ + /* Finish the lexical context of the last function in the file; pop + the context stack. */ if (context_stack_depth > 0) { - context_stack_depth--; - cstk = &context_stack[context_stack_depth]; + cstk = pop_context (); /* Make a block for the local symbols within. */ finish_block (cstk->name, &local_symbols, cstk->old_blocks, cstk->start_addr, end_addr, objfile); - /* Debug: if context stack still has something in it, - we are in trouble. */ if (context_stack_depth > 0) { - abort (); + /* This is said to happen with SCO. The old coffread.c + code simply emptied the context stack, so we do the + same. FIXME: Find out why it is happening. This is not + believed to happen in most cases (even for coffread.c); + it used to be an abort(). */ + static struct complaint msg = + {"Context stack not empty in end_symtab", 0, 0}; + complain (&msg); + context_stack_depth = 0; } } - /* 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. */ - - if (sort_pending && pending_blocks) + /* Reordered executables may have out of order pending blocks; if + OBJF_REORDERED is true, then sort the pending blocks. */ + if ((objfile->flags & OBJF_REORDERED) && pending_blocks) { - /* FIXME! Remove this horrid bubble sort and use qsort!!! */ + /* FIXME! Remove this horrid bubble sort and use merge sort!!! */ int swapped; do { struct pending_block *pb, *pbnext; - + pb = pending_blocks; pbnext = pb->next; swapped = 0; @@ -610,8 +852,8 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) while (pbnext) { /* swap blocks if unordered! */ - - if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) + + if (BLOCK_START (pb->block) < BLOCK_START (pbnext->block)) { struct block *tmp = pb->block; pb->block = pbnext->block; @@ -621,26 +863,36 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) pb = pbnext; pbnext = pbnext->next; } - } while (swapped); + } + while (swapped); } /* 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); if (pending_blocks == NULL && file_symbols == NULL - && global_symbols == NULL) + && global_symbols == NULL + && have_line_numbers == 0) { - /* Ignore symtabs that have no functions with real debugging info */ + /* Ignore symtabs that have no functions with real debugging + info. */ blockvector = NULL; } else { - /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */ + /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the + blockvector. */ finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr, objfile); finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr, @@ -648,33 +900,43 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) blockvector = make_blockvector (objfile); } -#ifdef PROCESS_LINENUMBER_HOOK - PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */ +#ifndef PROCESS_LINENUMBER_HOOK +#define PROCESS_LINENUMBER_HOOK() #endif + PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */ /* Now create the symtab objects proper, one for each subfile. */ /* (The main file is the last one on the chain.) */ for (subfile = subfiles; subfile; subfile = nextsub) { - int linetablesize; - /* If we have blocks of symbols, make a symtab. - Otherwise, just ignore this file and any line number info in it. */ + int linetablesize = 0; symtab = NULL; + + /* If we have blocks of symbols, make a symtab. Otherwise, just + ignore this file and any line number info in it. */ if (blockvector) { if (subfile->line_vector) { - /* First, shrink the linetable to make more memory. */ linetablesize = sizeof (struct linetable) + - subfile->line_vector->nitems * sizeof (struct linetable_entry); + 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) + /* Like the pending blocks, the line table may be + scrambled in reordered executables. Sort it if + OBJF_REORDERED is true. */ + if (objfile->flags & OBJF_REORDERED) qsort (subfile->line_vector->item, subfile->line_vector->nitems, - sizeof (struct linetable_entry), compare_line_numbers); + sizeof (struct linetable_entry), compare_line_numbers); } /* Now, allocate a symbol table. */ @@ -685,20 +947,21 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) if (subfile->line_vector) { /* Reallocate the line table on the symbol obstack */ - symtab->linetable = (struct linetable *) - obstack_alloc (&objfile -> symbol_obstack, linetablesize); + symtab->linetable = (struct linetable *) + obstack_alloc (&objfile->symbol_obstack, linetablesize); memcpy (symtab->linetable, subfile->line_vector, linetablesize); } else { symtab->linetable = NULL; } + 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); + obstack_alloc (&objfile->symbol_obstack, + strlen (subfile->dirname) + 1); strcpy (symtab->dirname, subfile->dirname); } else @@ -708,55 +971,67 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile) 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 + /* Save the debug format string (if any) in the symtab */ + if (subfile->debugformat != NULL) + { + symtab->debugformat = obsavestring (subfile->debugformat, + strlen (subfile->debugformat), + &objfile->symbol_obstack); + } + + /* 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); + xfree ((void *) subfile->name); } if (subfile->dirname != NULL) { - free ((PTR) subfile->dirname); + xfree ((void *) subfile->dirname); } if (subfile->line_vector != NULL) { - free ((PTR) subfile->line_vector); + xfree ((void *) subfile->line_vector); + } + if (subfile->debugformat != NULL) + { + xfree ((void *) subfile->debugformat); } nextsub = subfile->next; - free ((PTR)subfile); + xfree ((void *) 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 (symtab); + return symtab; } - -/* Push a context block. Args are an identifying nesting level (checkable - when you pop it), and the starting PC address of this context. */ +/* Push a context block. Args are an identifying nesting level + (checkable when you pop it), and the starting PC address of this + context. */ struct context_stack * -push_context (desc, valu) - int desc; - CORE_ADDR valu; +push_context (int desc, CORE_ADDR valu) { register struct context_stack *new; @@ -771,22 +1046,67 @@ push_context (desc, valu) new = &context_stack[context_stack_depth++]; new->depth = desc; new->locals = local_symbols; + new->params = param_symbols; new->old_blocks = pending_blocks; new->start_addr = valu; new->name = NULL; local_symbols = NULL; + param_symbols = NULL; + + return new; +} + + +/* Compute a small integer hash code for the given name. */ + +int +hashname (char *name) +{ + return (hash(name,strlen(name)) % HASHSIZE); +} + - return (new); +void +record_debugformat (char *format) +{ + current_subfile->debugformat = savestring (format, strlen (format)); } +/* Merge the first symbol list SRCLIST into the second symbol list + TARGETLIST by repeated calls to add_symbol_to_list(). This + procedure "frees" each link of SRCLIST by adding it to the + free_pendings list. Caller must set SRCLIST to a null list after + calling this function. + + Void return. */ + +void +merge_symbol_lists (struct pending **srclist, struct pending **targetlist) +{ + register int i; + + if (!srclist || !*srclist) + return; + + /* Merge in elements from current link. */ + for (i = 0; i < (*srclist)->nsyms; i++) + add_symbol_to_list ((*srclist)->symbol[i], targetlist); + + /* Recurse on next. */ + merge_symbol_lists (&(*srclist)->next, targetlist); + + /* "Free" the current link. */ + (*srclist)->next = free_pendings; + free_pendings = (*srclist); +} -/* Initialize anything that needs initializing when starting to read - a fresh piece of a symbol file, e.g. reading in the stuff corresponding - to a psymtab. */ +/* Initialize anything that needs initializing when starting to read a + fresh piece of a symbol file, e.g. reading in the stuff + corresponding to a psymtab. */ void -buildsym_init () +buildsym_init (void) { free_pendings = NULL; file_symbols = NULL; @@ -799,14 +1119,7 @@ buildsym_init () file, e.g. a shared library). */ void -buildsym_new_init () +buildsym_new_init (void) { buildsym_init (); } - -/* Initializer for this module */ - -void -_initialize_buildsym () -{ -}