Commit | Line | Data |
---|---|---|
252b5132 RH |
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 | { | |
8622e41b | 49 | 0, "<non-existent-file>", 0, 0, 0, NULL |
252b5132 RH |
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) | |
5af11cab AM |
204 | && (pattern->name |
205 | ? strcmp (pattern->name, | |
206 | sym->name+(discard_underscores && sym->name[0] == '_')) == 0 | |
207 | : TRUE); | |
252b5132 RH |
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 : "*", | |
fdcf7d43 ILT |
329 | left->name ? left->name : "*", |
330 | (unsigned long) left->addr, | |
331 | (unsigned long) left->end_addr, | |
252b5132 | 332 | right->file ? right->file->name : "*", |
fdcf7d43 ILT |
333 | right->name ? right->name : "*", |
334 | (unsigned long) right->addr, | |
335 | (unsigned long) right->end_addr, | |
252b5132 RH |
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 | } |