#include "libiberty.h"
#include "safe-ctype.h"
#include "gprof.h"
#include "search_list.h"
#include "source.h"
#include "symtab.h"
#include "cg_arcs.h"
#include "sym_ids.h"
struct sym_id
{
struct sym_id *next;
char *spec;
Table_Id which_table;
bfd_boolean has_right;
struct match
{
int prev_index;
Sym *prev_match;
Sym *first_match;
Sym sym;
}
left, right;
}
*id_list;
static void parse_spec
(char *, Sym *);
static void parse_id
(struct sym_id *);
static bfd_boolean match
(Sym *, Sym *);
static void extend_match
(struct match *, Sym *, Sym_Table *, bfd_boolean);
Sym_Table syms[NUM_TABLES];
#ifdef DEBUG
const char *table_name[] =
{
"INCL_GRAPH", "EXCL_GRAPH",
"INCL_ARCS", "EXCL_ARCS",
"INCL_FLAT", "EXCL_FLAT",
"INCL_TIME", "EXCL_TIME",
"INCL_ANNO", "EXCL_ANNO",
"INCL_EXEC", "EXCL_EXEC"
};
#endif
static Sym_Table right_ids;
static Source_File non_existent_file =
{
0, "<non-existent-file>", 0, 0, 0, NULL
};
void
sym_id_add (const char *spec, Table_Id which_table)
{
struct sym_id *id;
int len = strlen (spec);
id = (struct sym_id *) xmalloc (sizeof (*id) + len + 1);
memset (id, 0, sizeof (*id));
id->spec = (char *) id + sizeof (*id);
strcpy (id->spec, spec);
id->which_table = which_table;
id->next = id_list;
id_list = id;
}
static void
parse_spec (char *spec, Sym *sym)
{
char *colon;
sym_init (sym);
colon = strrchr (spec, ':');
if (colon)
{
*colon = '\0';
if (colon > spec)
{
sym->file = source_file_lookup_name (spec);
if (!sym->file)
sym->file = &non_existent_file;
}
spec = colon + 1;
if (strlen (spec))
{
if (ISDIGIT (spec[0]))
sym->line_num = atoi (spec);
else
sym->name = spec;
}
}
else if (strlen (spec))
{
if (strchr (spec, '.'))
{
sym->file = source_file_lookup_name (spec);
if (!sym->file)
sym->file = &non_existent_file;
}
else if (ISDIGIT (*spec))
{
sym->line_num = atoi (spec);
}
else if (strlen (spec))
{
sym->name = spec;
}
}
}
static void
parse_id (struct sym_id *id)
{
char *slash;
DBG (IDDEBUG, printf ("[parse_id] %s -> ", id->spec));
slash = strchr (id->spec, '/');
if (slash)
{
parse_spec (slash + 1, &id->right.sym);
*slash = '\0';
id->has_right = TRUE;
}
parse_spec (id->spec, &id->left.sym);
#ifdef DEBUG
if (debug_level & IDDEBUG)
{
printf ("%s:", id->left.sym.file ? id->left.sym.file->name : "*");
if (id->left.sym.name)
printf ("%s", id->left.sym.name);
else if (id->left.sym.line_num)
printf ("%d", id->left.sym.line_num);
else
printf ("*");
if (id->has_right)
{
printf ("/%s:",
id->right.sym.file ? id->right.sym.file->name : "*");
if (id->right.sym.name)
printf ("%s", id->right.sym.name);
else if (id->right.sym.line_num)
printf ("%d", id->right.sym.line_num);
else
printf ("*");
}
printf ("\n");
}
#endif
}
static bfd_boolean
match (Sym *pattern, Sym *sym)
{
return (pattern->file ? pattern->file == sym->file : TRUE)
&& (pattern->line_num ? pattern->line_num == sym->line_num : TRUE)
&& (pattern->name
? strcmp (pattern->name,
sym->name+(discard_underscores && sym->name[0] == '_')) == 0
: TRUE);
}
static void
extend_match (struct match *m, Sym *sym, Sym_Table *tab, bfd_boolean second_pass)
{
if (m->prev_match != sym - 1)
{
if (second_pass)
{
tab->base[tab->len] = *sym;
m->prev_index = tab->len;
tab->base[tab->len].next = m->first_match;
m->first_match = &tab->base[tab->len];
}
++tab->len;
}
if (second_pass)
tab->base[m->prev_index].end_addr = sym->end_addr;
m->prev_match = sym;
}
void
sym_id_parse ()
{
Sym *sym, *left, *right;
struct sym_id *id;
Sym_Table *tab;
for (id = id_list; id; id = id->next)
parse_id (id);
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);
}
}
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;
}
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);
}
}
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);
}
}
}
}
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);
}
}
bfd_boolean
sym_id_arc_is_present (Sym_Table *sym_tab, Sym *from, Sym *to)
{
Sym *sym;
for (sym = sym_tab->base; sym < sym_tab->limit; ++sym)
{
if (from->addr >= sym->addr && from->addr <= sym->end_addr
&& arc_lookup (sym, to))
return TRUE;
}
return FALSE;
}