X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gprof%2Fsym_ids.c;h=c214f14314dbe49a17b0522b2e7be0ec1dbc3bbf;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=412c8d482791c6726bdd61ac9eda52c1283317c6;hpb=30727aa6d12fb866494020c0b62ab265a2bdcdfe;p=deliverable%2Fbinutils-gdb.git diff --git a/gprof/sym_ids.c b/gprof/sym_ids.c index 412c8d4827..c214f14314 100644 --- a/gprof/sym_ids.c +++ b/gprof/sym_ids.c @@ -1,30 +1,68 @@ -#include +/* sym_ids.c + Copyright (C) 1999-2020 Free Software Foundation, Inc. + + This file is part of GNU Binutils. + + 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 3 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., 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ + +#include "gprof.h" #include "libiberty.h" +#include "safe-ctype.h" +#include "search_list.h" +#include "source.h" +#include "symtab.h" #include "cg_arcs.h" #include "sym_ids.h" +#include "corefile.h" + +struct match + { + int prev_index; /* Index of prev match. */ + Sym *prev_match; /* Previous match. */ + Sym *first_match; /* Chain of all matches. */ + Sym sym; + }; struct sym_id { struct sym_id *next; - char *spec; /* parsing modifies this */ + 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; + bfd_boolean has_right; + + struct match left, right; + }; + +static struct sym_id *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[] = +static const char *table_name[] = { "INCL_GRAPH", "EXCL_GRAPH", "INCL_ARCS", "EXCL_ARCS", @@ -35,13 +73,11 @@ const char *table_name[] = }; #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). - */ +/* 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 = @@ -51,8 +87,7 @@ static Source_File non_existent_file = void -DEFUN (sym_id_add, (spec, which_table), - const char *spec AND Table_Id which_table) +sym_id_add (const char *spec, Table_Id which_table) { struct sym_id *id; int len = strlen (spec); @@ -69,60 +104,57 @@ DEFUN (sym_id_add, (spec, which_table), } -/* - * 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:. - */ +/* 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) +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; - } + sym->file = &non_existent_file; } + spec = colon + 1; + if (strlen (spec)) { - if (isdigit ((unsigned char) spec[0])) - { - sym->line_num = atoi (spec); - } + if (ISDIGIT (spec[0])) + sym->line_num = atoi (spec); else - { - sym->name = spec; - } + sym->name = 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, '.')) { sym->file = source_file_lookup_name (spec); + if (!sym->file) - { - sym->file = &non_existent_file; - } + sym->file = &non_existent_file; } - else if (isdigit ((unsigned char) *spec)) + else if (ISDIGIT (*spec)) { sym->line_num = atoi (spec); } @@ -134,12 +166,11 @@ DEFUN (parse_spec, (spec, sym), char *spec AND Sym * sym) } -/* - * A symbol id has the syntax SPEC[/SPEC], where SPEC is is defined - * by 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) +parse_id (struct sym_id *id) { char *slash; @@ -158,124 +189,114 @@ DEFUN (parse_id, (id), struct sym_id *id) 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); - } + printf ("%s", id->left.sym.name); else if (id->left.sym.line_num) - { - printf ("%d", id->left.sym.line_num); - } + printf ("%d", id->left.sym.line_num); else - { - printf ("*"); - } + 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); - } + printf ("%s", id->right.sym.name); else if (id->right.sym.line_num) - { - printf ("%d", id->right.sym.line_num); - } + printf ("%d", id->right.sym.line_num); else - { - printf ("*"); - } + printf ("*"); } + printf ("\n"); } #endif } -/* - * Return TRUE iff PATTERN matches SYM. - */ -static bool -DEFUN (match, (pattern, sym), Sym * pattern AND Sym * sym) +/* Return TRUE iff PATTERN matches SYM. */ + +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) == 0 : TRUE); + if (pattern->file && pattern->file != sym->file) + return FALSE; + if (pattern->line_num && pattern->line_num != sym->line_num) + return FALSE; + if (pattern->name) + { + const char *sym_name = sym->name; + if (*sym_name && bfd_get_symbol_leading_char (core_bfd) == *sym_name) + sym_name++; + if (strcmp (pattern->name, sym_name) != 0) + return FALSE; + } + return TRUE; } static void -DEFUN (extend_match, (m, sym, tab, second_pass), - struct match *m AND Sym * sym AND Sym_Table * tab AND bool second_pass) +extend_match (struct match *m, Sym *sym, Sym_Table *tab, bfd_boolean second_pass) { if (m->prev_match != sym - 1) { - /* discontinuity: add new match to table: */ + /* 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: */ + /* Link match into match's chain. */ tab->base[tab->len].next = m->first_match; m->first_match = &tab->base[tab->len]; } + ++tab->len; } - /* extend match to include this symbol: */ + /* Extend match to include this symbol. */ 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; } -/* - * 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! - */ +/* 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_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: - */ + /* 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: */ + 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); - } + 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); - } + 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) { if (tab->len) @@ -285,6 +306,7 @@ DEFUN_VOID (sym_id_parse) tab->len = 0; } } + if (right_ids.len) { right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym)); @@ -292,25 +314,20 @@ DEFUN_VOID (sym_id_parse) 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 (id = id_list; id; id = id->next) { 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)) - { - 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) { if (id->has_right) @@ -331,14 +348,14 @@ DEFUN_VOID (sym_id_parse) (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: */ - + /* 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", @@ -348,27 +365,23 @@ DEFUN_VOID (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) +/* 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. */ +bfd_boolean +sym_id_arc_is_present (Sym_Table *sym_tab, Sym *from, Sym *to) { Sym *sym; - for (sym = symtab->base; sym < symtab->limit; ++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 TRUE; } + return FALSE; }