X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fbuildsym.c;h=4b362e08a2edf2edd8efa8a9b47f4086b52b520b;hb=4a146b47d7355c3c0ef7004f35c6c9c9a88b80c0;hp=c67dd4c8efc68197038a5c56ad992e604b5c2e15;hpb=f3cc3e6e6dd47562a934d6406ef0850d29d48909;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/buildsym.c b/gdb/buildsym.c index c67dd4c8ef..4b362e08a2 100644 --- a/gdb/buildsym.c +++ b/gdb/buildsym.c @@ -1,21 +1,24 @@ /* Support routines for building symbol tables in GDB's internal format. - Copyright 1986-1999 Free Software Foundation, Inc. + Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 + 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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- @@ -26,78 +29,87 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" #include "bfd.h" -#include "obstack.h" +#include "gdb_obstack.h" #include "symtab.h" -#include "symfile.h" /* Needed for "struct complaint" */ +#include "symfile.h" #include "objfiles.h" #include "gdbtypes.h" +#include "gdb_assert.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 */ +#include "macrotab.h" +#include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */ +#include "block.h" +#include "cp-support.h" +#include "dictionary.h" /* Ask buildsym.h to define the vars it normally declares `extern'. */ -#define EXTERN /**/ +#define EXTERN +/**/ #include "buildsym.h" /* Our own declarations */ #undef EXTERN /* 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; -/* Non-zero if symtab has line number info. This prevents an otherwise empty - symtab from being tossed. */ +/* Non-zero if symtab has line number info. This prevents an + otherwise empty symtab from being tossed. */ static int have_line_numbers; -static int -compare_line_numbers PARAMS ((const void *, const void *)); - +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. */ + +/* 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}; - -struct complaint innerblock_anon_complaint = - {"inner block (0x%lx-0x%lx) not inside outer block (0x%lx-0x%lx)", 0, 0}; - -struct complaint blockvector_complaint = - {"block at 0x%lx out of order", 0, 0}; - /* maintain the lists of symbols and blocks */ -/* Add a symbol to one of the lists of symbols. */ +/* Add a pending list to free_pendings. */ +void +add_free_pendings (struct pending *list) +{ + 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. While we're at it, if + we're in the C++ case and don't have full namespace debugging info, + check to see if it references an anonymous namespace; if so, add an + appropriate using directive. */ 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; + struct pending *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. */ + + /* 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) @@ -116,25 +128,28 @@ add_symbol_to_list (symbol, listhead) } (*listhead)->symbol[(*listhead)->nsyms++] = symbol; + + /* Check to see if we might need to look for a mention of anonymous + namespaces. */ + + if (SYMBOL_LANGUAGE (symbol) == language_cplus) + cp_scan_for_anonymous_namespaces (symbol); } -/* Find a symbol named NAME on a LIST. NAME need not be '\0'-terminated; - LENGTH is the length of the name. */ +/* 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]); + pp = DEPRECATED_SYMBOL_NAME (list->symbol[j]); if (*pp == *name && strncmp (pp, name, length) == 0 && pp[length] == '\0') { @@ -146,20 +161,18 @@ 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 (void *dummy) { struct pending *next, *next1; for (next = free_pendings; next; next = next1) { next1 = next->next; - free ((PTR)next); + xfree ((void *) next); } free_pendings = NULL; @@ -168,81 +181,73 @@ really_free_pendings (foo) 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; + + if (pending_macros) + free_macro_table (pending_macros); } /* This function is called to discard any pending blocks. */ void -free_pending_blocks () +free_pending_blocks (void) { -#if 0 /* Now we make the links in the symbol_obstack, so don't free them. */ +#if 0 /* Now we make the links in the + objfile_obstack, so don't free + them. */ struct pending_block *bnext, *bnext1; for (bnext = pending_blocks; bnext; bnext = bnext1) { bnext1 = bnext->next; - free ((PTR)bnext); + 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. */ +/* 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; - register struct pending_block *pblock; + struct pending *next, *next1; + struct block *block; + struct pending_block *pblock; struct pending_block *opblock; - register int i; - register int j; - /* Count the length of the list of symbols. */ + block = allocate_block (&objfile->objfile_obstack); - for (next = *listhead, i = 0; - next; - i += next->nsyms, next = next->next) + if (symbol) { - /*EMPTY*/; + BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack, + *listhead); } - - 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) + else { - for (j = next->nsyms - 1; j >= 0; j--) - { - BLOCK_SYM (block, --i) = next->symbol[j]; - } + BLOCK_DICT (block) = dict_create_hashed (&objfile->objfile_obstack, + *listhead); } 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_NAMESPACE (block) = NULL; BLOCK_GCC_COMPILED (block) = processing_gcc_compilation; @@ -251,18 +256,19 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) if (symbol) { struct type *ftype = SYMBOL_TYPE (symbol); + struct dict_iterator iter; 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. */ + /* 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; - for (i = 0; i < BLOCK_NSYMS (block); i++) + ALL_BLOCK_SYMBOLS (block, iter, sym) { - sym = BLOCK_SYM (block, i); switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -271,6 +277,7 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) case LOC_REGPARM_ADDR: case LOC_BASEREG_ARG: case LOC_LOCAL_ARG: + case LOC_COMPUTED_ARG: nparams++; break; case LOC_UNDEF: @@ -286,6 +293,7 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) case LOC_BASEREG: case LOC_UNRESOLVED: case LOC_OPTIMIZED_OUT: + case LOC_COMPUTED: default: break; } @@ -295,10 +303,13 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) TYPE_NFIELDS (ftype) = nparams; TYPE_FIELDS (ftype) = (struct field *) TYPE_ALLOC (ftype, nparams * sizeof (struct field)); - - for (i = iparams = 0; iparams < nparams; i++) + + iparams = 0; + ALL_BLOCK_SYMBOLS (block, iter, sym) { - sym = BLOCK_SYM (block, i); + if (iparams == nparams) + break; + switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -307,13 +318,15 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) case LOC_REGPARM_ADDR: case LOC_BASEREG_ARG: case LOC_LOCAL_ARG: + case LOC_COMPUTED_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_INDIRECT: case LOC_REGISTER: case LOC_LOCAL: case LOC_TYPEDEF: @@ -323,12 +336,19 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) case LOC_BASEREG: case LOC_UNRESOLVED: case LOC_OPTIMIZED_OUT: + case LOC_COMPUTED: default: break; } } } } + + /* If we're in the C++ case, set the block's scope. */ + if (SYMBOL_LANGUAGE (symbol) == language_cplus) + { + cp_set_block_scope (symbol, block, &objfile->objfile_obstack); + } } else { @@ -353,43 +373,52 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) { if (symbol) { - complain (&block_end_complaint, SYMBOL_SOURCE_NAME (symbol)); + complaint (&symfile_complaints, + "block end address less than block start address in %s (patched it)", + SYMBOL_PRINT_NAME (symbol)); } else { - complain (&anon_block_end_complaint, BLOCK_END (block), BLOCK_START (block)); + complaint (&symfile_complaints, + "block end address 0x%s less than block start address 0x%s (patched it)", + paddr_nz (BLOCK_END (block)), paddr_nz (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. */ + /* 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) + for (pblock = pending_blocks; + pblock && pblock != old_blocks; + pblock = pblock->next) { 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_SOURCE_NAME (symbol)); + complaint (&symfile_complaints, + "inner block not inside outer block in %s", + SYMBOL_PRINT_NAME (symbol)); } else { - complain (&innerblock_anon_complaint, BLOCK_START (pblock->block), - BLOCK_END (pblock->block), BLOCK_START (block), - BLOCK_END (block)); + complaint (&symfile_complaints, + "inner block (0x%s-0x%s) not inside outer block (0x%s-0x%s)", + paddr_nz (BLOCK_START (pblock->block)), + paddr_nz (BLOCK_END (pblock->block)), + paddr_nz (BLOCK_START (block)), + paddr_nz (BLOCK_END (block))); } if (BLOCK_START (pblock->block) < BLOCK_START (block)) BLOCK_START (pblock->block) = BLOCK_START (block); @@ -405,62 +434,58 @@ finish_block (symbol, listhead, old_blocks, start, end, objfile) 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. + 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 + Allocate the pending block struct in the objfile_obstack to save time. This wastes a little space. FIXME: Is it worth it? */ void -record_pending_block (objfile, block, opblock) - struct objfile* objfile; - struct block *block; - struct pending_block *opblock; +record_pending_block (struct objfile *objfile, struct block *block, + struct pending_block *opblock) { - register struct pending_block *pblock; + struct pending_block *pblock; pblock = (struct pending_block *) - obstack_alloc (&objfile -> symbol_obstack, sizeof (struct pending_block)); - pblock -> block = block; + obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block)); + pblock->block = block; if (opblock) { - pblock -> next = opblock -> next; - opblock -> next = pblock; + pblock->next = opblock->next; + opblock->next = pblock; } else { - pblock -> next = pending_blocks; + pblock->next = pending_blocks; pending_blocks = pblock; } } -/* 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 (objfile) - struct objfile *objfile; +static struct blockvector * +make_blockvector (struct objfile *objfile) { - register struct pending_block *next; - register struct blockvector *blockvector; - register int i; + struct pending_block *next; + struct blockvector *blockvector; + int i; /* 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->objfile_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) @@ -468,39 +493,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))) { + CORE_ADDR start + = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)); - /* FIXME-32x64: loses if CORE_ADDR doesn't fit in a - long. Possible solutions include a version of - complain which takes a callback, a - sprintf_address_numeric to match - print_address_numeric, or a way to set up a GDB_FILE - * which causes sprintf rather than fprintf to be - called. */ - - complain (&blockvector_complaint, - (unsigned long) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i))); + complaint (&symfile_complaints, "block at %s out of order", + local_hex_string ((LONGEST) start)); } } } @@ -508,37 +529,35 @@ 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. NAME is - the name of the file (cannot be NULL), DIRNAME is the directory in which - it resides (or NULL if not known). */ +/* 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; + 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 (STREQ (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; @@ -547,20 +566,20 @@ start_subfile (name, 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. */ + /* 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 && @@ -573,15 +592,9 @@ start_subfile (name, dirname) 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). */ + /* 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. */ /* Likewise for f2c. */ if (subfile->name) @@ -605,40 +618,38 @@ start_subfile (name, dirname) } } -/* 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 = 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. */ + 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 && @@ -648,53 +659,48 @@ patch_subfile_names (subfile, name) } } } - -/* 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 *tem + = (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; + char *name; + 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); } - -/* Add a linetable entry for line number LINE and address PC to the line - vector for 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 (struct subfile *subfile, int line, CORE_ADDR pc) { struct linetable_entry *e; /* Ignore the dummy line number in libg.o */ @@ -710,7 +716,7 @@ 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; } @@ -719,21 +725,21 @@ record_line (subfile, line, pc) { 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 void *ln1p; - const void *ln2p; +compare_line_numbers (const void *ln1p, const void *ln2p) { struct linetable_entry *ln1 = (struct linetable_entry *) ln1p; struct linetable_entry *ln2 = (struct linetable_entry *) ln2p; @@ -750,18 +756,14 @@ compare_line_numbers (ln1p, ln2p) 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; @@ -771,8 +773,8 @@ start_symtab (name, dirname, start_addr) 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; @@ -781,61 +783,63 @@ 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). */ + /* Set up support for C++ namespace support, in case we need it. */ + + cp_initialize_namespace (); + + /* 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. - SECTION is the section number (in objfile->section_offsets) of - the blockvector and linetable. + 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, objfile, section) - CORE_ADDR end_addr; - struct objfile *objfile; - int section; +end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section) { - register struct symtab *symtab = NULL; - register struct blockvector *blockvector; - register struct subfile *subfile; - register struct context_stack *cstk; + struct symtab *symtab = NULL; + struct blockvector *blockvector; + struct subfile *subfile; + 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) { - cstk = pop_context(); + 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); if (context_stack_depth > 0) { - /* 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); + /* 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(). */ + complaint (&symfile_complaints, + "Context stack not empty in end_symtab"); context_stack_depth = 0; } } @@ -849,7 +853,7 @@ end_symtab (end_addr, objfile, section) do { struct pending_block *pb, *pbnext; - + pb = pending_blocks; pbnext = pb->next; swapped = 0; @@ -857,8 +861,8 @@ end_symtab (end_addr, objfile, section) 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; @@ -868,7 +872,8 @@ end_symtab (end_addr, objfile, section) pb = pbnext; pbnext = pbnext->next; } - } while (swapped); + } + while (swapped); } /* Cleanup any undefined types that have been left hanging around @@ -887,25 +892,30 @@ end_symtab (end_addr, objfile, section) if (pending_blocks == NULL && file_symbols == NULL && global_symbols == NULL - && have_line_numbers == 0) + && have_line_numbers == 0 + && pending_macros == NULL) { - /* 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, objfile); blockvector = make_blockvector (objfile); + cp_finalize_namespace (BLOCKVECTOR_BLOCK (blockvector, STATIC_BLOCK), + &objfile->objfile_obstack); } #ifndef PROCESS_LINENUMBER_HOOK #define PROCESS_LINENUMBER_HOOK() #endif - PROCESS_LINENUMBER_HOOK (); /* Needed for xcoff. */ + 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.) */ @@ -913,31 +923,32 @@ end_symtab (end_addr, objfile, section) for (subfile = subfiles; subfile; subfile = nextsub) { 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 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) { 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. */ + /* 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 - /* Like the pending blocks, the line table may be scrambled - in reordered executables. Sort it if OBJF_REORDERED is - true. */ + /* 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. */ @@ -945,11 +956,12 @@ end_symtab (end_addr, objfile, section) /* Fill in its components. */ symtab->blockvector = blockvector; + symtab->macro_table = pending_macros; 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->objfile_obstack, linetablesize); memcpy (symtab->linetable, subfile->line_vector, linetablesize); } else @@ -961,8 +973,8 @@ end_symtab (end_addr, objfile, section) { /* Reallocate the dirname on the symbol obstack */ symtab->dirname = (char *) - obstack_alloc (&objfile -> symbol_obstack, - strlen (subfile -> dirname) + 1); + obstack_alloc (&objfile->objfile_obstack, + strlen (subfile->dirname) + 1); strcpy (symtab->dirname, subfile->dirname); } else @@ -970,48 +982,49 @@ end_symtab (end_addr, objfile, section) symtab->dirname = NULL; } symtab->free_code = free_linetable; - symtab->free_ptr = NULL; - - /* 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->free_func = NULL; + + /* 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; /* Save the debug format string (if any) in the symtab */ - if (subfile -> debugformat != NULL) + if (subfile->debugformat != NULL) { symtab->debugformat = obsavestring (subfile->debugformat, - strlen (subfile->debugformat), - &objfile -> symbol_obstack); + strlen (subfile->debugformat), + &objfile->objfile_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. */ + 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) { - free ((PTR) subfile->debugformat); + xfree ((void *) subfile->debugformat); } nextsub = subfile->next; - free ((PTR)subfile); + xfree ((void *) subfile); } /* Set this for the main source file. */ @@ -1022,20 +1035,19 @@ end_symtab (end_addr, objfile, section) last_source_file = NULL; current_subfile = NULL; + pending_macros = 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; + struct context_stack *new; if (context_stack_depth == context_stack_size) { @@ -1056,93 +1068,76 @@ push_context (desc, valu) local_symbols = NULL; param_symbols = NULL; - return (new); + return new; +} + +/* Pop a context block. Returns the address of the context block just + popped. */ + +struct context_stack * +pop_context (void) +{ + gdb_assert (context_stack_depth > 0); + return (&context_stack[--context_stack_depth]); } + /* Compute a small integer hash code for the given name. */ int -hashname (name) - char *name; +hashname (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); + return (hash(name,strlen(name)) % HASHSIZE); } - + void -record_debugformat (format) - char *format; +record_debugformat (char *format) { - current_subfile -> debugformat = savestring (format, strlen (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 return. */ void -merge_symbol_lists (srclist, targetlist) - struct pending ** srclist; - struct pending ** targetlist; +merge_symbol_lists (struct pending **srclist, struct pending **targetlist) { - register int i; + int i; if (!srclist || !*srclist) return; - /* Merge in elements from current link */ - for (i=0; i < (*srclist)->nsyms; i++) + /* Merge in elements from current link. */ + for (i = 0; i < (*srclist)->nsyms; i++) add_symbol_to_list ((*srclist)->symbol[i], targetlist); - /* Recurse on next */ + /* Recurse on next. */ merge_symbol_lists (&(*srclist)->next, targetlist); - - /* "Free" the current link */ + + /* "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; global_symbols = NULL; pending_blocks = NULL; + pending_macros = NULL; } /* Initialize anything that needs initializing when a completely new @@ -1150,7 +1145,7 @@ buildsym_init () file, e.g. a shared library). */ void -buildsym_new_init () +buildsym_new_init (void) { buildsym_init (); }