#include "gdb_string.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;
\f
static int
compare_line_numbers PARAMS ((const void *, const void *));
-
\f
-/* 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
-
\f
+
/* 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};
+{"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};
+{"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 (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};
+{"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};
\f
/* maintain the lists of symbols and blocks */
/* 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)
(*listhead)->symbol[(*listhead)->nsyms++] = 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)
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 &&
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
for (next = free_pendings; next; next = next1)
{
next1 = next->next;
- free ((PTR)next);
+ free ((PTR) next);
}
free_pendings = NULL;
for (next = file_symbols; next != NULL; next = next1)
{
next1 = next->next;
- free ((PTR)next);
+ free ((PTR) next);
}
file_symbols = NULL;
for (next = global_symbols; next != NULL; next = next1)
{
next1 = next->next;
- free ((PTR)next);
+ free ((PTR) next);
}
global_symbols = NULL;
}
void
free_pending_blocks ()
{
-#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
+ symbol_obstack, so don't free
+ them. */
struct pending_block *bnext, *bnext1;
for (bnext = pending_blocks; bnext; bnext = bnext1)
{
bnext1 = bnext->next;
- free ((PTR)bnext);
+ free ((PTR) 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)
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. */
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;
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++)
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);
case LOC_UNDEF:
case LOC_CONST:
case LOC_STATIC:
- case LOC_INDIRECT:
+ case LOC_INDIRECT:
case LOC_REGISTER:
case LOC_LOCAL:
case LOC_TYPEDEF:
}
#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)
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)
{
else
{
complain (&innerblock_anon_complaint, BLOCK_START (pblock->block),
- BLOCK_END (pblock->block), BLOCK_START (block),
+ BLOCK_END (pblock->block), BLOCK_START (block),
BLOCK_END (block));
}
if (BLOCK_START (pblock->block) < BLOCK_START (block))
}
/* 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
time. This wastes a little space. FIXME: Is it worth it? */
void
record_pending_block (objfile, block, opblock)
- struct objfile* objfile;
+ struct objfile *objfile;
struct block *block;
struct pending_block *opblock;
{
register struct pending_block *pblock;
pblock = (struct pending_block *)
- obstack_alloc (&objfile -> symbol_obstack, sizeof (struct pending_block));
- pblock -> block = block;
+ obstack_alloc (&objfile->symbol_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. */
+/* 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)
/* 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)
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)
#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)))
{
/* 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)));
+ 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)));
}
}
}
return (blockvector);
}
-
\f
-/* 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)
{
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)
{
}
}
- /* 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));
subfile->next = subfiles;
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 &&
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). */
+
+ 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)
}
}
-/* 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)
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 &&
}
}
}
-
\f
-/* 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 ()
{
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;
}
name = link->name;
subfile_stack = link->next;
- free ((PTR)link);
+ free ((PTR) link);
return (name);
}
-
\f
-/* 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)
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;
}
{
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 = pc;
}
-
/* Needed in order to sort line tables from IBM xcoff files. Sigh! */
static int
behavior (see comment at struct linetable in symtab.h). */
return ln1->line - ln2->line;
}
-
\f
-/* 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)
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;
}
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.
- 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)
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)
{
- 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(). */
+ /* 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};
+ {"Context stack not empty in end_symtab", 0, 0};
complain (&msg);
context_stack_depth = 0;
}
do
{
struct pending_block *pb, *pbnext;
-
+
pb = pending_blocks;
pbnext = pb->next;
swapped = 0;
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;
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).
-
+
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
&& 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,
#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.) */
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,
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
{
/* 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
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. */
+ /* 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->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. */
+ blockvector, so we need to clear primary for everything
+ but the main file. */
symtab->primary = 0;
}
}
nextsub = subfile->next;
- free ((PTR)subfile);
+ free ((PTR) subfile);
}
/* Set this for the main source file. */
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)
context_stack_size *= 2;
context_stack = (struct context_stack *)
xrealloc ((char *) context_stack,
- (context_stack_size * sizeof (struct context_stack)));
+ (context_stack_size * sizeof (struct context_stack)));
}
new = &context_stack[context_stack_depth++];
local_symbols = NULL;
param_symbols = NULL;
- return (new);
+ return new;
}
-
\f
/* Compute a small integer hash code for the given name. */
}
return (total % HASHSIZE);
}
-
\f
+
void
record_debugformat (format)
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;
+ 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++)
+ /* 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);
}
-
-
-
\f
-/* 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 ()
/* Build symbol tables in GDB's internal format.
- Copyright (C) 1986-1996 Free Software Foundation, Inc.
+ Copyright 1986-1993, 1996-1999 Free Software Foundation, Inc.
This file is part of GDB.
/* This module provides definitions used for creating and adding to
the symbol table. These routines are called from various symbol-
- file-reading routines.
+ file-reading routines.
They originated in dbxread.c of gdb-4.2, and were split out to
make xcoffread.c more maintainable by sharing code.
- Variables declared in this file can be defined by #define-ing
- the name EXTERN to null. It is used to declare variables that
- are normally extern, but which get defined in a single module
- using this technique. */
+ Variables declared in this file can be defined by #define-ing the
+ name EXTERN to null. It is used to declare variables that are
+ normally extern, but which get defined in a single module using
+ this technique. */
#ifndef EXTERN
#define EXTERN extern
#endif
-#define HASHSIZE 127 /* Size of things hashed via hashname() */
+#define HASHSIZE 127 /* Size of things hashed via
+ hashname() */
-/* Name of source file whose symbol data we are now processing.
- This comes from a symbol of type N_SO. */
+/* Name of source file whose symbol data we are now processing. This
+ comes from a symbol of type N_SO. */
EXTERN char *last_source_file;
-/* Core address of start of text of current source file.
- This too comes from the N_SO symbol. */
+/* Core address of start of text of current source file. This too
+ comes from the N_SO symbol. */
EXTERN CORE_ADDR last_source_start_addr;
-/* The list of sub-source-files within the current individual compilation.
- Each file gets its own symtab with its own linetable and associated info,
- but they all share one blockvector. */
+/* The list of sub-source-files within the current individual
+ compilation. Each file gets its own symtab with its own linetable
+ and associated info, but they all share one blockvector. */
struct subfile
-{
- struct subfile *next;
- char *name;
- char *dirname;
- struct linetable *line_vector;
- int line_vector_length;
- enum language language;
- char *debugformat;
-};
+ {
+ struct subfile *next;
+ char *name;
+ char *dirname;
+ struct linetable *line_vector;
+ int line_vector_length;
+ enum language language;
+ char *debugformat;
+ };
EXTERN struct subfile *subfiles;
/* elz: added this flag to know when a block is compiled with HP
compilers (cc, aCC). This is necessary because of the macro
- COERCE_FLOAT_TO_DOUBLE defined in tm_hppa.h, which causes
- a coercion of float to double to always occur in parameter passing
- for a function called by gdb (see the function value_arg_coerce in
- valops.c). This is necessary only if the target
- was compiled with gcc, not with HP compilers or with g++ */
+ COERCE_FLOAT_TO_DOUBLE defined in tm_hppa.h, which causes a
+ coercion of float to double to always occur in parameter passing
+ for a function called by gdb (see the function value_arg_coerce in
+ valops.c). This is necessary only if the target was compiled with
+ gcc, not with HP compilers or with g++ */
EXTERN unsigned char processing_hp_compilation;
EXTERN unsigned int symnum;
-/* Record the symbols defined for each context in a list.
- We don't create a struct block for the context until we
- know how long to make it. */
+/* Record the symbols defined for each context in a list. We don't
+ create a struct block for the context until we know how long to
+ make it. */
#define PENDINGSIZE 100
struct pending
-{
- struct pending *next;
- int nsyms;
- struct symbol *symbol[PENDINGSIZE];
-};
+ {
+ struct pending *next;
+ int nsyms;
+ struct symbol *symbol[PENDINGSIZE];
+ };
/* Here are the three lists that symbols are put on. */
-EXTERN struct pending *file_symbols; /* static at top level, and types */
+/* static at top level, and types */
-EXTERN struct pending *global_symbols; /* global functions and variables */
+EXTERN struct pending *file_symbols;
-EXTERN struct pending *local_symbols; /* everything local to lexic context */
+/* global functions and variables */
-EXTERN struct pending *param_symbols; /* func params local to lexic context */
+EXTERN struct pending *global_symbols;
-/* Stack representing unclosed lexical contexts
- (that will become blocks, eventually). */
+/* everything local to lexical context */
+
+EXTERN struct pending *local_symbols;
+
+/* func params local to lexical context */
+
+EXTERN struct pending *param_symbols;
+
+/* Stack representing unclosed lexical contexts (that will become
+ blocks, eventually). */
struct context_stack
-{
- /* Outer locals at the time we entered */
+ {
+ /* Outer locals at the time we entered */
- struct pending *locals;
+ struct pending *locals;
- /* Pending func params at the time we entered */
+ /* Pending func params at the time we entered */
- struct pending *params;
+ struct pending *params;
- /* Pointer into blocklist as of entry */
+ /* Pointer into blocklist as of entry */
- struct pending_block *old_blocks;
+ struct pending_block *old_blocks;
- /* Name of function, if any, defining context*/
+ /* Name of function, if any, defining context */
- struct symbol *name;
+ struct symbol *name;
- /* PC where this context starts */
+ /* PC where this context starts */
- CORE_ADDR start_addr;
+ CORE_ADDR start_addr;
- /* Temp slot for exception handling. */
+ /* Temp slot for exception handling. */
- CORE_ADDR end_addr;
+ CORE_ADDR end_addr;
- /* For error-checking matching push/pop */
+ /* For error-checking matching push/pop */
- int depth;
+ int depth;
-};
+ };
EXTERN struct context_stack *context_stack;
EXTERN int context_stack_size;
-/* Macro "function" for popping contexts from the stack. Pushing is done
- by a real function, push_context. This returns a pointer to a struct
- context_stack. */
+/* Macro "function" for popping contexts from the stack. Pushing is
+ done by a real function, push_context. This returns a pointer to a
+ struct context_stack. */
#define pop_context() (&context_stack[--context_stack_depth]);
-/* Nonzero if within a function (so symbols should be local,
- if nothing says specifically). */
+/* Nonzero if within a function (so symbols should be local, if
+ nothing says specifically). */
EXTERN int within_function;
This is used at the end to make the blockvector. */
struct pending_block
-{
- struct pending_block *next;
- struct block *block;
-};
+ {
+ struct pending_block *next;
+ struct block *block;
+ };
/* Pointer to the head of a linked list of symbol blocks which have
- already been finalized (lexical contexts already closed) and which are
- just waiting to be built into a blockvector when finalizing the
+ already been finalized (lexical contexts already closed) and which
+ are just waiting to be built into a blockvector when finalizing the
associated symtab. */
EXTERN struct pending_block *pending_blocks;
-
\f
+
struct subfile_stack
-{
- struct subfile_stack *next;
- char *name;
-};
+ {
+ struct subfile_stack *next;
+ char *name;
+ };
EXTERN struct subfile_stack *subfile_stack;
EXTERN char *(*next_symbol_text_func) PARAMS ((struct objfile *));
/* Vector of types defined so far, indexed by their type numbers.
- Used for both stabs and coff.
- (In newer sun systems, dbx uses a pair of numbers in parens,
- as in "(SUBFILENUM,NUMWITHINSUBFILE)". Then these numbers must be
- translated through the type_translations hash table to get
- the index into the type vector.) */
+ Used for both stabs and coff. (In newer sun systems, dbx uses a
+ pair of numbers in parens, as in "(SUBFILENUM,NUMWITHINSUBFILE)".
+ Then these numbers must be translated through the type_translations
+ hash table to get the index into the type vector.) */
EXTERN struct type **type_vector;
EXTERN int type_vector_length;
-/* Initial size of type vector. Is realloc'd larger if needed,
- and realloc'd down to the size actually used, when completed. */
+/* Initial size of type vector. Is realloc'd larger if needed, and
+ realloc'd down to the size actually used, when completed. */
#define INITIAL_TYPE_VECTOR_LENGTH 160
add_symbol_to_list PARAMS ((struct symbol *, struct pending **));
extern struct symbol *
-find_symbol_in_list PARAMS ((struct pending *, char *, int));
+ find_symbol_in_list PARAMS ((struct pending *, char *, int));
extern void
finish_block PARAMS ((struct symbol *, struct pending **,
start_subfile PARAMS ((char *, char *));
extern void
-patch_subfile_names PARAMS ((struct subfile *subfile, char *name));
+patch_subfile_names PARAMS ((struct subfile * subfile, char *name));
extern void
push_subfile PARAMS ((void));
extern char *
-pop_subfile PARAMS ((void));
+ pop_subfile PARAMS ((void));
extern struct symtab *
-end_symtab PARAMS ((CORE_ADDR, struct objfile *, int));
+ end_symtab PARAMS ((CORE_ADDR, struct objfile *, int));
extern void
scan_file_globals PARAMS ((struct objfile *));
buildsym_init PARAMS ((void));
extern struct context_stack *
-push_context PARAMS ((int, CORE_ADDR));
+ push_context PARAMS ((int, CORE_ADDR));
extern void
record_line PARAMS ((struct subfile *, int, CORE_ADDR));
free_pending_blocks PARAMS ((void));
/* FIXME: Note that this is used only in buildsym.c and dstread.c,
- which should be fixed to not need direct access to make_blockvector. */
+ which should be fixed to not need direct access to
+ make_blockvector. */
extern struct blockvector *
-make_blockvector PARAMS ((struct objfile *));
+ make_blockvector PARAMS ((struct objfile *));
/* FIXME: Note that this is used only in buildsym.c and dstread.c,
- which should be fixed to not need direct access to record_pending_block. */
+ which should be fixed to not need direct access to
+ record_pending_block. */
extern void
record_pending_block PARAMS ((struct objfile *, struct block *,
#undef EXTERN
-#endif /* defined (BUILDSYM_H) */
+#endif /* defined (BUILDSYM_H) */
projects / external / binutils.git / commitdiff