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