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