4137c5fc0d
(record_line): Record directly in a subfile. Alloc on demand. (compare_line_numbers): Add from xcoffread.c. (end_symtab): New params say whether to sort pendings and linetable. Patch block stabs if defined. Shrink linetable before allocating the symtab. * buildsym.h: Delete line_vector* and prev_line_number. Add global_stabs and file_stabs for xcoffread. * dbxread.c (start_subfile): Move to buildsym. Change above calls. * symtab.h: LINETABLE(symtab) can now be null. Zap LINELIST. * symmisc.c, symtab.c: Cope with null LINETABLEs.
493 lines
13 KiB
C
493 lines
13 KiB
C
/* Do various things to symbol tables (other than lookup)), for GDB.
|
||
Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
|
||
|
||
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 distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
|
||
#include <stdio.h>
|
||
#include "defs.h"
|
||
#include "param.h"
|
||
#include "symtab.h"
|
||
#include "bfd.h"
|
||
#include "symfile.h"
|
||
#include "breakpoint.h"
|
||
#include "command.h"
|
||
|
||
#include <obstack.h>
|
||
|
||
/* Free all the symtabs that are currently installed,
|
||
and all storage associated with them.
|
||
Leaves us in a consistent state with no symtabs installed. */
|
||
|
||
void
|
||
free_all_symtabs ()
|
||
{
|
||
register struct symtab *s, *snext;
|
||
|
||
/* All values will be invalid because their types will be! */
|
||
|
||
clear_value_history ();
|
||
clear_displays ();
|
||
clear_internalvars ();
|
||
#if defined (CLEAR_SOLIB)
|
||
CLEAR_SOLIB ();
|
||
#endif
|
||
set_default_breakpoint (0, 0, 0, 0);
|
||
|
||
current_source_symtab = 0;
|
||
|
||
for (s = symtab_list; s; s = snext)
|
||
{
|
||
snext = s->next;
|
||
free_symtab (s);
|
||
}
|
||
symtab_list = 0;
|
||
obstack_free (symbol_obstack, 0);
|
||
obstack_init (symbol_obstack);
|
||
|
||
if (misc_function_vector)
|
||
free (misc_function_vector);
|
||
misc_function_count = 0;
|
||
misc_function_vector = 0;
|
||
clear_pc_function_cache();
|
||
}
|
||
|
||
/* Free a struct block <- B and all the symbols defined in that block. */
|
||
|
||
static void
|
||
free_symtab_block (b)
|
||
struct block *b;
|
||
{
|
||
register int i, n;
|
||
n = BLOCK_NSYMS (b);
|
||
for (i = 0; i < n; i++)
|
||
{
|
||
free (SYMBOL_NAME (BLOCK_SYM (b, i)));
|
||
free (BLOCK_SYM (b, i));
|
||
}
|
||
free (b);
|
||
}
|
||
|
||
/* Free all the storage associated with the struct symtab <- S.
|
||
Note that some symtabs have contents malloc'ed structure by structure,
|
||
while some have contents that all live inside one big block of memory,
|
||
and some share the contents of another symbol table and so you should
|
||
not free the contents on their behalf (except sometimes the linetable,
|
||
which maybe per symtab even when the rest is not).
|
||
It is s->free_code that says which alternative to use. */
|
||
|
||
void
|
||
free_symtab (s)
|
||
register struct symtab *s;
|
||
{
|
||
register int i, n;
|
||
register struct blockvector *bv;
|
||
|
||
switch (s->free_code)
|
||
{
|
||
case free_nothing:
|
||
/* All the contents are part of a big block of memory (an obstack),
|
||
and some other symtab is in charge of freeing that block.
|
||
Therefore, do nothing. */
|
||
break;
|
||
|
||
case free_contents:
|
||
/* Here all the contents were malloc'ed structure by structure
|
||
and must be freed that way. */
|
||
/* First free the blocks (and their symbols. */
|
||
bv = BLOCKVECTOR (s);
|
||
n = BLOCKVECTOR_NBLOCKS (bv);
|
||
for (i = 0; i < n; i++)
|
||
free_symtab_block (BLOCKVECTOR_BLOCK (bv, i));
|
||
/* Free the blockvector itself. */
|
||
free (bv);
|
||
/* Also free the linetable. */
|
||
|
||
case free_linetable:
|
||
/* Everything will be freed either by our `free_ptr'
|
||
or by some other symbatb, except for our linetable.
|
||
Free that now. */
|
||
free (LINETABLE (s));
|
||
break;
|
||
}
|
||
|
||
/* If there is a single block of memory to free, free it. */
|
||
if (s->free_ptr)
|
||
free (s->free_ptr);
|
||
|
||
/* Free source-related stuff */
|
||
if (s->line_charpos)
|
||
free (s->line_charpos);
|
||
if (s->fullname)
|
||
free (s->fullname);
|
||
free (s);
|
||
}
|
||
|
||
static int block_depth ();
|
||
static void print_symbol ();
|
||
static void print_partial_symbol ();
|
||
|
||
void
|
||
print_symtabs (filename)
|
||
char *filename;
|
||
{
|
||
FILE *outfile;
|
||
register struct symtab *s;
|
||
register int i, j;
|
||
int len, blen;
|
||
register struct linetable *l;
|
||
struct blockvector *bv;
|
||
register struct block *b;
|
||
int depth;
|
||
struct cleanup *cleanups;
|
||
extern int fclose();
|
||
|
||
if (filename == 0)
|
||
error_no_arg ("file to write symbol data in");
|
||
|
||
filename = tilde_expand (filename);
|
||
make_cleanup (free, filename);
|
||
|
||
outfile = fopen (filename, "w");
|
||
if (outfile == 0)
|
||
perror_with_name (filename);
|
||
|
||
cleanups = make_cleanup (fclose, outfile);
|
||
immediate_quit++;
|
||
|
||
for (s = symtab_list; s; s = s->next)
|
||
{
|
||
/* First print the line table. */
|
||
fprintf (outfile, "Symtab for file %s\n", s->filename);
|
||
l = LINETABLE (s);
|
||
if (l) {
|
||
fprintf (outfile, "\nLine table:\n\n");
|
||
len = l->nitems;
|
||
for (i = 0; i < len; i++)
|
||
fprintf (outfile, " line %d at %x\n", l->item[i].line,
|
||
l->item[i].pc);
|
||
}
|
||
/* Now print the block info. */
|
||
fprintf (outfile, "\nBlockvector:\n\n");
|
||
bv = BLOCKVECTOR (s);
|
||
len = BLOCKVECTOR_NBLOCKS (bv);
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
b = BLOCKVECTOR_BLOCK (bv, i);
|
||
depth = block_depth (b) * 2;
|
||
print_spaces (depth, outfile);
|
||
fprintf (outfile, "block #%03d (object 0x%x) ", i, b);
|
||
fprintf (outfile, "[0x%x..0x%x]", BLOCK_START (b), BLOCK_END (b));
|
||
if (BLOCK_SUPERBLOCK (b))
|
||
fprintf (outfile, " (under 0x%x)", BLOCK_SUPERBLOCK (b));
|
||
if (BLOCK_FUNCTION (b))
|
||
fprintf (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
|
||
fputc ('\n', outfile);
|
||
blen = BLOCK_NSYMS (b);
|
||
for (j = 0; j < blen; j++)
|
||
{
|
||
print_symbol (BLOCK_SYM (b, j), depth + 1, outfile);
|
||
}
|
||
}
|
||
|
||
fprintf (outfile, "\n\n");
|
||
}
|
||
|
||
immediate_quit--;
|
||
do_cleanups (cleanups);
|
||
}
|
||
|
||
static void
|
||
print_symbol (symbol, depth, outfile)
|
||
struct symbol *symbol;
|
||
int depth;
|
||
FILE *outfile;
|
||
{
|
||
print_spaces (depth, outfile);
|
||
if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
|
||
{
|
||
fprintf (outfile, "label %s at 0x%x\n", SYMBOL_NAME (symbol),
|
||
SYMBOL_VALUE_ADDRESS (symbol));
|
||
return;
|
||
}
|
||
if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
|
||
{
|
||
if (TYPE_NAME (SYMBOL_TYPE (symbol)))
|
||
{
|
||
type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
|
||
}
|
||
else
|
||
{
|
||
fprintf (outfile, "%s %s = ",
|
||
(TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
|
||
? "enum"
|
||
: (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
|
||
? "struct" : "union")),
|
||
SYMBOL_NAME (symbol));
|
||
type_print_1 (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
|
||
}
|
||
fprintf (outfile, ";\n");
|
||
}
|
||
else
|
||
{
|
||
if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
|
||
fprintf (outfile, "typedef ");
|
||
if (SYMBOL_TYPE (symbol))
|
||
{
|
||
type_print_1 (SYMBOL_TYPE (symbol), SYMBOL_NAME (symbol),
|
||
outfile, 1, depth);
|
||
fprintf (outfile, "; ");
|
||
}
|
||
else
|
||
fprintf (outfile, "%s ", SYMBOL_NAME (symbol));
|
||
|
||
switch (SYMBOL_CLASS (symbol))
|
||
{
|
||
case LOC_CONST:
|
||
fprintf (outfile, "const %ld (0x%lx),",
|
||
SYMBOL_VALUE (symbol), SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_CONST_BYTES:
|
||
fprintf (outfile, "const %u hex bytes:",
|
||
TYPE_LENGTH (SYMBOL_TYPE (symbol)));
|
||
{
|
||
unsigned i;
|
||
for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
|
||
fprintf (outfile, " %2x",
|
||
(unsigned)SYMBOL_VALUE_BYTES (symbol) [i]);
|
||
fprintf (outfile, ",");
|
||
}
|
||
break;
|
||
|
||
case LOC_STATIC:
|
||
fprintf (outfile, "static at 0x%x,", SYMBOL_VALUE_ADDRESS (symbol));
|
||
break;
|
||
|
||
case LOC_REGISTER:
|
||
fprintf (outfile, "register %ld,", SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_ARG:
|
||
fprintf (outfile, "arg at 0x%lx,", SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_LOCAL_ARG:
|
||
fprintf (outfile, "arg at offset 0x%x from fp,",
|
||
SYMBOL_VALUE (symbol));
|
||
|
||
case LOC_REF_ARG:
|
||
fprintf (outfile, "reference arg at 0x%lx,", SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_REGPARM:
|
||
fprintf (outfile, "parameter register %ld,", SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_LOCAL:
|
||
fprintf (outfile, "local at 0x%lx,", SYMBOL_VALUE (symbol));
|
||
break;
|
||
|
||
case LOC_TYPEDEF:
|
||
break;
|
||
|
||
case LOC_LABEL:
|
||
fprintf (outfile, "label at 0x%lx", SYMBOL_VALUE_ADDRESS (symbol));
|
||
break;
|
||
|
||
case LOC_BLOCK:
|
||
fprintf (outfile, "block (object 0x%x) starting at 0x%x,",
|
||
SYMBOL_BLOCK_VALUE (symbol),
|
||
BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)));
|
||
break;
|
||
|
||
default:
|
||
fprintf (outfile, "botched symbol class %x", SYMBOL_CLASS (symbol));
|
||
break;
|
||
}
|
||
}
|
||
fprintf (outfile, "\n");
|
||
}
|
||
|
||
void
|
||
print_partial_symtabs (filename)
|
||
char *filename;
|
||
{
|
||
FILE *outfile;
|
||
struct partial_symtab *p;
|
||
struct cleanup *cleanups;
|
||
extern int fclose();
|
||
|
||
if (filename == 0)
|
||
error_no_arg ("file to write partial symbol data in");
|
||
|
||
filename = tilde_expand (filename);
|
||
make_cleanup (free, filename);
|
||
|
||
outfile = fopen (filename, "w");
|
||
if (outfile == 0)
|
||
perror_with_name (filename);
|
||
|
||
cleanups = make_cleanup (fclose, outfile);
|
||
immediate_quit++;
|
||
|
||
for (p = partial_symtab_list; p; p = p->next)
|
||
{
|
||
fprintf_filtered (outfile, "Partial symtab for source file %s ",
|
||
p->filename);
|
||
fprintf_filtered (outfile, "(object 0x%x)\n\n", p);
|
||
fprintf_filtered (outfile, " Full symbol table %s been read from %s\n",
|
||
p->readin ? "has" : "has not yet",
|
||
p->symfile_name);
|
||
if (p->readin)
|
||
fprintf_filtered (outfile, " Was read into symtab at 0x%x by function at 0x%x\n",
|
||
p->symtab, p->read_symtab);
|
||
fprintf_filtered (outfile, " Relocate symbols by 0x%x\n", p->addr);
|
||
fprintf_filtered (outfile, " Symbols cover text addresses 0x%x-0x%x\n",
|
||
p->textlow, p->texthigh);
|
||
fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
|
||
p->number_of_dependencies);
|
||
if (p->n_global_syms > 0)
|
||
print_partial_symbol (global_psymbols.list + p->globals_offset,
|
||
p->n_global_syms, "Global", outfile);
|
||
if (p->n_static_syms > 0)
|
||
print_partial_symbol (static_psymbols.list + p->statics_offset,
|
||
p->n_static_syms, "Static", outfile);
|
||
fprintf_filtered (outfile, "\n\n");
|
||
}
|
||
|
||
immediate_quit--;
|
||
do_cleanups (cleanups);
|
||
}
|
||
|
||
static void
|
||
print_partial_symbol (p, count, what, outfile)
|
||
struct partial_symbol *p;
|
||
int count;
|
||
char *what;
|
||
FILE *outfile;
|
||
{
|
||
char *space;
|
||
char *class;
|
||
|
||
fprintf_filtered (outfile, " %s partial symbols:\n", what);
|
||
while (count-- > 0)
|
||
{
|
||
fprintf_filtered (outfile, " `%s', ", SYMBOL_NAME(p));
|
||
switch (SYMBOL_NAMESPACE (p))
|
||
{
|
||
case UNDEF_NAMESPACE:
|
||
fputs_filtered ("undefined namespace, ", outfile);
|
||
break;
|
||
case VAR_NAMESPACE:
|
||
/* This is the usual thing -- don't print it */
|
||
break;
|
||
case STRUCT_NAMESPACE:
|
||
fputs_filtered ("struct namespace, ", outfile);
|
||
break;
|
||
case LABEL_NAMESPACE:
|
||
fputs_filtered ("label namespace, ", outfile);
|
||
break;
|
||
default:
|
||
fputs_filtered ("<invalid namespace>, ", outfile);
|
||
break;
|
||
}
|
||
switch (SYMBOL_CLASS (p))
|
||
{
|
||
case LOC_UNDEF:
|
||
fputs_filtered ("undefined", outfile);
|
||
break;
|
||
case LOC_CONST:
|
||
fputs_filtered ("constant int", outfile);
|
||
break;
|
||
case LOC_STATIC:
|
||
fputs_filtered ("static", outfile);
|
||
break;
|
||
case LOC_REGISTER:
|
||
fputs_filtered ("register", outfile);
|
||
break;
|
||
case LOC_ARG:
|
||
fputs_filtered ("pass by value", outfile);
|
||
break;
|
||
case LOC_REF_ARG:
|
||
fputs_filtered ("pass by reference", outfile);
|
||
break;
|
||
case LOC_REGPARM:
|
||
fputs_filtered ("register parameter", outfile);
|
||
break;
|
||
case LOC_LOCAL:
|
||
fputs_filtered ("stack parameter", outfile);
|
||
break;
|
||
case LOC_TYPEDEF:
|
||
fputs_filtered ("type", outfile);
|
||
break;
|
||
case LOC_LABEL:
|
||
fputs_filtered ("label", outfile);
|
||
break;
|
||
case LOC_BLOCK:
|
||
fputs_filtered ("function", outfile);
|
||
break;
|
||
case LOC_CONST_BYTES:
|
||
fputs_filtered ("constant bytes", outfile);
|
||
break;
|
||
case LOC_LOCAL_ARG:
|
||
fputs_filtered ("shuffled arg", outfile);
|
||
break;
|
||
default:
|
||
fputs_filtered ("<invalid location>", outfile);
|
||
break;
|
||
}
|
||
fputs_filtered (", ", outfile);
|
||
fprintf_filtered (outfile, "0x%x\n", SYMBOL_VALUE (p));
|
||
p++;
|
||
}
|
||
}
|
||
|
||
/* Return the nexting depth of a block within other blocks in its symtab. */
|
||
|
||
static int
|
||
block_depth (block)
|
||
struct block *block;
|
||
{
|
||
register int i = 0;
|
||
while (block = BLOCK_SUPERBLOCK (block)) i++;
|
||
return i;
|
||
}
|
||
|
||
/*
|
||
* Free all partial_symtab storage.
|
||
*/
|
||
void
|
||
free_all_psymtabs()
|
||
{
|
||
obstack_free (psymbol_obstack, 0);
|
||
obstack_init (psymbol_obstack);
|
||
partial_symtab_list = (struct partial_symtab *) 0;
|
||
}
|
||
|
||
void
|
||
_initialize_symmisc ()
|
||
{
|
||
symtab_list = (struct symtab *) 0;
|
||
partial_symtab_list = (struct partial_symtab *) 0;
|
||
|
||
add_com ("printsyms", class_obscure, print_symtabs,
|
||
"Print dump of current symbol definitions to file OUTFILE.");
|
||
add_com ("printpsyms", class_obscure, print_partial_symtabs,
|
||
"Print dump of current partial symbol definitions to file OUTFILE.");
|
||
}
|
||
|