/* sym_ids.c
|
/* sym_ids.c
|
|
|
Copyright 1999, 2000, 2001, 2002, 2004, 2007 Free Software Foundation, Inc.
|
Copyright 1999, 2000, 2001, 2002, 2004, 2007 Free Software Foundation, Inc.
|
|
|
This file is part of GNU Binutils.
|
This file is part of GNU Binutils.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
|
02110-1301, USA. */
|
02110-1301, USA. */
|
|
|
#include "libiberty.h"
|
#include "libiberty.h"
|
#include "safe-ctype.h"
|
#include "safe-ctype.h"
|
#include "gprof.h"
|
#include "gprof.h"
|
#include "search_list.h"
|
#include "search_list.h"
|
#include "source.h"
|
#include "source.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "cg_arcs.h"
|
#include "cg_arcs.h"
|
#include "sym_ids.h"
|
#include "sym_ids.h"
|
#include "corefile.h"
|
#include "corefile.h"
|
|
|
static struct sym_id
|
static struct sym_id
|
{
|
{
|
struct sym_id *next;
|
struct sym_id *next;
|
char *spec; /* Parsing modifies this. */
|
char *spec; /* Parsing modifies this. */
|
Table_Id which_table;
|
Table_Id which_table;
|
bfd_boolean has_right;
|
bfd_boolean has_right;
|
|
|
struct match
|
struct match
|
{
|
{
|
int prev_index; /* Index of prev match. */
|
int prev_index; /* Index of prev match. */
|
Sym *prev_match; /* Previous match. */
|
Sym *prev_match; /* Previous match. */
|
Sym *first_match; /* Chain of all matches. */
|
Sym *first_match; /* Chain of all matches. */
|
Sym sym;
|
Sym sym;
|
}
|
}
|
left, right;
|
left, right;
|
}
|
}
|
*id_list;
|
*id_list;
|
|
|
static void parse_spec
|
static void parse_spec
|
(char *, Sym *);
|
(char *, Sym *);
|
static void parse_id
|
static void parse_id
|
(struct sym_id *);
|
(struct sym_id *);
|
static bfd_boolean match
|
static bfd_boolean match
|
(Sym *, Sym *);
|
(Sym *, Sym *);
|
static void extend_match
|
static void extend_match
|
(struct match *, Sym *, Sym_Table *, bfd_boolean);
|
(struct match *, Sym *, Sym_Table *, bfd_boolean);
|
|
|
|
|
Sym_Table syms[NUM_TABLES];
|
Sym_Table syms[NUM_TABLES];
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
static const char *table_name[] =
|
static const char *table_name[] =
|
{
|
{
|
"INCL_GRAPH", "EXCL_GRAPH",
|
"INCL_GRAPH", "EXCL_GRAPH",
|
"INCL_ARCS", "EXCL_ARCS",
|
"INCL_ARCS", "EXCL_ARCS",
|
"INCL_FLAT", "EXCL_FLAT",
|
"INCL_FLAT", "EXCL_FLAT",
|
"INCL_TIME", "EXCL_TIME",
|
"INCL_TIME", "EXCL_TIME",
|
"INCL_ANNO", "EXCL_ANNO",
|
"INCL_ANNO", "EXCL_ANNO",
|
"INCL_EXEC", "EXCL_EXEC"
|
"INCL_EXEC", "EXCL_EXEC"
|
};
|
};
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
/* This is the table in which we keep all the syms that match
|
/* This is the table in which we keep all the syms that match
|
the right half of an arc id. It is NOT sorted according
|
the right half of an arc id. It is NOT sorted according
|
to the addresses, because it is accessed only through
|
to the addresses, because it is accessed only through
|
the left half's CHILDREN pointers (so it's crucial not
|
the left half's CHILDREN pointers (so it's crucial not
|
to reorder this table once pointers into it exist). */
|
to reorder this table once pointers into it exist). */
|
static Sym_Table right_ids;
|
static Sym_Table right_ids;
|
|
|
static Source_File non_existent_file =
|
static Source_File non_existent_file =
|
{
|
{
|
0, "<non-existent-file>", 0, 0, 0, NULL
|
0, "<non-existent-file>", 0, 0, 0, NULL
|
};
|
};
|
|
|
|
|
void
|
void
|
sym_id_add (const char *spec, Table_Id which_table)
|
sym_id_add (const char *spec, Table_Id which_table)
|
{
|
{
|
struct sym_id *id;
|
struct sym_id *id;
|
int len = strlen (spec);
|
int len = strlen (spec);
|
|
|
id = (struct sym_id *) xmalloc (sizeof (*id) + len + 1);
|
id = (struct sym_id *) xmalloc (sizeof (*id) + len + 1);
|
memset (id, 0, sizeof (*id));
|
memset (id, 0, sizeof (*id));
|
|
|
id->spec = (char *) id + sizeof (*id);
|
id->spec = (char *) id + sizeof (*id);
|
strcpy (id->spec, spec);
|
strcpy (id->spec, spec);
|
id->which_table = which_table;
|
id->which_table = which_table;
|
|
|
id->next = id_list;
|
id->next = id_list;
|
id_list = id;
|
id_list = id;
|
}
|
}
|
|
|
|
|
/* A spec has the syntax FILENAME:(FUNCNAME|LINENUM). As a convenience
|
/* A spec has the syntax FILENAME:(FUNCNAME|LINENUM). As a convenience
|
to the user, a spec without a colon is interpreted as:
|
to the user, a spec without a colon is interpreted as:
|
|
|
(i) a FILENAME if it contains a dot
|
(i) a FILENAME if it contains a dot
|
(ii) a FUNCNAME if it starts with a non-digit character
|
(ii) a FUNCNAME if it starts with a non-digit character
|
(iii) a LINENUM if it starts with a digit
|
(iii) a LINENUM if it starts with a digit
|
|
|
A FUNCNAME containing a dot can be specified by :FUNCNAME, a
|
A FUNCNAME containing a dot can be specified by :FUNCNAME, a
|
FILENAME not containing a dot can be specified by FILENAME. */
|
FILENAME not containing a dot can be specified by FILENAME. */
|
|
|
static void
|
static void
|
parse_spec (char *spec, Sym *sym)
|
parse_spec (char *spec, Sym *sym)
|
{
|
{
|
char *colon;
|
char *colon;
|
|
|
sym_init (sym);
|
sym_init (sym);
|
colon = strrchr (spec, ':');
|
colon = strrchr (spec, ':');
|
|
|
if (colon)
|
if (colon)
|
{
|
{
|
*colon = '\0';
|
*colon = '\0';
|
|
|
if (colon > spec)
|
if (colon > spec)
|
{
|
{
|
sym->file = source_file_lookup_name (spec);
|
sym->file = source_file_lookup_name (spec);
|
|
|
if (!sym->file)
|
if (!sym->file)
|
sym->file = &non_existent_file;
|
sym->file = &non_existent_file;
|
}
|
}
|
|
|
spec = colon + 1;
|
spec = colon + 1;
|
|
|
if (strlen (spec))
|
if (strlen (spec))
|
{
|
{
|
if (ISDIGIT (spec[0]))
|
if (ISDIGIT (spec[0]))
|
sym->line_num = atoi (spec);
|
sym->line_num = atoi (spec);
|
else
|
else
|
sym->name = spec;
|
sym->name = spec;
|
}
|
}
|
}
|
}
|
else if (strlen (spec))
|
else if (strlen (spec))
|
{
|
{
|
/* No colon: spec is a filename if it contains a dot. */
|
/* No colon: spec is a filename if it contains a dot. */
|
if (strchr (spec, '.'))
|
if (strchr (spec, '.'))
|
{
|
{
|
sym->file = source_file_lookup_name (spec);
|
sym->file = source_file_lookup_name (spec);
|
|
|
if (!sym->file)
|
if (!sym->file)
|
sym->file = &non_existent_file;
|
sym->file = &non_existent_file;
|
}
|
}
|
else if (ISDIGIT (*spec))
|
else if (ISDIGIT (*spec))
|
{
|
{
|
sym->line_num = atoi (spec);
|
sym->line_num = atoi (spec);
|
}
|
}
|
else if (strlen (spec))
|
else if (strlen (spec))
|
{
|
{
|
sym->name = spec;
|
sym->name = spec;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
/* A symbol id has the syntax SPEC[/SPEC], where SPEC is is defined
|
/* A symbol id has the syntax SPEC[/SPEC], where SPEC is is defined
|
by parse_spec(). */
|
by parse_spec(). */
|
|
|
static void
|
static void
|
parse_id (struct sym_id *id)
|
parse_id (struct sym_id *id)
|
{
|
{
|
char *slash;
|
char *slash;
|
|
|
DBG (IDDEBUG, printf ("[parse_id] %s -> ", id->spec));
|
DBG (IDDEBUG, printf ("[parse_id] %s -> ", id->spec));
|
|
|
slash = strchr (id->spec, '/');
|
slash = strchr (id->spec, '/');
|
if (slash)
|
if (slash)
|
{
|
{
|
parse_spec (slash + 1, &id->right.sym);
|
parse_spec (slash + 1, &id->right.sym);
|
*slash = '\0';
|
*slash = '\0';
|
id->has_right = TRUE;
|
id->has_right = TRUE;
|
}
|
}
|
parse_spec (id->spec, &id->left.sym);
|
parse_spec (id->spec, &id->left.sym);
|
|
|
#ifdef DEBUG
|
#ifdef DEBUG
|
if (debug_level & IDDEBUG)
|
if (debug_level & IDDEBUG)
|
{
|
{
|
printf ("%s:", id->left.sym.file ? id->left.sym.file->name : "*");
|
printf ("%s:", id->left.sym.file ? id->left.sym.file->name : "*");
|
|
|
if (id->left.sym.name)
|
if (id->left.sym.name)
|
printf ("%s", id->left.sym.name);
|
printf ("%s", id->left.sym.name);
|
else if (id->left.sym.line_num)
|
else if (id->left.sym.line_num)
|
printf ("%d", id->left.sym.line_num);
|
printf ("%d", id->left.sym.line_num);
|
else
|
else
|
printf ("*");
|
printf ("*");
|
|
|
if (id->has_right)
|
if (id->has_right)
|
{
|
{
|
printf ("/%s:",
|
printf ("/%s:",
|
id->right.sym.file ? id->right.sym.file->name : "*");
|
id->right.sym.file ? id->right.sym.file->name : "*");
|
|
|
if (id->right.sym.name)
|
if (id->right.sym.name)
|
printf ("%s", id->right.sym.name);
|
printf ("%s", id->right.sym.name);
|
else if (id->right.sym.line_num)
|
else if (id->right.sym.line_num)
|
printf ("%d", id->right.sym.line_num);
|
printf ("%d", id->right.sym.line_num);
|
else
|
else
|
printf ("*");
|
printf ("*");
|
}
|
}
|
|
|
printf ("\n");
|
printf ("\n");
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
|
|
/* Return TRUE iff PATTERN matches SYM. */
|
/* Return TRUE iff PATTERN matches SYM. */
|
|
|
static bfd_boolean
|
static bfd_boolean
|
match (Sym *pattern, Sym *sym)
|
match (Sym *pattern, Sym *sym)
|
{
|
{
|
if (pattern->file && pattern->file != sym->file)
|
if (pattern->file && pattern->file != sym->file)
|
return FALSE;
|
return FALSE;
|
if (pattern->line_num && pattern->line_num != sym->line_num)
|
if (pattern->line_num && pattern->line_num != sym->line_num)
|
return FALSE;
|
return FALSE;
|
if (pattern->name)
|
if (pattern->name)
|
{
|
{
|
const char *sym_name = sym->name;
|
const char *sym_name = sym->name;
|
if (*sym_name && bfd_get_symbol_leading_char (core_bfd) == *sym_name)
|
if (*sym_name && bfd_get_symbol_leading_char (core_bfd) == *sym_name)
|
sym_name++;
|
sym_name++;
|
if (strcmp (pattern->name, sym_name) != 0)
|
if (strcmp (pattern->name, sym_name) != 0)
|
return FALSE;
|
return FALSE;
|
}
|
}
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
extend_match (struct match *m, Sym *sym, Sym_Table *tab, bfd_boolean second_pass)
|
extend_match (struct match *m, Sym *sym, Sym_Table *tab, bfd_boolean second_pass)
|
{
|
{
|
if (m->prev_match != sym - 1)
|
if (m->prev_match != sym - 1)
|
{
|
{
|
/* Discontinuity: add new match to table. */
|
/* Discontinuity: add new match to table. */
|
if (second_pass)
|
if (second_pass)
|
{
|
{
|
tab->base[tab->len] = *sym;
|
tab->base[tab->len] = *sym;
|
m->prev_index = tab->len;
|
m->prev_index = tab->len;
|
|
|
/* Link match into match's chain. */
|
/* Link match into match's chain. */
|
tab->base[tab->len].next = m->first_match;
|
tab->base[tab->len].next = m->first_match;
|
m->first_match = &tab->base[tab->len];
|
m->first_match = &tab->base[tab->len];
|
}
|
}
|
|
|
++tab->len;
|
++tab->len;
|
}
|
}
|
|
|
/* Extend match to include this symbol. */
|
/* Extend match to include this symbol. */
|
if (second_pass)
|
if (second_pass)
|
tab->base[m->prev_index].end_addr = sym->end_addr;
|
tab->base[m->prev_index].end_addr = sym->end_addr;
|
|
|
m->prev_match = sym;
|
m->prev_match = sym;
|
}
|
}
|
|
|
|
|
/* Go through sym_id list produced by option processing and fill
|
/* Go through sym_id list produced by option processing and fill
|
in the various symbol tables indicating what symbols should
|
in the various symbol tables indicating what symbols should
|
be displayed or suppressed for the various kinds of outputs.
|
be displayed or suppressed for the various kinds of outputs.
|
|
|
This can potentially produce huge tables and in particulars
|
This can potentially produce huge tables and in particulars
|
tons of arcs, but this happens only if the user makes silly
|
tons of arcs, but this happens only if the user makes silly
|
requests---you get what you ask for! */
|
requests---you get what you ask for! */
|
|
|
void
|
void
|
sym_id_parse ()
|
sym_id_parse ()
|
{
|
{
|
Sym *sym, *left, *right;
|
Sym *sym, *left, *right;
|
struct sym_id *id;
|
struct sym_id *id;
|
Sym_Table *tab;
|
Sym_Table *tab;
|
|
|
/* Convert symbol ids into Syms, so we can deal with them more easily. */
|
/* Convert symbol ids into Syms, so we can deal with them more easily. */
|
for (id = id_list; id; id = id->next)
|
for (id = id_list; id; id = id->next)
|
parse_id (id);
|
parse_id (id);
|
|
|
/* First determine size of each table. */
|
/* First determine size of each table. */
|
for (sym = symtab.base; sym < symtab.limit; ++sym)
|
for (sym = symtab.base; sym < symtab.limit; ++sym)
|
{
|
{
|
for (id = id_list; id; id = id->next)
|
for (id = id_list; id; id = id->next)
|
{
|
{
|
if (match (&id->left.sym, sym))
|
if (match (&id->left.sym, sym))
|
extend_match (&id->left, sym, &syms[id->which_table], FALSE);
|
extend_match (&id->left, sym, &syms[id->which_table], FALSE);
|
|
|
if (id->has_right && match (&id->right.sym, sym))
|
if (id->has_right && match (&id->right.sym, sym))
|
extend_match (&id->right, sym, &right_ids, FALSE);
|
extend_match (&id->right, sym, &right_ids, FALSE);
|
}
|
}
|
}
|
}
|
|
|
/* Create tables of appropriate size and reset lengths. */
|
/* Create tables of appropriate size and reset lengths. */
|
for (tab = syms; tab < &syms[NUM_TABLES]; ++tab)
|
for (tab = syms; tab < &syms[NUM_TABLES]; ++tab)
|
{
|
{
|
if (tab->len)
|
if (tab->len)
|
{
|
{
|
tab->base = (Sym *) xmalloc (tab->len * sizeof (Sym));
|
tab->base = (Sym *) xmalloc (tab->len * sizeof (Sym));
|
tab->limit = tab->base + tab->len;
|
tab->limit = tab->base + tab->len;
|
tab->len = 0;
|
tab->len = 0;
|
}
|
}
|
}
|
}
|
|
|
if (right_ids.len)
|
if (right_ids.len)
|
{
|
{
|
right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym));
|
right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym));
|
right_ids.limit = right_ids.base + right_ids.len;
|
right_ids.limit = right_ids.base + right_ids.len;
|
right_ids.len = 0;
|
right_ids.len = 0;
|
}
|
}
|
|
|
/* Make a second pass through symtab, creating syms as necessary. */
|
/* Make a second pass through symtab, creating syms as necessary. */
|
for (sym = symtab.base; sym < symtab.limit; ++sym)
|
for (sym = symtab.base; sym < symtab.limit; ++sym)
|
{
|
{
|
for (id = id_list; id; id = id->next)
|
for (id = id_list; id; id = id->next)
|
{
|
{
|
if (match (&id->left.sym, sym))
|
if (match (&id->left.sym, sym))
|
extend_match (&id->left, sym, &syms[id->which_table], TRUE);
|
extend_match (&id->left, sym, &syms[id->which_table], TRUE);
|
|
|
if (id->has_right && match (&id->right.sym, sym))
|
if (id->has_right && match (&id->right.sym, sym))
|
extend_match (&id->right, sym, &right_ids, TRUE);
|
extend_match (&id->right, sym, &right_ids, TRUE);
|
}
|
}
|
}
|
}
|
|
|
/* Go through ids creating arcs as needed. */
|
/* Go through ids creating arcs as needed. */
|
for (id = id_list; id; id = id->next)
|
for (id = id_list; id; id = id->next)
|
{
|
{
|
if (id->has_right)
|
if (id->has_right)
|
{
|
{
|
for (left = id->left.first_match; left; left = left->next)
|
for (left = id->left.first_match; left; left = left->next)
|
{
|
{
|
for (right = id->right.first_match; right; right = right->next)
|
for (right = id->right.first_match; right; right = right->next)
|
{
|
{
|
DBG (IDDEBUG,
|
DBG (IDDEBUG,
|
printf (
|
printf (
|
"[sym_id_parse]: arc %s:%s(%lx-%lx) -> %s:%s(%lx-%lx) to %s\n",
|
"[sym_id_parse]: arc %s:%s(%lx-%lx) -> %s:%s(%lx-%lx) to %s\n",
|
left->file ? left->file->name : "*",
|
left->file ? left->file->name : "*",
|
left->name ? left->name : "*",
|
left->name ? left->name : "*",
|
(unsigned long) left->addr,
|
(unsigned long) left->addr,
|
(unsigned long) left->end_addr,
|
(unsigned long) left->end_addr,
|
right->file ? right->file->name : "*",
|
right->file ? right->file->name : "*",
|
right->name ? right->name : "*",
|
right->name ? right->name : "*",
|
(unsigned long) right->addr,
|
(unsigned long) right->addr,
|
(unsigned long) right->end_addr,
|
(unsigned long) right->end_addr,
|
table_name[id->which_table]));
|
table_name[id->which_table]));
|
|
|
arc_add (left, right, (unsigned long) 0);
|
arc_add (left, right, (unsigned long) 0);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Finally, we can sort the tables and we're done. */
|
/* Finally, we can sort the tables and we're done. */
|
for (tab = &syms[0]; tab < &syms[NUM_TABLES]; ++tab)
|
for (tab = &syms[0]; tab < &syms[NUM_TABLES]; ++tab)
|
{
|
{
|
DBG (IDDEBUG, printf ("[sym_id_parse] syms[%s]:\n",
|
DBG (IDDEBUG, printf ("[sym_id_parse] syms[%s]:\n",
|
table_name[tab - &syms[0]]));
|
table_name[tab - &syms[0]]));
|
symtab_finalize (tab);
|
symtab_finalize (tab);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Symbol tables storing the FROM symbols of arcs do not necessarily
|
/* Symbol tables storing the FROM symbols of arcs do not necessarily
|
have distinct address ranges. For example, somebody might request
|
have distinct address ranges. For example, somebody might request
|
-k /_mcount to suppress any arcs into _mcount, while at the same
|
-k /_mcount to suppress any arcs into _mcount, while at the same
|
time requesting -k a/b. Fortunately, those symbol tables don't get
|
time requesting -k a/b. Fortunately, those symbol tables don't get
|
very big (the user has to type them!), so a linear search is probably
|
very big (the user has to type them!), so a linear search is probably
|
tolerable. */
|
tolerable. */
|
bfd_boolean
|
bfd_boolean
|
sym_id_arc_is_present (Sym_Table *sym_tab, Sym *from, Sym *to)
|
sym_id_arc_is_present (Sym_Table *sym_tab, Sym *from, Sym *to)
|
{
|
{
|
Sym *sym;
|
Sym *sym;
|
|
|
for (sym = sym_tab->base; sym < sym_tab->limit; ++sym)
|
for (sym = sym_tab->base; sym < sym_tab->limit; ++sym)
|
{
|
{
|
if (from->addr >= sym->addr && from->addr <= sym->end_addr
|
if (from->addr >= sym->addr && from->addr <= sym->end_addr
|
&& arc_lookup (sym, to))
|
&& arc_lookup (sym, to))
|
return TRUE;
|
return TRUE;
|
}
|
}
|
|
|
return FALSE;
|
return FALSE;
|
}
|
}
|
|
|
