316 lines
8.3 KiB
C
316 lines
8.3 KiB
C
|
#include "libiberty.h"
|
||
|
|
#include "cg_arcs.h"
|
||
|
|
#include "sym_ids.h"
|
||
|
|
|
||
|
|
struct sym_id {
|
||
|
|
struct sym_id *next;
|
||
|
|
char *spec; /* parsing modifies this */
|
||
|
|
Table_Id which_table;
|
||
|
|
bool has_right;
|
||
|
|
struct match {
|
||
|
|
int prev_index; /* index of prev match */
|
||
|
|
Sym *prev_match; /* previous match */
|
||
|
|
Sym *first_match; /* chain of all matches */
|
||
|
|
Sym sym;
|
||
|
|
} left, right;
|
||
|
|
} *id_list;
|
||
|
|
|
||
|
|
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 /* DEBUG */
|
||
|
|
|
||
|
|
/*
|
||
|
|
* 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
|
||
|
|
* to the addresses, because it is accessed only through
|
||
|
|
* the left half's CHILDREN pointers (so it's crucial not
|
||
|
|
* to reorder this table once pointers into it exist).
|
||
|
|
*/
|
||
|
|
static Sym_Table right_ids;
|
||
|
|
|
||
|
|
static Source_File non_existent_file = {
|
||
|
|
0, "<non-existent-file>"
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
void
|
||
|
|
DEFUN(sym_id_add, (spec, which_table),
|
||
|
|
const char *spec AND 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;
|
||
|
|
} /* sym_id_add */
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* A spec has the syntax FILENAME:(FUNCNAME|LINENUM). As a convenience
|
||
|
|
* to the user, a spec without a colon is interpreted as:
|
||
|
|
*
|
||
|
|
* (i) a FILENAME if it contains a dot
|
||
|
|
* (ii) a FUNCNAME if it starts with a non-digit character
|
||
|
|
* (iii) a LINENUM if it starts with a digit
|
||
|
|
*
|
||
|
|
* A FUNCNAME containing a dot can be specified by :FUNCNAME, a
|
||
|
|
* FILENAME not containing a dot can be specified by FILENAME:.
|
||
|
|
*/
|
||
|
|
static void
|
||
|
|
DEFUN(parse_spec, (spec, sym), char *spec AND 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;
|
||
|
|
} /* if */
|
||
|
|
} /* if */
|
||
|
|
spec = colon + 1;
|
||
|
|
if (strlen(spec)) {
|
||
|
|
if (isdigit(spec[0])) {
|
||
|
|
sym->line_num = atoi(spec);
|
||
|
|
} else {
|
||
|
|
sym->name = spec;
|
||
|
|
} /* if */
|
||
|
|
} /* if */
|
||
|
|
} else if (strlen(spec)) {
|
||
|
|
/* no colon: spec is a filename if it contains a dot: */
|
||
|
|
if (strchr(spec, '.')) {
|
||
|
|
sym->file = source_file_lookup_name(spec);
|
||
|
|
if (!sym->file) {
|
||
|
|
sym->file = &non_existent_file;
|
||
|
|
} /* if */
|
||
|
|
} else if (isdigit(*spec)) {
|
||
|
|
sym->line_num = atoi(spec);
|
||
|
|
} else if (strlen(spec)) {
|
||
|
|
sym->name = spec;
|
||
|
|
} /* if */
|
||
|
|
} /* if */
|
||
|
|
} /* parse_spec */
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* A symbol id has the syntax SPEC[/SPEC], where SPEC is is defined
|
||
|
|
* by parse_spec().
|
||
|
|
*/
|
||
|
|
static void
|
||
|
|
DEFUN(parse_id, (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;
|
||
|
|
} /* if */
|
||
|
|
parse_spec(id->spec, &id->left.sym);
|
||
|
|
|
||
|
|
DBG(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 */
|
||
|
|
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("*");
|
||
|
|
} /* if */
|
||
|
|
} /* if */
|
||
|
|
printf("\n"));
|
||
|
|
} /* parse_id */
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Return TRUE iff PATTERN matches SYM.
|
||
|
|
*/
|
||
|
|
static bool
|
||
|
|
DEFUN(match, (pattern, sym), Sym *pattern AND 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) == 0 : TRUE);
|
||
|
|
} /* match */
|
||
|
|
|
||
|
|
|
||
|
|
static void
|
||
|
|
DEFUN(extend_match, (m, sym, tab, second_pass),
|
||
|
|
struct match *m AND Sym *sym AND Sym_Table *tab AND bool second_pass)
|
||
|
|
{
|
||
|
|
if (m->prev_match != sym - 1) {
|
||
|
|
/* discontinuity: add new match to table: */
|
||
|
|
if (second_pass) {
|
||
|
|
tab->base[tab->len] = *sym;
|
||
|
|
m->prev_index = tab->len;
|
||
|
|
|
||
|
|
/* link match into match's chain: */
|
||
|
|
tab->base[tab->len].next = m->first_match;
|
||
|
|
m->first_match = &tab->base[tab->len];
|
||
|
|
} /* if */
|
||
|
|
++tab->len;
|
||
|
|
} /* if */
|
||
|
|
|
||
|
|
/* extend match to include this symbol: */
|
||
|
|
if (second_pass) {
|
||
|
|
tab->base[m->prev_index].end_addr = sym->end_addr;
|
||
|
|
} /* if */
|
||
|
|
m->prev_match = sym;
|
||
|
|
} /* extend_match */
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Go through sym_id list produced by option processing and fill
|
||
|
|
* in the various symbol tables indicating what symbols should
|
||
|
|
* be displayed or suppressed for the various kinds of outputs.
|
||
|
|
*
|
||
|
|
* This can potentially produce huge tables and in particulars
|
||
|
|
* tons of arcs, but this happens only if the user makes silly
|
||
|
|
* requests---you get what you ask for!
|
||
|
|
*/
|
||
|
|
void
|
||
|
|
DEFUN_VOID(sym_id_parse)
|
||
|
|
{
|
||
|
|
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);
|
||
|
|
} /* for */
|
||
|
|
|
||
|
|
/* 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 */
|
||
|
|
if (id->has_right && match(&id->right.sym, sym)) {
|
||
|
|
extend_match(&id->right, sym, &right_ids, FALSE);
|
||
|
|
} /* if */
|
||
|
|
} /* for */
|
||
|
|
} /* for */
|
||
|
|
|
||
|
|
/* 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 */
|
||
|
|
} /* for */
|
||
|
|
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;
|
||
|
|
} /* if */
|
||
|
|
|
||
|
|
/* 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 */
|
||
|
|
if (id->has_right && match(&id->right.sym, sym)) {
|
||
|
|
extend_match(&id->right, sym, &right_ids, TRUE);
|
||
|
|
} /* if */
|
||
|
|
} /* for */
|
||
|
|
} /* for */
|
||
|
|
|
||
|
|
/* 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 : "*", left->addr,
|
||
|
|
left->end_addr,
|
||
|
|
right->file ? right->file->name : "*",
|
||
|
|
right->name ? right->name : "*", right->addr,
|
||
|
|
right->end_addr,
|
||
|
|
table_name[id->which_table]));
|
||
|
|
arc_add(left, right, 0);
|
||
|
|
} /* for */
|
||
|
|
} /* for */
|
||
|
|
} /* if */
|
||
|
|
} /* for */
|
||
|
|
|
||
|
|
/* 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);
|
||
|
|
} /* for */
|
||
|
|
} /* sym_id_parse */
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Symbol tables storing the FROM symbols of arcs do not necessarily
|
||
|
|
* have distinct address ranges. For example, somebody might request
|
||
|
|
* -k /_mcount to suppress any arcs into _mcount, while at the same
|
||
|
|
* 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
|
||
|
|
* tolerable.
|
||
|
|
*/
|
||
|
|
bool
|
||
|
|
DEFUN(sym_id_arc_is_present, (symtab, from, to),
|
||
|
|
Sym_Table *symtab AND Sym *from AND Sym *to)
|
||
|
|
{
|
||
|
|
Sym *sym;
|
||
|
|
|
||
|
|
for (sym = symtab->base; sym < symtab->limit; ++sym) {
|
||
|
|
if (from->addr >= sym->addr && from->addr <= sym->end_addr
|
||
|
|
&& arc_lookup(sym, to))
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
} /* if */
|
||
|
|
} /* for */
|
||
|
|
return FALSE;
|
||
|
|
} /* sym_id_arc_is_present */
|
||
|
|
|
||
|
|
/*** end of sym_ids.h ***/
|