int
main ( int argc, char **argv )
{
options ( argc, argv );
symtab_init ();
yyparse();
#ifdef DUMP_TREES
if ( (DUMP_TREES & 1) != 0 )
node_print ( stderr, root, 0 );
#endif
simplify_tree ( root );
#ifdef DUMP_TREES
if ( (DUMP_TREES & 2) != 0 )
node_print ( stderr, root, 0 );
#endif
bind_names ( root );
/* Parsing and semantics are ok, redirect stdout to file (if requested) */
if ( outfile != NULL )
{
if ( freopen ( outfile, "w", stdout ) == NULL )
{
fprintf ( stderr, "Could not open output file '%s'\n", outfile );
exit ( EXIT_FAILURE );
}
free ( outfile );
}
generate ( stdout, root );
destroy_subtree ( root );
symtab_finalize();
exit ( EXIT_SUCCESS );
}
void
core_create_line_syms (void)
{
char *prev_name, *prev_filename;
unsigned int prev_name_len, prev_filename_len;
bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
Sym *prev, dummy, *sym;
const char *filename;
int prev_line_num;
Sym_Table ltab;
bfd_vma vma_high;
/* Create symbols for functions as usual. This is necessary in
cases where parts of a program were not compiled with -g. For
those parts we still want to get info at the function level. */
core_create_function_syms ();
/* Pass 1: count the number of symbols. */
/* To find all line information, walk through all possible
text-space addresses (one by one!) and get the debugging
info for each address. When the debugging info changes,
it is time to create a new symbol.
Of course, this is rather slow and it would be better if
BFD would provide an iterator for enumerating all line infos. */
prev_name_len = PATH_MAX;
prev_filename_len = PATH_MAX;
prev_name = (char *) xmalloc (prev_name_len);
prev_filename = (char *) xmalloc (prev_filename_len);
ltab.len = 0;
prev_line_num = 0;
vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
{
unsigned int len;
if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
|| (prev_line_num == dummy.line_num
&& prev_name != NULL
&& strcmp (prev_name, dummy.name) == 0
&& filename_cmp (prev_filename, filename) == 0))
continue;
++ltab.len;
prev_line_num = dummy.line_num;
len = strlen (dummy.name);
if (len >= prev_name_len)
{
prev_name_len = len + 1024;
free (prev_name);
prev_name = (char *) xmalloc (prev_name_len);
}
strcpy (prev_name, dummy.name);
len = strlen (filename);
if (len >= prev_filename_len)
{
prev_filename_len = len + 1024;
free (prev_filename);
prev_filename = (char *) xmalloc (prev_filename_len);
}
strcpy (prev_filename, filename);
min_vma = MIN (vma, min_vma);
max_vma = MAX (vma, max_vma);
}
free (prev_name);
free (prev_filename);
/* Make room for function symbols, too. */
ltab.len += symtab.len;
ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
ltab.limit = ltab.base;
/* Pass 2 - create symbols. */
/* We now set is_static as we go along, rather than by running
through the symbol table at the end.
The old way called symtab_finalize before the is_static pass,
causing a problem since symtab_finalize uses is_static as part of
its address conflict resolution algorithm. Since global symbols
were prefered over static symbols, and all line symbols were
global at that point, static function names that conflicted with
their own line numbers (static, but labeled as global) were
rejected in favor of the line num.
This was not the desired functionality. We always want to keep
our function symbols and discard any conflicting line symbols.
Perhaps symtab_finalize should be modified to make this
distinction as well, but the current fix works and the code is a
lot cleaner now. */
prev = 0;
for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
{
sym_init (ltab.limit);
if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num)
|| (prev && prev->line_num == ltab.limit->line_num
&& strcmp (prev->name, ltab.limit->name) == 0
&& filename_cmp (prev->file->name, filename) == 0))
continue;
/* Make name pointer a malloc'ed string. */
ltab.limit->name = xstrdup (ltab.limit->name);
ltab.limit->file = source_file_lookup_path (filename);
ltab.limit->addr = vma;
/* Set is_static based on the enclosing function, using either:
1) the previous symbol, if it's from the same function, or
2) a symtab lookup. */
if (prev && ltab.limit->file == prev->file &&
strcmp (ltab.limit->name, prev->name) == 0)
{
ltab.limit->is_static = prev->is_static;
}
else
{
sym = sym_lookup(&symtab, ltab.limit->addr);
if (sym)
ltab.limit->is_static = sym->is_static;
}
prev = ltab.limit;
DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
(unsigned long) (ltab.limit - ltab.base),
ltab.limit->name,
(unsigned long) ltab.limit->addr));
++ltab.limit;
}
/* Copy in function symbols. */
memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
ltab.limit += symtab.len;
if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
{
fprintf (stderr,
_("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
whoami, ltab.len, (long) (ltab.limit - ltab.base));
done (1);
}
/* Finalize ltab and make it symbol table. */
symtab_finalize (<ab);
free (symtab.base);
symtab = ltab;
}
void
core_create_function_syms (void)
{
bfd_vma min_vma = ~ (bfd_vma) 0;
bfd_vma max_vma = 0;
int cxxclass;
long i;
struct function_map * found = NULL;
int core_has_func_syms = 0;
switch (core_bfd->xvec->flavour)
{
default:
break;
case bfd_target_coff_flavour:
case bfd_target_ecoff_flavour:
case bfd_target_xcoff_flavour:
case bfd_target_elf_flavour:
case bfd_target_nlm_flavour:
case bfd_target_som_flavour:
core_has_func_syms = 1;
}
/* Pass 1 - determine upper bound on number of function names. */
symtab.len = 0;
for (i = 0; i < core_num_syms; ++i)
{
if (!core_sym_class (core_syms[i]))
continue;
/* Don't create a symtab entry for a function that has
a mapping to a file, unless it's the first function
in the file. */
if (symbol_map_count != 0)
{
/* Note: some systems (SunOS 5.8) crash if bsearch base argument
is NULL. */
found = (struct function_map *) bsearch
(core_syms[i]->name, symbol_map, symbol_map_count,
sizeof (struct function_map), search_mapped_symbol);
}
if (found == NULL || found->is_first)
++symtab.len;
}
if (symtab.len == 0)
{
fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
done (1);
}
symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
/* Pass 2 - create symbols. */
symtab.limit = symtab.base;
for (i = 0; i < core_num_syms; ++i)
{
asection *sym_sec;
cxxclass = core_sym_class (core_syms[i]);
if (!cxxclass)
{
DBG (AOUTDEBUG,
printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
(unsigned long) core_syms[i]->value,
core_syms[i]->name));
continue;
}
if (symbol_map_count != 0)
{
/* Note: some systems (SunOS 5.8) crash if bsearch base argument
is NULL. */
found = (struct function_map *) bsearch
(core_syms[i]->name, symbol_map, symbol_map_count,
sizeof (struct function_map), search_mapped_symbol);
}
if (found && ! found->is_first)
continue;
sym_init (symtab.limit);
/* Symbol offsets are always section-relative. */
sym_sec = core_syms[i]->section;
symtab.limit->addr = core_syms[i]->value;
if (sym_sec)
symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
if (found)
{
symtab.limit->name = found->file_name;
symtab.limit->mapped = 1;
}
else
{
symtab.limit->name = core_syms[i]->name;
symtab.limit->mapped = 0;
}
/* Lookup filename and line number, if we can. */
{
const char * filename;
const char * func_name;
if (get_src_info (symtab.limit->addr, & filename, & func_name,
& symtab.limit->line_num))
{
symtab.limit->file = source_file_lookup_path (filename);
/* FIXME: Checking __osf__ here does not work with a cross
gprof. */
#ifdef __osf__
/* Suppress symbols that are not function names. This is
useful to suppress code-labels and aliases.
This is known to be useful under DEC's OSF/1. Under SunOS 4.x,
labels do not appear in the symbol table info, so this isn't
necessary. */
if (strcmp (symtab.limit->name, func_name) != 0)
{
/* The symbol's address maps to a different name, so
it can't be a function-entry point. This happens
for labels, for example. */
DBG (AOUTDEBUG,
printf ("[core_create_function_syms: rej %s (maps to %s)\n",
symtab.limit->name, func_name));
continue;
}
#endif
}
}
symtab.limit->is_func = (!core_has_func_syms
|| (core_syms[i]->flags & BSF_FUNCTION) != 0);
symtab.limit->is_bb_head = TRUE;
if (cxxclass == 't')
symtab.limit->is_static = TRUE;
/* Keep track of the minimum and maximum vma addresses used by all
symbols. When computing the max_vma, use the ending address of the
section containing the symbol, if available. */
min_vma = MIN (symtab.limit->addr, min_vma);
if (sym_sec)
max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
+ bfd_section_size (sym_sec->owner, sym_sec) - 1,
max_vma);
else
max_vma = MAX (symtab.limit->addr, max_vma);
DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
(long) (symtab.limit - symtab.base),
symtab.limit->name,
(unsigned long) symtab.limit->addr));
++symtab.limit;
}
symtab.len = symtab.limit - symtab.base;
symtab_finalize (&symtab);
}
void
core_create_syms_from (const char * sym_table_file)
{
const int BUFSIZE = 1024;
char * buf = (char *) xmalloc (BUFSIZE);
char * address = (char *) xmalloc (BUFSIZE);
char type;
char * name = (char *) xmalloc (BUFSIZE);
bfd_vma min_vma = ~(bfd_vma) 0;
bfd_vma max_vma = 0;
FILE * f;
f = fopen (sym_table_file, "r");
if (!f)
{
fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
done (1);
}
/* Pass 1 - determine upper bound on number of function names. */
symtab.len = num_of_syms_in (f);
if (symtab.len == 0)
{
fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
done (1);
}
symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
/* Pass 2 - create symbols. */
symtab.limit = symtab.base;
if (fseek (f, 0, SEEK_SET) != 0)
{
perror (sym_table_file);
done (1);
}
while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
{
if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
if (type != 't' && type != 'T')
continue;
sym_init (symtab.limit);
sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
strcpy ((char *) symtab.limit->name, name);
symtab.limit->mapped = 0;
symtab.limit->is_func = TRUE;
symtab.limit->is_bb_head = TRUE;
symtab.limit->is_static = (type == 't');
min_vma = MIN (symtab.limit->addr, min_vma);
max_vma = MAX (symtab.limit->addr, max_vma);
++symtab.limit;
}
fclose (f);
symtab.len = symtab.limit - symtab.base;
symtab_finalize (&symtab);
free (buf);
free (address);
free (name);
}
int
main ( int argc, char **argv )
{
outputStage = 12;
options ( argc, argv );
symtab_init ();
/* In order to only scan the tokens we call yylex() directly */
if ( outputStage == 1 ) {
do { } while ( yylex() ); // "Token files"
exit(0);
}
/* The parser calls yylex(), match the rules and builds the abstract syntax tree */
// "BuildTree files"
yyparse();
if ( outputStage == 2 ) {
exit(0); // Exit if we are only printing this stages debug information. "BuildTree files"
}
/* Print the abstract syntax tree */
if ( outputStage == 3 ) {
node_print ( stderr, root, 0 ); // "Tree files"
exit(0);
}
//simplify_tree ( root );
/* Assign nodes functions according to their type; Handout first time only? */
assignFunctionsToNodes( root );
/* Simplify the abstract syntax tree */
root->simplify( root, 0 );
if ( outputStage == 4 ) {
exit(0); // Exit if we are only printing this stages debug information. "Build Simple Tree files"
}
/* Print the abstract syntax tree after simplification "Final Simple Tree files" */
if ( outputStage == 5 ) {
node_print ( stderr, root, 0 );
exit(0);
}
//bind_names ( root );
root->bind_names( root, 0);
if ( outputStage == 6 || outputStage == 7) {
exit(0); // Exit if we are only printing this stages debug information. "Scopes&String files" and "Symbol table files"
}
/* Print the .data (strings) segment of the assembly file */
if ( outputStage == 8) {
strings_output(stderr);
exit(0);
}
/* Print the entries and string indexes in the node tree "Entries files" */
if ( outputStage == 9) {
node_print_entries ( stderr, root, 0 );
exit(0);
}
root->typecheck(root);
if (outputStage == 10) {
exit(0);
}
/* Parsing and semantics are ok, redirect stdout to file (if requested) */
if ( outfile != NULL )
{
if ( freopen ( outfile, "w", stdout ) == NULL )
{
fprintf ( stderr, "Could not open output file '%s'\n", outfile );
exit ( EXIT_FAILURE );
}
free ( outfile );
}
root->generate(root, 1);
/*
if(outputStage > 10 )
generate ( NULL, NULL, root ); // Output nothing, for later debugging stages.
else if(outputStage == 10 )
generate ( NULL, stderr, root ); // Output only the traversal process.
else if(outputStage == -1 )
generate ( stderr, NULL, root ); // Output the asm as no debug text is made.
*/
//destroy_subtree ( stderr, root );
if ( outputStage == 11 ) {
destroy_subtree ( stderr, root );
exit(0);
} else
destroy_subtree ( NULL, root );
symtab_finalize();
yylex_destroy(); // Free internal data structures of the scanner.
exit ( EXIT_SUCCESS );
}
void
sym_id_parse (void)
{
Sym *sym, *left, *right;
struct sym_id *id;
Sym_Table *tab;
/* Convert symbol ids into Syms, so we can deal with them more easily. */
for (id = id_list; id; id = id->next)
parse_id (id);
/* First determine size of each table. */
for (sym = symtab.base; sym < symtab.limit; ++sym)
{
for (id = id_list; id; id = id->next)
{
if (match (&id->left.sym, sym))
extend_match (&id->left, sym, &syms[id->which_table], FALSE);
if (id->has_right && match (&id->right.sym, sym))
extend_match (&id->right, sym, &right_ids, FALSE);
}
}
/* Create tables of appropriate size and reset lengths. */
for (tab = syms; tab < &syms[NUM_TABLES]; ++tab)
{
if (tab->len)
{
tab->base = (Sym *) xmalloc (tab->len * sizeof (Sym));
tab->limit = tab->base + tab->len;
tab->len = 0;
}
}
if (right_ids.len)
{
right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym));
right_ids.limit = right_ids.base + right_ids.len;
right_ids.len = 0;
}
/* Make a second pass through symtab, creating syms as necessary. */
for (sym = symtab.base; sym < symtab.limit; ++sym)
{
for (id = id_list; id; id = id->next)
{
if (match (&id->left.sym, sym))
extend_match (&id->left, sym, &syms[id->which_table], TRUE);
if (id->has_right && match (&id->right.sym, sym))
extend_match (&id->right, sym, &right_ids, TRUE);
}
}
/* Go through ids creating arcs as needed. */
for (id = id_list; id; id = id->next)
{
if (id->has_right)
{
for (left = id->left.first_match; left; left = left->next)
{
for (right = id->right.first_match; right; right = right->next)
{
DBG (IDDEBUG,
printf (
"[sym_id_parse]: arc %s:%s(%lx-%lx) -> %s:%s(%lx-%lx) to %s\n",
left->file ? left->file->name : "*",
left->name ? left->name : "*",
(unsigned long) left->addr,
(unsigned long) left->end_addr,
right->file ? right->file->name : "*",
right->name ? right->name : "*",
(unsigned long) right->addr,
(unsigned long) right->end_addr,
table_name[id->which_table]));
arc_add (left, right, (unsigned long) 0);
}
}
}
}
/* Finally, we can sort the tables and we're done. */
for (tab = &syms[0]; tab < &syms[NUM_TABLES]; ++tab)
{
DBG (IDDEBUG, printf ("[sym_id_parse] syms[%s]:\n",
table_name[tab - &syms[0]]));
symtab_finalize (tab);
}
}
