/* Support routines for building symbol tables in GDB's internal format.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ Free Software Foundation, Inc.
This file is part of GDB.
#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 INITIAL_LINE_VECTOR_LENGTH 1000
\f
-/* Complaints about the symbols we have encountered. */
-
-struct deprecated_complaint block_end_complaint =
-{"block end address less than block start address in %s (patched it)", 0, 0};
-
-struct deprecated_complaint anon_block_end_complaint =
-{"block end address 0x%lx less than block start address 0x%lx (patched it)", 0, 0};
-
-struct deprecated_complaint innerblock_complaint =
-{"inner block not inside outer block in %s", 0, 0};
-
-struct deprecated_complaint innerblock_anon_complaint =
-{"inner block (0x%lx-0x%lx) not inside outer block (0x%lx-0x%lx)", 0, 0};
-
-struct deprecated_complaint blockvector_complaint =
-{"block at %s out of order", 0, 0};
-\f
/* 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;
+ struct pending *link = list;
if (list)
{
}
}
-/* Add a symbol to one of the lists of symbols. */
+/* 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 (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] == '#')
}
(*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
{
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')
{
/* 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 (PTR dummy)
+really_free_pendings (void *dummy)
{
struct pending *next, *next1;
free_pending_blocks (void)
{
#if 0 /* Now we make the links in the
- symbol_obstack, so don't free
+ objfile_obstack, so don't free
them. */
struct pending_block *bnext, *bnext1;
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. */
- for (next = *listhead, i = 0;
- next;
- i += next->nsyms, next = next->next)
- {
- /* EMPTY */ ;
- }
-
- /* Copy the symbols into the block. */
+ block = allocate_block (&objfile->objfile_obstack);
if (symbol)
{
- block = (struct block *)
- obstack_alloc (&objfile->symbol_obstack,
- (sizeof (struct block) +
- ((i - 1) * sizeof (struct symbol *))));
- BLOCK_NSYMS (block) = i;
- for (next = *listhead; next; next = next->next)
- for (j = next->nsyms - 1; j >= 0; j--)
- {
- BLOCK_SYM (block, --i) = next->symbol[j];
- }
+ BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack,
+ *listhead);
}
else
{
- int htab_size = BLOCK_HASHTABLE_SIZE (i);
-
- block = (struct block *)
- obstack_alloc (&objfile->symbol_obstack,
- (sizeof (struct block) +
- ((htab_size - 1) * sizeof (struct symbol *))));
- for (j = 0; j < htab_size; j++)
- {
- BLOCK_BUCKET (block, j) = 0;
- }
- BLOCK_BUCKETS (block) = htab_size;
- for (next = *listhead; next; next = next->next)
- {
- for (j = next->nsyms - 1; j >= 0; j--)
- {
- struct symbol *sym;
- unsigned int hash_index;
- const char *name = SYMBOL_DEMANGLED_NAME (next->symbol[j]);
- if (name == NULL)
- name = SYMBOL_NAME (next->symbol[j]);
- hash_index = msymbol_hash_iw (name);
- hash_index = hash_index % BLOCK_BUCKETS (block);
- sym = BLOCK_BUCKET (block, hash_index);
- BLOCK_BUCKET (block, hash_index) = next->symbol[j];
- next->symbol[j]->hash_next = sym;
- }
- }
+ 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 */
BLOCK_SUPERBLOCK (block) = NULL;
+ BLOCK_NAMESPACE (block) = NULL;
BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
if (symbol)
{
struct type *ftype = SYMBOL_TYPE (symbol);
+ struct dict_iterator iter;
SYMBOL_BLOCK_VALUE (symbol) = block;
BLOCK_FUNCTION (block) = symbol;
- BLOCK_HASHTABLE (block) = 0;
if (TYPE_NFIELDS (ftype) <= 0)
{
parameter symbols. */
int nparams = 0, iparams;
struct symbol *sym;
- ALL_BLOCK_SYMBOLS (block, i, sym)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
switch (SYMBOL_CLASS (sym))
{
case LOC_REGPARM_ADDR:
case LOC_BASEREG_ARG:
case LOC_LOCAL_ARG:
+ case LOC_COMPUTED_ARG:
nparams++;
break;
case LOC_UNDEF:
case LOC_BASEREG:
case LOC_UNRESOLVED:
case LOC_OPTIMIZED_OUT:
+ case LOC_COMPUTED:
default:
break;
}
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:
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++;
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
{
BLOCK_FUNCTION (block) = NULL;
- BLOCK_HASHTABLE (block) = 1;
}
/* Now "free" the links of the list, and empty the list. */
{
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);
{
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);
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
+ 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 (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));
+ obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block));
pblock->block = block;
if (opblock)
{
}
}
-/* OBSOLETE Note that this is only used in this file and in dstread.c, which */
-/* OBSOLETE should be fixed to not need direct access to this function. When */
-/* OBSOLETE that is done, it can be made static again. */
-
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. */
}
blockvector = (struct blockvector *)
- obstack_alloc (&objfile->symbol_obstack,
+ obstack_alloc (&objfile->objfile_obstack,
(sizeof (struct blockvector)
+ (i - 1) * sizeof (struct block *)));
CORE_ADDR start
= BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i));
- complain (&blockvector_complaint,
- local_hex_string ((LONGEST) start));
+ complaint (&symfile_complaints, _("block at %s out of order"),
+ hex_string ((LONGEST) start));
}
}
}
void
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. */
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
+ /* 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). */
+ any other C++ suffixes accepted by deduce_language_from_filename. */
/* Likewise for f2c. */
if (subfile->name)
void
push_subfile (void)
{
- register struct subfile_stack *tem
+ 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)
{
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
tem->name = current_subfile->name;
}
char *
pop_subfile (void)
{
- register char *name;
- register struct subfile_stack *link = subfile_stack;
+ char *name;
+ struct subfile_stack *link = subfile_stack;
if (link == NULL)
{
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
}
name = link->name;
subfile_stack = link->next;
line vector for SUBFILE. */
void
-record_line (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 */
}
context_stack_depth = 0;
+ /* 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). */
struct symtab *
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
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 deprecated_complaint msg =
- {"Context stack not empty in end_symtab", 0, 0};
- complain (&msg);
+ complaint (&symfile_complaints,
+ _("Context stack not empty in end_symtab"));
context_stack_depth = 0;
}
}
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
{
/* Reallocate the line table on the symbol obstack */
symtab->linetable = (struct linetable *)
- obstack_alloc (&objfile->symbol_obstack, linetablesize);
+ obstack_alloc (&objfile->objfile_obstack, linetablesize);
memcpy (symtab->linetable, subfile->line_vector, linetablesize);
}
else
{
/* Reallocate the dirname on the symbol obstack */
symtab->dirname = (char *)
- obstack_alloc (&objfile->symbol_obstack,
+ obstack_alloc (&objfile->objfile_obstack,
strlen (subfile->dirname) + 1);
strcpy (symtab->dirname, subfile->dirname);
}
symtab->dirname = NULL;
}
symtab->free_code = free_linetable;
- symtab->free_ptr = NULL;
+ symtab->free_func = NULL;
/* Use whatever language we have been using for this
subfile, not the one that was deduced in allocate_symtab
{
symtab->debugformat = obsavestring (subfile->debugformat,
strlen (subfile->debugformat),
- &objfile->symbol_obstack);
+ &objfile->objfile_obstack);
}
/* All symtabs for the main file and the subfiles share a
struct context_stack *
push_context (int desc, CORE_ADDR valu)
{
- register struct context_stack *new;
+ struct context_stack *new;
if (context_stack_depth == context_stack_size)
{
void
merge_symbol_lists (struct pending **srclist, struct pending **targetlist)
{
- register int i;
+ int i;
if (!srclist || !*srclist)
return;
projects / deliverable / binutils-gdb.git / blobdiff