}
else
{
- link = (struct pending *) xmalloc (sizeof (struct pending));
+ link = XNEW (struct pending);
}
link->next = *listhead;
file). Put the block on the list of pending blocks. */
static struct block *
-finish_block_internal (struct symbol *symbol, struct pending **listhead,
+finish_block_internal (struct symbol *symbol,
+ struct pending **listhead,
struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
CORE_ADDR start, CORE_ADDR end,
int is_global, int expandable)
{
BLOCK_FUNCTION (block) = NULL;
}
+ if (static_link != NULL)
+ objfile_register_static_link (objfile, block, static_link);
+
/* Now "free" the links of the list, and empty the list. */
for (next = *listhead; next; next = next1)
opblock = pblock;
}
- block_set_using (block, using_directives, &objfile->objfile_obstack);
- using_directives = NULL;
+ block_set_using (block,
+ (is_global
+ ? global_using_directives
+ : local_using_directives),
+ &objfile->objfile_obstack);
+ if (is_global)
+ global_using_directives = NULL;
+ else
+ local_using_directives = NULL;
record_pending_block (objfile, block, opblock);
}
struct block *
-finish_block (struct symbol *symbol, struct pending **listhead,
+finish_block (struct symbol *symbol,
+ struct pending **listhead,
struct pending_block *old_blocks,
+ const struct dynamic_prop *static_link,
CORE_ADDR start, CORE_ADDR end)
{
- return finish_block_internal (symbol, listhead, old_blocks,
+ return finish_block_internal (symbol, listhead, old_blocks, static_link,
start, end, 0, 0);
}
if (pending_blocks == NULL)
obstack_init (&pending_block_obstack);
- pblock = (struct pending_block *)
- obstack_alloc (&pending_block_obstack, sizeof (struct pending_block));
+ pblock = XOBNEW (&pending_block_obstack, struct pending_block);
pblock->block = block;
if (opblock)
{
/* This subfile is not known. Add an entry for it. */
- subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
+ subfile = XNEW (struct subfile);
memset (subfile, 0, sizeof (struct subfile));
subfile->buildsym_compunit = buildsym_compunit;
{
struct buildsym_compunit *bscu;
- bscu = (struct buildsym_compunit *)
- xmalloc (sizeof (struct buildsym_compunit));
+ bscu = XNEW (struct buildsym_compunit);
memset (bscu, 0, sizeof (struct buildsym_compunit));
bscu->objfile = objfile;
void
push_subfile (void)
{
- struct subfile_stack *tem
- = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
+ struct subfile_stack *tem = XNEW (struct subfile_stack);
tem->next = subfile_stack;
subfile_stack = tem;
last_source_start_addr = start_addr;
local_symbols = NULL;
+ local_using_directives = NULL;
within_function = 0;
have_line_numbers = 0;
a symtab, or by the really_free_pendings cleanup. */
gdb_assert (file_symbols == NULL);
gdb_assert (global_symbols == NULL);
+ gdb_assert (global_using_directives == NULL);
gdb_assert (pending_macros == NULL);
gdb_assert (pending_addrmap == NULL);
gdb_assert (current_subfile == NULL);
set_last_source_file (NULL);
local_symbols = NULL;
+ local_using_directives = NULL;
file_symbols = NULL;
global_symbols = NULL;
+ global_using_directives = NULL;
/* We don't free pending_macros here because if the symtab was successfully
built then ownership was transferred to the symtab. */
struct context_stack *cstk = pop_context ();
/* Make a block for the local symbols within. */
- finish_block (cstk->name, &local_symbols, cstk->old_blocks,
+ finish_block (cstk->name, &local_symbols, cstk->old_blocks, NULL,
cstk->start_addr, end_addr);
if (context_stack_depth > 0)
for (pb = pending_blocks; pb != NULL; pb = pb->next)
count++;
- barray = xmalloc (sizeof (*barray) * count);
+ barray = XNEWVEC (struct block *, count);
back_to = make_cleanup (xfree, barray);
bp = barray;
&& file_symbols == NULL
&& global_symbols == NULL
&& have_line_numbers == 0
- && pending_macros == NULL)
+ && pending_macros == NULL
+ && global_using_directives == NULL)
{
/* Ignore symtabs that have no functions with real debugging info. */
return NULL;
else
{
/* Define the STATIC_BLOCK. */
- return finish_block_internal (NULL, &file_symbols, NULL,
+ return finish_block_internal (NULL, &file_symbols, NULL, NULL,
last_source_start_addr, end_addr,
0, expandable);
}
end_addr = BLOCK_END (static_block);
/* Create the GLOBAL_BLOCK and build the blockvector. */
- finish_block_internal (NULL, &global_symbols, NULL,
+ finish_block_internal (NULL, &global_symbols, NULL, NULL,
last_source_start_addr, end_addr,
1, expandable);
blockvector = make_blockvector ();
struct context_stack *
push_context (int desc, CORE_ADDR valu)
{
- struct context_stack *new;
+ struct context_stack *newobj;
if (context_stack_depth == context_stack_size)
{
(context_stack_size * sizeof (struct context_stack)));
}
- new = &context_stack[context_stack_depth++];
- new->depth = desc;
- new->locals = local_symbols;
- new->old_blocks = pending_blocks;
- new->start_addr = valu;
- new->using_directives = using_directives;
- new->name = NULL;
+ newobj = &context_stack[context_stack_depth++];
+ newobj->depth = desc;
+ newobj->locals = local_symbols;
+ newobj->old_blocks = pending_blocks;
+ newobj->start_addr = valu;
+ newobj->local_using_directives = local_using_directives;
+ newobj->name = NULL;
local_symbols = NULL;
- using_directives = NULL;
+ local_using_directives = NULL;
- return new;
+ return newobj;
}
/* Pop a context block. Returns the address of the context block just
void
buildsym_init (void)
{
- using_directives = NULL;
subfile_stack = NULL;
pending_addrmap_interesting = 0;
if (context_stack == NULL)
{
context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
- context_stack = (struct context_stack *)
- xmalloc (context_stack_size * sizeof (struct context_stack));
+ context_stack = XNEWVEC (struct context_stack, context_stack_size);
}
/* Ensure the really_free_pendings cleanup was called after
gdb_assert (pending_blocks == NULL);
gdb_assert (file_symbols == NULL);
gdb_assert (global_symbols == NULL);
+ gdb_assert (global_using_directives == NULL);
gdb_assert (pending_macros == NULL);
gdb_assert (pending_addrmap == NULL);
gdb_assert (buildsym_compunit == NULL);