gprof/sym_ids.c

   1 #include <ctype.h>
   2
   3 #include "libiberty.h"
   4 #include "cg_arcs.h"
   5 #include "sym_ids.h"
   6
   7 struct sym_id
   8   {
   9     struct sym_id *next;
  10     char *spec;                 /* parsing modifies this */
  11     Table_Id which_table;
  12     bool has_right;
  13     struct match
  14       {
  15         int prev_index;         /* index of prev match */
  16         Sym *prev_match;        /* previous match */
  17         Sym *first_match;       /* chain of all matches */
  18         Sym sym;
  19       }
  20     left, right;
  21   }
  22  *id_list;
  23
  24 Sym_Table syms[NUM_TABLES];
  25
  26 #ifdef DEBUG
  27 const char *table_name[] =
  28 {
  29   "INCL_GRAPH", "EXCL_GRAPH",
  30   "INCL_ARCS", "EXCL_ARCS",
  31   "INCL_FLAT", "EXCL_FLAT",
  32   "INCL_TIME", "EXCL_TIME",
  33   "INCL_ANNO", "EXCL_ANNO",
  34   "INCL_EXEC", "EXCL_EXEC"
  35 };
  36 #endif /* DEBUG */
  37
  38 /*
  39  * This is the table in which we keep all the syms that match
  40  * the right half of an arc id.  It is NOT sorted according
  41  * to the addresses, because it is accessed only through
  42  * the left half's CHILDREN pointers (so it's crucial not
  43  * to reorder this table once pointers into it exist).
  44  */
  45 static Sym_Table right_ids;
  46
  47 static Source_File non_existent_file =
  48 {
  49   0, "<non-existent-file>", 0, 0, 0, NULL
  50 };
  51
  52
  53 void
  54 DEFUN (sym_id_add, (spec, which_table),
  55        const char *spec AND Table_Id which_table)
  56 {
  57   struct sym_id *id;
  58   int len = strlen (spec);
  59
  60   id = (struct sym_id *) xmalloc (sizeof (*id) + len + 1);
  61   memset (id, 0, sizeof (*id));
  62
  63   id->spec = (char *) id + sizeof (*id);
  64   strcpy (id->spec, spec);
  65   id->which_table = which_table;
  66
  67   id->next = id_list;
  68   id_list = id;
  69 }
  70
  71
  72 /*
  73  * A spec has the syntax FILENAME:(FUNCNAME|LINENUM).  As a convenience
  74  * to the user, a spec without a colon is interpreted as:
  75  *
  76  *      (i)   a FILENAME if it contains a dot
  77  *      (ii)  a FUNCNAME if it starts with a non-digit character
  78  *      (iii) a LINENUM if it starts with a digit
  79  *
  80  * A FUNCNAME containing a dot can be specified by :FUNCNAME, a
  81  * FILENAME not containing a dot can be specified by FILENAME:.
  82  */
  83 static void
  84 DEFUN (parse_spec, (spec, sym), char *spec AND Sym * sym)
  85 {
  86   char *colon;
  87
  88   sym_init (sym);
  89   colon = strrchr (spec, ':');
  90   if (colon)
  91     {
  92       *colon = '\0';
  93       if (colon > spec)
  94         {
  95           sym->file = source_file_lookup_name (spec);
  96           if (!sym->file)
  97             {
  98               sym->file = &non_existent_file;
  99             }
 100         }
 101       spec = colon + 1;
 102       if (strlen (spec))
 103         {
 104           if (isdigit ((unsigned char) spec[0]))
 105             {
 106               sym->line_num = atoi (spec);
 107             }
 108           else
 109             {
 110               sym->name = spec;
 111             }
 112         }
 113     }
 114   else if (strlen (spec))
 115     {
 116       /* no colon: spec is a filename if it contains a dot: */
 117       if (strchr (spec, '.'))
 118         {
 119           sym->file = source_file_lookup_name (spec);
 120           if (!sym->file)
 121             {
 122               sym->file = &non_existent_file;
 123             }
 124         }
 125       else if (isdigit ((unsigned char) *spec))
 126         {
 127           sym->line_num = atoi (spec);
 128         }
 129       else if (strlen (spec))
 130         {
 131           sym->name = spec;
 132         }
 133     }
 134 }
 135
 136
 137 /*
 138  * A symbol id has the syntax SPEC[/SPEC], where SPEC is is defined
 139  * by parse_spec().
 140  */
 141 static void
 142 DEFUN (parse_id, (id), struct sym_id *id)
 143 {
 144   char *slash;
 145
 146   DBG (IDDEBUG, printf ("[parse_id] %s -> ", id->spec));
 147
 148   slash = strchr (id->spec, '/');
 149   if (slash)
 150     {
 151       parse_spec (slash + 1, &id->right.sym);
 152       *slash = '\0';
 153       id->has_right = TRUE;
 154     }
 155   parse_spec (id->spec, &id->left.sym);
 156
 157 #ifdef DEBUG
 158   if (debug_level & IDDEBUG)
 159     {
 160       printf ("%s:", id->left.sym.file ? id->left.sym.file->name : "*");
 161       if (id->left.sym.name)
 162         {
 163           printf ("%s", id->left.sym.name);
 164         }
 165       else if (id->left.sym.line_num)
 166         {
 167           printf ("%d", id->left.sym.line_num);
 168         }
 169       else
 170         {
 171           printf ("*");
 172         }
 173       if (id->has_right)
 174         {
 175           printf ("/%s:",
 176                   id->right.sym.file ? id->right.sym.file->name : "*");
 177           if (id->right.sym.name)
 178             {
 179               printf ("%s", id->right.sym.name);
 180             }
 181           else if (id->right.sym.line_num)
 182             {
 183               printf ("%d", id->right.sym.line_num);
 184             }
 185           else
 186             {
 187               printf ("*");
 188             }
 189         }
 190       printf ("\n");
 191     }
 192 #endif
 193 }
 194
 195
 196 /*
 197  * Return TRUE iff PATTERN matches SYM.
 198  */
 199 static bool
 200 DEFUN (match, (pattern, sym), Sym * pattern AND Sym * sym)
 201 {
 202   return (pattern->file ? pattern->file == sym->file : TRUE)
 203     && (pattern->line_num ? pattern->line_num == sym->line_num : TRUE)
 204     && (pattern->name
 205         ? strcmp (pattern->name,
 206                   sym->name+(discard_underscores && sym->name[0] == '_')) == 0
 207         : TRUE);
 208 }
 209
 210
 211 static void
 212 DEFUN (extend_match, (m, sym, tab, second_pass),
 213      struct match *m AND Sym * sym AND Sym_Table * tab AND bool second_pass)
 214 {
 215   if (m->prev_match != sym - 1)
 216     {
 217       /* discontinuity: add new match to table: */
 218       if (second_pass)
 219         {
 220           tab->base[tab->len] = *sym;
 221           m->prev_index = tab->len;
 222
 223           /* link match into match's chain: */
 224           tab->base[tab->len].next = m->first_match;
 225           m->first_match = &tab->base[tab->len];
 226         }
 227       ++tab->len;
 228     }
 229
 230   /* extend match to include this symbol: */
 231   if (second_pass)
 232     {
 233       tab->base[m->prev_index].end_addr = sym->end_addr;
 234     }
 235   m->prev_match = sym;
 236 }
 237
 238
 239 /*
 240  * Go through sym_id list produced by option processing and fill
 241  * in the various symbol tables indicating what symbols should
 242  * be displayed or suppressed for the various kinds of outputs.
 243  *
 244  * This can potentially produce huge tables and in particulars
 245  * tons of arcs, but this happens only if the user makes silly
 246  * requests---you get what you ask for!
 247  */
 248 void
 249 DEFUN_VOID (sym_id_parse)
 250 {
 251   Sym *sym, *left, *right;
 252   struct sym_id *id;
 253   Sym_Table *tab;
 254
 255   /*
 256    * Convert symbol ids into Syms, so we can deal with them more easily:
 257    */
 258   for (id = id_list; id; id = id->next)
 259     {
 260       parse_id (id);
 261     }
 262
 263   /* first determine size of each table: */
 264
 265   for (sym = symtab.base; sym < symtab.limit; ++sym)
 266     {
 267       for (id = id_list; id; id = id->next)
 268         {
 269           if (match (&id->left.sym, sym))
 270             {
 271               extend_match (&id->left, sym, &syms[id->which_table], FALSE);
 272             }
 273           if (id->has_right && match (&id->right.sym, sym))
 274             {
 275               extend_match (&id->right, sym, &right_ids, FALSE);
 276             }
 277         }
 278     }
 279
 280   /* create tables of appropriate size and reset lengths: */
 281
 282   for (tab = syms; tab < &syms[NUM_TABLES]; ++tab)
 283     {
 284       if (tab->len)
 285         {
 286           tab->base = (Sym *) xmalloc (tab->len * sizeof (Sym));
 287           tab->limit = tab->base + tab->len;
 288           tab->len = 0;
 289         }
 290     }
 291   if (right_ids.len)
 292     {
 293       right_ids.base = (Sym *) xmalloc (right_ids.len * sizeof (Sym));
 294       right_ids.limit = right_ids.base + right_ids.len;
 295       right_ids.len = 0;
 296     }
 297
 298   /* make a second pass through symtab, creating syms as necessary: */
 299
 300   for (sym = symtab.base; sym < symtab.limit; ++sym)
 301     {
 302       for (id = id_list; id; id = id->next)
 303         {
 304           if (match (&id->left.sym, sym))
 305             {
 306               extend_match (&id->left, sym, &syms[id->which_table], TRUE);
 307             }
 308           if (id->has_right && match (&id->right.sym, sym))
 309             {
 310               extend_match (&id->right, sym, &right_ids, TRUE);
 311             }
 312         }
 313     }
 314
 315   /* go through ids creating arcs as needed: */
 316
 317   for (id = id_list; id; id = id->next)
 318     {
 319       if (id->has_right)
 320         {
 321           for (left = id->left.first_match; left; left = left->next)
 322             {
 323               for (right = id->right.first_match; right; right = right->next)
 324                 {
 325                   DBG (IDDEBUG,
 326                        printf (
 327                                 "[sym_id_parse]: arc %s:%s(%lx-%lx) -> %s:%s(%lx-%lx) to %s\n",
 328                                 left->file ? left->file->name : "*",
 329                                 left->name ? left->name : "*",
 330                                 (unsigned long) left->addr,
 331                                 (unsigned long) left->end_addr,
 332                                 right->file ? right->file->name : "*",
 333                                 right->name ? right->name : "*",
 334                                 (unsigned long) right->addr,
 335                                 (unsigned long) right->end_addr,
 336                                 table_name[id->which_table]));
 337                   arc_add (left, right, (unsigned long) 0);
 338                 }
 339             }
 340         }
 341     }
 342
 343   /* finally, we can sort the tables and we're done: */
 344
 345   for (tab = &syms[0]; tab < &syms[NUM_TABLES]; ++tab)
 346     {
 347       DBG (IDDEBUG, printf ("[sym_id_parse] syms[%s]:\n",
 348                             table_name[tab - &syms[0]]));
 349       symtab_finalize (tab);
 350     }
 351 }
 352
 353
 354 /*
 355  * Symbol tables storing the FROM symbols of arcs do not necessarily
 356  * have distinct address ranges.  For example, somebody might request
 357  * -k /_mcount to suppress any arcs into _mcount, while at the same
 358  * time requesting -k a/b.  Fortunately, those symbol tables don't get
 359  * very big (the user has to type them!), so a linear search is probably
 360  * tolerable.
 361  */
 362 bool
 363 DEFUN (sym_id_arc_is_present, (symtab, from, to),
 364        Sym_Table * symtab AND Sym * from AND Sym * to)
 365 {
 366   Sym *sym;
 367
 368   for (sym = symtab->base; sym < symtab->limit; ++sym)
 369     {
 370       if (from->addr >= sym->addr && from->addr <= sym->end_addr
 371           && arc_lookup (sym, to))
 372         {
 373           return TRUE;
 374         }
 375     }
 376   return FALSE;
 377 }