File: | src/gnu/usr.bin/binutils-2.17/binutils/stabs.c |
Warning: | line 869, column 16 Dereference of null pointer (loaded from variable 'name') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* stabs.c -- Parse stabs debugging information | |||
2 | Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 | |||
3 | Free Software Foundation, Inc. | |||
4 | Written by Ian Lance Taylor <ian@cygnus.com>. | |||
5 | ||||
6 | This file is part of GNU Binutils. | |||
7 | ||||
8 | This program is free software; you can redistribute it and/or modify | |||
9 | it under the terms of the GNU General Public License as published by | |||
10 | the Free Software Foundation; either version 2 of the License, or | |||
11 | (at your option) any later version. | |||
12 | ||||
13 | This program is distributed in the hope that it will be useful, | |||
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
16 | GNU General Public License for more details. | |||
17 | ||||
18 | You should have received a copy of the GNU General Public License | |||
19 | along with this program; if not, write to the Free Software | |||
20 | Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA | |||
21 | 02110-1301, USA. */ | |||
22 | ||||
23 | /* This file contains code which parses stabs debugging information. | |||
24 | The organization of this code is based on the gdb stabs reading | |||
25 | code. The job it does is somewhat different, because it is not | |||
26 | trying to identify the correct address for anything. */ | |||
27 | ||||
28 | #include <stdio.h> | |||
29 | ||||
30 | #include "bfd.h" | |||
31 | #include "bucomm.h" | |||
32 | #include "libiberty.h" | |||
33 | #include "safe-ctype.h" | |||
34 | #include "demangle.h" | |||
35 | #include "debug.h" | |||
36 | #include "budbg.h" | |||
37 | #include "filenames.h" | |||
38 | #include "aout/aout64.h" | |||
39 | #include "aout/stab_gnu.h" | |||
40 | ||||
41 | /* The number of predefined XCOFF types. */ | |||
42 | ||||
43 | #define XCOFF_TYPE_COUNT34 34 | |||
44 | ||||
45 | /* This structure is used as a handle so that the stab parsing doesn't | |||
46 | need to use any static variables. */ | |||
47 | ||||
48 | struct stab_handle | |||
49 | { | |||
50 | /* The BFD. */ | |||
51 | bfd *abfd; | |||
52 | /* TRUE if this is stabs in sections. */ | |||
53 | bfd_boolean sections; | |||
54 | /* The symbol table. */ | |||
55 | asymbol **syms; | |||
56 | /* The number of symbols. */ | |||
57 | long symcount; | |||
58 | /* The accumulated file name string. */ | |||
59 | char *so_string; | |||
60 | /* The value of the last N_SO symbol. */ | |||
61 | bfd_vma so_value; | |||
62 | /* The value of the start of the file, so that we can handle file | |||
63 | relative N_LBRAC and N_RBRAC symbols. */ | |||
64 | bfd_vma file_start_offset; | |||
65 | /* The offset of the start of the function, so that we can handle | |||
66 | function relative N_LBRAC and N_RBRAC symbols. */ | |||
67 | bfd_vma function_start_offset; | |||
68 | /* The version number of gcc which compiled the current compilation | |||
69 | unit, 0 if not compiled by gcc. */ | |||
70 | int gcc_compiled; | |||
71 | /* Whether an N_OPT symbol was seen that was not generated by gcc, | |||
72 | so that we can detect the SunPRO compiler. */ | |||
73 | bfd_boolean n_opt_found; | |||
74 | /* The main file name. */ | |||
75 | char *main_filename; | |||
76 | /* A stack of unfinished N_BINCL files. */ | |||
77 | struct bincl_file *bincl_stack; | |||
78 | /* A list of finished N_BINCL files. */ | |||
79 | struct bincl_file *bincl_list; | |||
80 | /* Whether we are inside a function or not. */ | |||
81 | bfd_boolean within_function; | |||
82 | /* The address of the end of the function, used if we have seen an | |||
83 | N_FUN symbol while in a function. This is -1 if we have not seen | |||
84 | an N_FUN (the normal case). */ | |||
85 | bfd_vma function_end; | |||
86 | /* The depth of block nesting. */ | |||
87 | int block_depth; | |||
88 | /* List of pending variable definitions. */ | |||
89 | struct stab_pending_var *pending; | |||
90 | /* Number of files for which we have types. */ | |||
91 | unsigned int files; | |||
92 | /* Lists of types per file. */ | |||
93 | struct stab_types **file_types; | |||
94 | /* Predefined XCOFF types. */ | |||
95 | debug_type xcoff_types[XCOFF_TYPE_COUNT34]; | |||
96 | /* Undefined tags. */ | |||
97 | struct stab_tag *tags; | |||
98 | /* Set by parse_stab_type if it sees a structure defined as a cross | |||
99 | reference to itself. Reset by parse_stab_type otherwise. */ | |||
100 | bfd_boolean self_crossref; | |||
101 | }; | |||
102 | ||||
103 | /* A list of these structures is used to hold pending variable | |||
104 | definitions seen before the N_LBRAC of a block. */ | |||
105 | ||||
106 | struct stab_pending_var | |||
107 | { | |||
108 | /* Next pending variable definition. */ | |||
109 | struct stab_pending_var *next; | |||
110 | /* Name. */ | |||
111 | const char *name; | |||
112 | /* Type. */ | |||
113 | debug_type type; | |||
114 | /* Kind. */ | |||
115 | enum debug_var_kind kind; | |||
116 | /* Value. */ | |||
117 | bfd_vma val; | |||
118 | }; | |||
119 | ||||
120 | /* A list of these structures is used to hold the types for a single | |||
121 | file. */ | |||
122 | ||||
123 | struct stab_types | |||
124 | { | |||
125 | /* Next set of slots for this file. */ | |||
126 | struct stab_types *next; | |||
127 | /* Types indexed by type number. */ | |||
128 | #define STAB_TYPES_SLOTS(16) (16) | |||
129 | debug_type types[STAB_TYPES_SLOTS(16)]; | |||
130 | }; | |||
131 | ||||
132 | /* We keep a list of undefined tags that we encounter, so that we can | |||
133 | fill them in if the tag is later defined. */ | |||
134 | ||||
135 | struct stab_tag | |||
136 | { | |||
137 | /* Next undefined tag. */ | |||
138 | struct stab_tag *next; | |||
139 | /* Tag name. */ | |||
140 | const char *name; | |||
141 | /* Type kind. */ | |||
142 | enum debug_type_kind kind; | |||
143 | /* Slot to hold real type when we discover it. If we don't, we fill | |||
144 | in an undefined tag type. */ | |||
145 | debug_type slot; | |||
146 | /* Indirect type we have created to point at slot. */ | |||
147 | debug_type type; | |||
148 | }; | |||
149 | ||||
150 | static char *savestring (const char *, int); | |||
151 | static bfd_vma parse_number (const char **, bfd_boolean *); | |||
152 | static void bad_stab (const char *); | |||
153 | static void warn_stab (const char *, const char *); | |||
154 | static bfd_boolean parse_stab_string | |||
155 | (void *, struct stab_handle *, int, int, bfd_vma, const char *); | |||
156 | static debug_type parse_stab_type | |||
157 | (void *, struct stab_handle *, const char *, const char **, debug_type **); | |||
158 | static bfd_boolean parse_stab_type_number (const char **, int *); | |||
159 | static debug_type parse_stab_range_type | |||
160 | (void *, struct stab_handle *, const char *, const char **, const int *); | |||
161 | static debug_type parse_stab_sun_builtin_type (void *, const char **); | |||
162 | static debug_type parse_stab_sun_floating_type (void *, const char **); | |||
163 | static debug_type parse_stab_enum_type (void *, const char **); | |||
164 | static debug_type parse_stab_struct_type | |||
165 | (void *, struct stab_handle *, const char *, const char **, | |||
166 | bfd_boolean, const int *); | |||
167 | static bfd_boolean parse_stab_baseclasses | |||
168 | (void *, struct stab_handle *, const char **, debug_baseclass **); | |||
169 | static bfd_boolean parse_stab_struct_fields | |||
170 | (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *); | |||
171 | static bfd_boolean parse_stab_cpp_abbrev | |||
172 | (void *, struct stab_handle *, const char **, debug_field *); | |||
173 | static bfd_boolean parse_stab_one_struct_field | |||
174 | (void *, struct stab_handle *, const char **, const char *, | |||
175 | debug_field *, bfd_boolean *); | |||
176 | static bfd_boolean parse_stab_members | |||
177 | (void *, struct stab_handle *, const char *, const char **, const int *, | |||
178 | debug_method **); | |||
179 | static debug_type parse_stab_argtypes | |||
180 | (void *, struct stab_handle *, debug_type, const char *, const char *, | |||
181 | debug_type, const char *, bfd_boolean, bfd_boolean, const char **); | |||
182 | static bfd_boolean parse_stab_tilde_field | |||
183 | (void *, struct stab_handle *, const char **, const int *, debug_type *, | |||
184 | bfd_boolean *); | |||
185 | static debug_type parse_stab_array_type | |||
186 | (void *, struct stab_handle *, const char **, bfd_boolean); | |||
187 | static void push_bincl (struct stab_handle *, const char *, bfd_vma); | |||
188 | static const char *pop_bincl (struct stab_handle *); | |||
189 | static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma); | |||
190 | static bfd_boolean stab_record_variable | |||
191 | (void *, struct stab_handle *, const char *, debug_type, | |||
192 | enum debug_var_kind, bfd_vma); | |||
193 | static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *); | |||
194 | static debug_type *stab_find_slot (struct stab_handle *, const int *); | |||
195 | static debug_type stab_find_type (void *, struct stab_handle *, const int *); | |||
196 | static bfd_boolean stab_record_type | |||
197 | (void *, struct stab_handle *, const int *, debug_type); | |||
198 | static debug_type stab_xcoff_builtin_type | |||
199 | (void *, struct stab_handle *, int); | |||
200 | static debug_type stab_find_tagged_type | |||
201 | (void *, struct stab_handle *, const char *, int, enum debug_type_kind); | |||
202 | static debug_type *stab_demangle_argtypes | |||
203 | (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int); | |||
204 | static debug_type *stab_demangle_v3_argtypes | |||
205 | (void *, struct stab_handle *, const char *, bfd_boolean *); | |||
206 | static debug_type *stab_demangle_v3_arglist | |||
207 | (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *); | |||
208 | static debug_type stab_demangle_v3_arg | |||
209 | (void *, struct stab_handle *, struct demangle_component *, debug_type, | |||
210 | bfd_boolean *); | |||
211 | ||||
212 | /* Save a string in memory. */ | |||
213 | ||||
214 | static char * | |||
215 | savestring (const char *start, int len) | |||
216 | { | |||
217 | char *ret; | |||
218 | ||||
219 | ret = (char *) xmalloc (len + 1); | |||
220 | memcpy (ret, start, len); | |||
221 | ret[len] = '\0'; | |||
222 | return ret; | |||
223 | } | |||
224 | ||||
225 | /* Read a number from a string. */ | |||
226 | ||||
227 | static bfd_vma | |||
228 | parse_number (const char **pp, bfd_boolean *poverflow) | |||
229 | { | |||
230 | unsigned long ul; | |||
231 | const char *orig; | |||
232 | ||||
233 | if (poverflow != NULL((void*)0)) | |||
234 | *poverflow = FALSE0; | |||
235 | ||||
236 | orig = *pp; | |||
237 | ||||
238 | errno(*__errno()) = 0; | |||
239 | ul = strtoul (*pp, (char **) pp, 0); | |||
240 | if (ul + 1 != 0 || errno(*__errno()) == 0) | |||
241 | { | |||
242 | /* If bfd_vma is larger than unsigned long, and the number is | |||
243 | meant to be negative, we have to make sure that we sign | |||
244 | extend properly. */ | |||
245 | if (*orig == '-') | |||
246 | return (bfd_vma) (bfd_signed_vma) (long) ul; | |||
247 | return (bfd_vma) ul; | |||
248 | } | |||
249 | ||||
250 | /* Note that even though strtoul overflowed, it should have set *pp | |||
251 | to the end of the number, which is where we want it. */ | |||
252 | if (sizeof (bfd_vma) > sizeof (unsigned long)) | |||
253 | { | |||
254 | const char *p; | |||
255 | bfd_boolean neg; | |||
256 | int base; | |||
257 | bfd_vma over, lastdig; | |||
258 | bfd_boolean overflow; | |||
259 | bfd_vma v; | |||
260 | ||||
261 | /* Our own version of strtoul, for a bfd_vma. */ | |||
262 | p = orig; | |||
263 | ||||
264 | neg = FALSE0; | |||
265 | if (*p == '+') | |||
266 | ++p; | |||
267 | else if (*p == '-') | |||
268 | { | |||
269 | neg = TRUE1; | |||
270 | ++p; | |||
271 | } | |||
272 | ||||
273 | base = 10; | |||
274 | if (*p == '0') | |||
275 | { | |||
276 | if (p[1] == 'x' || p[1] == 'X') | |||
277 | { | |||
278 | base = 16; | |||
279 | p += 2; | |||
280 | } | |||
281 | else | |||
282 | { | |||
283 | base = 8; | |||
284 | ++p; | |||
285 | } | |||
286 | } | |||
287 | ||||
288 | over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base; | |||
289 | lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base; | |||
290 | ||||
291 | overflow = FALSE0; | |||
292 | v = 0; | |||
293 | while (1) | |||
294 | { | |||
295 | int d; | |||
296 | ||||
297 | d = *p++; | |||
298 | if (ISDIGIT (d)(_sch_istable[(d) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
299 | d -= '0'; | |||
300 | else if (ISUPPER (d)(_sch_istable[(d) & 0xff] & (unsigned short)(_sch_isupper ))) | |||
301 | d -= 'A'; | |||
302 | else if (ISLOWER (d)(_sch_istable[(d) & 0xff] & (unsigned short)(_sch_islower ))) | |||
303 | d -= 'a'; | |||
304 | else | |||
305 | break; | |||
306 | ||||
307 | if (d >= base) | |||
308 | break; | |||
309 | ||||
310 | if (v > over || (v == over && (bfd_vma) d > lastdig)) | |||
311 | { | |||
312 | overflow = TRUE1; | |||
313 | break; | |||
314 | } | |||
315 | } | |||
316 | ||||
317 | if (! overflow) | |||
318 | { | |||
319 | if (neg) | |||
320 | v = - v; | |||
321 | return v; | |||
322 | } | |||
323 | } | |||
324 | ||||
325 | /* If we get here, the number is too large to represent in a | |||
326 | bfd_vma. */ | |||
327 | if (poverflow != NULL((void*)0)) | |||
328 | *poverflow = TRUE1; | |||
329 | else | |||
330 | warn_stab (orig, _("numeric overflow")("numeric overflow")); | |||
331 | ||||
332 | return 0; | |||
333 | } | |||
334 | ||||
335 | /* Give an error for a bad stab string. */ | |||
336 | ||||
337 | static void | |||
338 | bad_stab (const char *p) | |||
339 | { | |||
340 | fprintf (stderr(&__sF[2]), _("Bad stab: %s\n")("Bad stab: %s\n"), p); | |||
341 | } | |||
342 | ||||
343 | /* Warn about something in a stab string. */ | |||
344 | ||||
345 | static void | |||
346 | warn_stab (const char *p, const char *err) | |||
347 | { | |||
348 | fprintf (stderr(&__sF[2]), _("Warning: %s: %s\n")("Warning: %s: %s\n"), err, p); | |||
349 | } | |||
350 | ||||
351 | /* Create a handle to parse stabs symbols with. */ | |||
352 | ||||
353 | void * | |||
354 | start_stab (void *dhandle ATTRIBUTE_UNUSED__attribute__ ((__unused__)), bfd *abfd, bfd_boolean sections, | |||
355 | asymbol **syms, long symcount) | |||
356 | { | |||
357 | struct stab_handle *ret; | |||
358 | ||||
359 | ret = (struct stab_handle *) xmalloc (sizeof *ret); | |||
360 | memset (ret, 0, sizeof *ret); | |||
361 | ret->abfd = abfd; | |||
362 | ret->sections = sections; | |||
363 | ret->syms = syms; | |||
364 | ret->symcount = symcount; | |||
365 | ret->files = 1; | |||
366 | ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types); | |||
367 | ret->file_types[0] = NULL((void*)0); | |||
368 | ret->function_end = (bfd_vma) -1; | |||
369 | return (void *) ret; | |||
370 | } | |||
371 | ||||
372 | /* When we have processed all the stabs information, we need to go | |||
373 | through and fill in all the undefined tags. */ | |||
374 | ||||
375 | bfd_boolean | |||
376 | finish_stab (void *dhandle, void *handle) | |||
377 | { | |||
378 | struct stab_handle *info = (struct stab_handle *) handle; | |||
379 | struct stab_tag *st; | |||
380 | ||||
381 | if (info->within_function) | |||
382 | { | |||
383 | if (! stab_emit_pending_vars (dhandle, info) | |||
384 | || ! debug_end_function (dhandle, info->function_end)) | |||
385 | return FALSE0; | |||
386 | info->within_function = FALSE0; | |||
387 | info->function_end = (bfd_vma) -1; | |||
388 | } | |||
389 | ||||
390 | for (st = info->tags; st != NULL((void*)0); st = st->next) | |||
391 | { | |||
392 | enum debug_type_kind kind; | |||
393 | ||||
394 | kind = st->kind; | |||
395 | if (kind == DEBUG_KIND_ILLEGAL) | |||
396 | kind = DEBUG_KIND_STRUCT; | |||
397 | st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind); | |||
398 | if (st->slot == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
399 | return FALSE0; | |||
400 | } | |||
401 | ||||
402 | return TRUE1; | |||
403 | } | |||
404 | ||||
405 | /* Handle a single stabs symbol. */ | |||
406 | ||||
407 | bfd_boolean | |||
408 | parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value, | |||
409 | const char *string) | |||
410 | { | |||
411 | struct stab_handle *info = (struct stab_handle *) handle; | |||
412 | ||||
413 | /* gcc will emit two N_SO strings per compilation unit, one for the | |||
414 | directory name and one for the file name. We just collect N_SO | |||
415 | strings as we see them, and start the new compilation unit when | |||
416 | we see a non N_SO symbol. */ | |||
417 | if (info->so_string != NULL((void*)0) | |||
418 | && (type != N_SO || *string == '\0' || value != info->so_value)) | |||
419 | { | |||
420 | if (! debug_set_filename (dhandle, info->so_string)) | |||
421 | return FALSE0; | |||
422 | info->main_filename = info->so_string; | |||
423 | ||||
424 | info->gcc_compiled = 0; | |||
425 | info->n_opt_found = FALSE0; | |||
426 | ||||
427 | /* Generally, for stabs in the symbol table, the N_LBRAC and | |||
428 | N_RBRAC symbols are relative to the N_SO symbol value. */ | |||
429 | if (! info->sections) | |||
430 | info->file_start_offset = info->so_value; | |||
431 | ||||
432 | /* We need to reset the mapping from type numbers to types. We | |||
433 | can't free the old mapping, because of the use of | |||
434 | debug_make_indirect_type. */ | |||
435 | info->files = 1; | |||
436 | info->file_types = ((struct stab_types **) | |||
437 | xmalloc (sizeof *info->file_types)); | |||
438 | info->file_types[0] = NULL((void*)0); | |||
439 | ||||
440 | info->so_string = NULL((void*)0); | |||
441 | ||||
442 | /* Now process whatever type we just got. */ | |||
443 | } | |||
444 | ||||
445 | switch (type) | |||
446 | { | |||
447 | case N_FN0x1f: | |||
448 | case N_FN_SEQ0x0C: | |||
449 | break; | |||
450 | ||||
451 | case N_LBRAC: | |||
452 | /* Ignore extra outermost context from SunPRO cc and acc. */ | |||
453 | if (info->n_opt_found && desc == 1) | |||
454 | break; | |||
455 | ||||
456 | if (! info->within_function) | |||
457 | { | |||
458 | fprintf (stderr(&__sF[2]), _("N_LBRAC not within function\n")("N_LBRAC not within function\n")); | |||
459 | return FALSE0; | |||
460 | } | |||
461 | ||||
462 | /* Start an inner lexical block. */ | |||
463 | if (! debug_start_block (dhandle, | |||
464 | (value | |||
465 | + info->file_start_offset | |||
466 | + info->function_start_offset))) | |||
467 | return FALSE0; | |||
468 | ||||
469 | /* Emit any pending variable definitions. */ | |||
470 | if (! stab_emit_pending_vars (dhandle, info)) | |||
471 | return FALSE0; | |||
472 | ||||
473 | ++info->block_depth; | |||
474 | break; | |||
475 | ||||
476 | case N_RBRAC: | |||
477 | /* Ignore extra outermost context from SunPRO cc and acc. */ | |||
478 | if (info->n_opt_found && desc == 1) | |||
479 | break; | |||
480 | ||||
481 | /* We shouldn't have any pending variable definitions here, but, | |||
482 | if we do, we probably need to emit them before closing the | |||
483 | block. */ | |||
484 | if (! stab_emit_pending_vars (dhandle, info)) | |||
485 | return FALSE0; | |||
486 | ||||
487 | /* End an inner lexical block. */ | |||
488 | if (! debug_end_block (dhandle, | |||
489 | (value | |||
490 | + info->file_start_offset | |||
491 | + info->function_start_offset))) | |||
492 | return FALSE0; | |||
493 | ||||
494 | --info->block_depth; | |||
495 | if (info->block_depth < 0) | |||
496 | { | |||
497 | fprintf (stderr(&__sF[2]), _("Too many N_RBRACs\n")("Too many N_RBRACs\n")); | |||
498 | return FALSE0; | |||
499 | } | |||
500 | break; | |||
501 | ||||
502 | case N_SO: | |||
503 | /* This always ends a function. */ | |||
504 | if (info->within_function) | |||
505 | { | |||
506 | bfd_vma endval; | |||
507 | ||||
508 | endval = value; | |||
509 | if (*string != '\0' | |||
510 | && info->function_end != (bfd_vma) -1 | |||
511 | && info->function_end < endval) | |||
512 | endval = info->function_end; | |||
513 | if (! stab_emit_pending_vars (dhandle, info) | |||
514 | || ! debug_end_function (dhandle, endval)) | |||
515 | return FALSE0; | |||
516 | info->within_function = FALSE0; | |||
517 | info->function_end = (bfd_vma) -1; | |||
518 | } | |||
519 | ||||
520 | /* An empty string is emitted by gcc at the end of a compilation | |||
521 | unit. */ | |||
522 | if (*string == '\0') | |||
523 | return TRUE1; | |||
524 | ||||
525 | /* Just accumulate strings until we see a non N_SO symbol. If | |||
526 | the string starts with a directory separator or some other | |||
527 | form of absolute path specification, we discard the previously | |||
528 | accumulated strings. */ | |||
529 | if (info->so_string == NULL((void*)0)) | |||
530 | info->so_string = xstrdup (string); | |||
531 | else | |||
532 | { | |||
533 | char *f; | |||
534 | ||||
535 | f = info->so_string; | |||
536 | ||||
537 | if (IS_ABSOLUTE_PATH (string)((((string)[0]) == '/'))) | |||
538 | info->so_string = xstrdup (string); | |||
539 | else | |||
540 | info->so_string = concat (info->so_string, string, | |||
541 | (const char *) NULL((void*)0)); | |||
542 | free (f); | |||
543 | } | |||
544 | ||||
545 | info->so_value = value; | |||
546 | ||||
547 | break; | |||
548 | ||||
549 | case N_SOL: | |||
550 | /* Start an include file. */ | |||
551 | if (! debug_start_source (dhandle, string)) | |||
552 | return FALSE0; | |||
553 | break; | |||
554 | ||||
555 | case N_BINCL: | |||
556 | /* Start an include file which may be replaced. */ | |||
557 | push_bincl (info, string, value); | |||
558 | if (! debug_start_source (dhandle, string)) | |||
559 | return FALSE0; | |||
560 | break; | |||
561 | ||||
562 | case N_EINCL: | |||
563 | /* End an N_BINCL include. */ | |||
564 | if (! debug_start_source (dhandle, pop_bincl (info))) | |||
565 | return FALSE0; | |||
566 | break; | |||
567 | ||||
568 | case N_EXCL: | |||
569 | /* This is a duplicate of a header file named by N_BINCL which | |||
570 | was eliminated by the linker. */ | |||
571 | if (! find_excl (info, string, value)) | |||
572 | return FALSE0; | |||
573 | break; | |||
574 | ||||
575 | case N_SLINE: | |||
576 | if (! debug_record_line (dhandle, desc, | |||
577 | value + (info->within_function | |||
578 | ? info->function_start_offset : 0))) | |||
579 | return FALSE0; | |||
580 | break; | |||
581 | ||||
582 | case N_BCOMM: | |||
583 | if (! debug_start_common_block (dhandle, string)) | |||
584 | return FALSE0; | |||
585 | break; | |||
586 | ||||
587 | case N_ECOMM: | |||
588 | if (! debug_end_common_block (dhandle, string)) | |||
589 | return FALSE0; | |||
590 | break; | |||
591 | ||||
592 | case N_FUN: | |||
593 | if (*string == '\0') | |||
594 | { | |||
595 | if (info->within_function) | |||
596 | { | |||
597 | /* This always marks the end of a function; we don't | |||
598 | need to worry about info->function_end. */ | |||
599 | if (info->sections) | |||
600 | value += info->function_start_offset; | |||
601 | if (! stab_emit_pending_vars (dhandle, info) | |||
602 | || ! debug_end_function (dhandle, value)) | |||
603 | return FALSE0; | |||
604 | info->within_function = FALSE0; | |||
605 | info->function_end = (bfd_vma) -1; | |||
606 | } | |||
607 | break; | |||
608 | } | |||
609 | ||||
610 | /* A const static symbol in the .text section will have an N_FUN | |||
611 | entry. We need to use these to mark the end of the function, | |||
612 | in case we are looking at gcc output before it was changed to | |||
613 | always emit an empty N_FUN. We can't call debug_end_function | |||
614 | here, because it might be a local static symbol. */ | |||
615 | if (info->within_function | |||
616 | && (info->function_end == (bfd_vma) -1 | |||
617 | || value < info->function_end)) | |||
618 | info->function_end = value; | |||
619 | ||||
620 | /* Fall through. */ | |||
621 | /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM | |||
622 | symbols, and if it does not start with :S, gdb relocates the | |||
623 | value to the start of the section. gcc always seems to use | |||
624 | :S, so we don't worry about this. */ | |||
625 | /* Fall through. */ | |||
626 | default: | |||
627 | { | |||
628 | const char *colon; | |||
629 | ||||
630 | colon = strchr (string, ':'); | |||
631 | if (colon != NULL((void*)0) | |||
632 | && (colon[1] == 'f' || colon[1] == 'F')) | |||
633 | { | |||
634 | if (info->within_function) | |||
635 | { | |||
636 | bfd_vma endval; | |||
637 | ||||
638 | endval = value; | |||
639 | if (info->function_end != (bfd_vma) -1 | |||
640 | && info->function_end < endval) | |||
641 | endval = info->function_end; | |||
642 | if (! stab_emit_pending_vars (dhandle, info) | |||
643 | || ! debug_end_function (dhandle, endval)) | |||
644 | return FALSE0; | |||
645 | info->function_end = (bfd_vma) -1; | |||
646 | } | |||
647 | /* For stabs in sections, line numbers and block addresses | |||
648 | are offsets from the start of the function. */ | |||
649 | if (info->sections) | |||
650 | info->function_start_offset = value; | |||
651 | info->within_function = TRUE1; | |||
652 | } | |||
653 | ||||
654 | if (! parse_stab_string (dhandle, info, type, desc, value, string)) | |||
655 | return FALSE0; | |||
656 | } | |||
657 | break; | |||
658 | ||||
659 | case N_OPT: | |||
660 | if (string != NULL((void*)0) && strcmp (string, "gcc2_compiled.") == 0) | |||
661 | info->gcc_compiled = 2; | |||
662 | else if (string != NULL((void*)0) && strcmp (string, "gcc_compiled.") == 0) | |||
663 | info->gcc_compiled = 1; | |||
664 | else | |||
665 | info->n_opt_found = TRUE1; | |||
666 | break; | |||
667 | ||||
668 | case N_OBJ: | |||
669 | case N_ENDM: | |||
670 | case N_MAIN: | |||
671 | case N_WARNING0x1e: | |||
672 | break; | |||
673 | } | |||
674 | ||||
675 | return TRUE1; | |||
676 | } | |||
677 | ||||
678 | /* Parse the stabs string. */ | |||
679 | ||||
680 | static bfd_boolean | |||
681 | parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype, | |||
682 | int desc, bfd_vma value, const char *string) | |||
683 | { | |||
684 | const char *p; | |||
685 | char *name; | |||
686 | int type; | |||
687 | debug_type dtype; | |||
688 | bfd_boolean synonym; | |||
689 | bfd_boolean self_crossref; | |||
690 | unsigned int lineno; | |||
691 | debug_type *slot; | |||
692 | ||||
693 | p = strchr (string, ':'); | |||
694 | if (p == NULL((void*)0)) | |||
| ||||
695 | return TRUE1; | |||
696 | ||||
697 | while (p[1] == ':') | |||
698 | { | |||
699 | p += 2; | |||
700 | p = strchr (p, ':'); | |||
701 | if (p == NULL((void*)0)) | |||
702 | { | |||
703 | bad_stab (string); | |||
704 | return FALSE0; | |||
705 | } | |||
706 | } | |||
707 | ||||
708 | /* GCC 2.x puts the line number in desc. SunOS apparently puts in | |||
709 | the number of bytes occupied by a type or object, which we | |||
710 | ignore. */ | |||
711 | if (info->gcc_compiled >= 2) | |||
712 | lineno = desc; | |||
713 | else | |||
714 | lineno = 0; | |||
715 | ||||
716 | /* FIXME: Sometimes the special C++ names start with '.'. */ | |||
717 | name = NULL((void*)0); | |||
718 | if (string[0] == '$') | |||
719 | { | |||
720 | switch (string[1]) | |||
721 | { | |||
722 | case 't': | |||
723 | name = "this"; | |||
724 | break; | |||
725 | case 'v': | |||
726 | /* Was: name = "vptr"; */ | |||
727 | break; | |||
728 | case 'e': | |||
729 | name = "eh_throw"; | |||
730 | break; | |||
731 | case '_': | |||
732 | /* This was an anonymous type that was never fixed up. */ | |||
733 | break; | |||
734 | case 'X': | |||
735 | /* SunPRO (3.0 at least) static variable encoding. */ | |||
736 | break; | |||
737 | default: | |||
738 | warn_stab (string, _("unknown C++ encoded name")("unknown C++ encoded name")); | |||
739 | break; | |||
740 | } | |||
741 | } | |||
742 | ||||
743 | if (name
| |||
744 | { | |||
745 | if (p == string || (string[0] == ' ' && p == string + 1)) | |||
746 | name = NULL((void*)0); | |||
747 | else | |||
748 | name = savestring (string, p - string); | |||
749 | } | |||
750 | ||||
751 | ++p; | |||
752 | if (ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit )) || *p == '(' || *p == '-') | |||
753 | type = 'l'; | |||
754 | else | |||
755 | type = *p++; | |||
756 | ||||
757 | switch (type) | |||
758 | { | |||
759 | case 'c': | |||
760 | /* c is a special case, not followed by a type-number. | |||
761 | SYMBOL:c=iVALUE for an integer constant symbol. | |||
762 | SYMBOL:c=rVALUE for a floating constant symbol. | |||
763 | SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol. | |||
764 | e.g. "b:c=e6,0" for "const b = blob1" | |||
765 | (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ | |||
766 | if (*p != '=') | |||
767 | { | |||
768 | bad_stab (string); | |||
769 | return FALSE0; | |||
770 | } | |||
771 | ++p; | |||
772 | switch (*p++) | |||
773 | { | |||
774 | case 'r': | |||
775 | /* Floating point constant. */ | |||
776 | if (! debug_record_float_const (dhandle, name, atof (p))) | |||
777 | return FALSE0; | |||
778 | break; | |||
779 | case 'i': | |||
780 | /* Integer constant. */ | |||
781 | /* Defining integer constants this way is kind of silly, | |||
782 | since 'e' constants allows the compiler to give not only | |||
783 | the value, but the type as well. C has at least int, | |||
784 | long, unsigned int, and long long as constant types; | |||
785 | other languages probably should have at least unsigned as | |||
786 | well as signed constants. */ | |||
787 | if (! debug_record_int_const (dhandle, name, atoi (p))) | |||
788 | return FALSE0; | |||
789 | break; | |||
790 | case 'e': | |||
791 | /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value | |||
792 | can be represented as integral. | |||
793 | e.g. "b:c=e6,0" for "const b = blob1" | |||
794 | (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ | |||
795 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
796 | &p, (debug_type **) NULL((void*)0)); | |||
797 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
798 | return FALSE0; | |||
799 | if (*p != ',') | |||
800 | { | |||
801 | bad_stab (string); | |||
802 | return FALSE0; | |||
803 | } | |||
804 | if (! debug_record_typed_const (dhandle, name, dtype, atoi (p))) | |||
805 | return FALSE0; | |||
806 | break; | |||
807 | default: | |||
808 | bad_stab (string); | |||
809 | return FALSE0; | |||
810 | } | |||
811 | ||||
812 | break; | |||
813 | ||||
814 | case 'C': | |||
815 | /* The name of a caught exception. */ | |||
816 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
817 | &p, (debug_type **) NULL((void*)0)); | |||
818 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
819 | return FALSE0; | |||
820 | if (! debug_record_label (dhandle, name, dtype, value)) | |||
821 | return FALSE0; | |||
822 | break; | |||
823 | ||||
824 | case 'f': | |||
825 | case 'F': | |||
826 | /* A function definition. */ | |||
827 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
828 | (debug_type **) NULL((void*)0)); | |||
829 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
830 | return FALSE0; | |||
831 | if (! debug_record_function (dhandle, name, dtype, type == 'F', value)) | |||
832 | return FALSE0; | |||
833 | ||||
834 | /* Sun acc puts declared types of arguments here. We don't care | |||
835 | about their actual types (FIXME -- we should remember the whole | |||
836 | function prototype), but the list may define some new types | |||
837 | that we have to remember, so we must scan it now. */ | |||
838 | while (*p == ';') | |||
839 | { | |||
840 | ++p; | |||
841 | if (parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
842 | (debug_type **) NULL((void*)0)) | |||
843 | == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
844 | return FALSE0; | |||
845 | } | |||
846 | ||||
847 | break; | |||
848 | ||||
849 | case 'G': | |||
850 | { | |||
851 | char leading; | |||
852 | long c; | |||
853 | asymbol **ps; | |||
854 | ||||
855 | /* A global symbol. The value must be extracted from the | |||
856 | symbol table. */ | |||
857 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
858 | (debug_type **) NULL((void*)0)); | |||
859 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
860 | return FALSE0; | |||
861 | leading = bfd_get_symbol_leading_char (info->abfd)((info->abfd)->xvec->symbol_leading_char); | |||
862 | for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps) | |||
863 | { | |||
864 | const char *n; | |||
865 | ||||
866 | n = bfd_asymbol_name (*ps)((*ps)->name); | |||
867 | if (leading != '\0' && *n == leading) | |||
868 | ++n; | |||
869 | if (*n == *name && strcmp (n, name) == 0) | |||
| ||||
870 | break; | |||
871 | } | |||
872 | if (c > 0) | |||
873 | value = bfd_asymbol_value (*ps)(((*ps)->section->vma) + (*ps)->value); | |||
874 | if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL, | |||
875 | value)) | |||
876 | return FALSE0; | |||
877 | } | |||
878 | break; | |||
879 | ||||
880 | /* This case is faked by a conditional above, when there is no | |||
881 | code letter in the dbx data. Dbx data never actually | |||
882 | contains 'l'. */ | |||
883 | case 'l': | |||
884 | case 's': | |||
885 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
886 | (debug_type **) NULL((void*)0)); | |||
887 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
888 | return FALSE0; | |||
889 | if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, | |||
890 | value)) | |||
891 | return FALSE0; | |||
892 | break; | |||
893 | ||||
894 | case 'p': | |||
895 | /* A function parameter. */ | |||
896 | if (*p != 'F') | |||
897 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
898 | (debug_type **) NULL((void*)0)); | |||
899 | else | |||
900 | { | |||
901 | /* pF is a two-letter code that means a function parameter in | |||
902 | Fortran. The type-number specifies the type of the return | |||
903 | value. Translate it into a pointer-to-function type. */ | |||
904 | ++p; | |||
905 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
906 | (debug_type **) NULL((void*)0)); | |||
907 | if (dtype != DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
908 | { | |||
909 | debug_type ftype; | |||
910 | ||||
911 | ftype = debug_make_function_type (dhandle, dtype, | |||
912 | (debug_type *) NULL((void*)0), FALSE0); | |||
913 | dtype = debug_make_pointer_type (dhandle, ftype); | |||
914 | } | |||
915 | } | |||
916 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
917 | return FALSE0; | |||
918 | if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK, | |||
919 | value)) | |||
920 | return FALSE0; | |||
921 | ||||
922 | /* FIXME: At this point gdb considers rearranging the parameter | |||
923 | address on a big endian machine if it is smaller than an int. | |||
924 | We have no way to do that, since we don't really know much | |||
925 | about the target. */ | |||
926 | break; | |||
927 | ||||
928 | case 'P': | |||
929 | if (stabtype == N_FUN) | |||
930 | { | |||
931 | /* Prototype of a function referenced by this file. */ | |||
932 | while (*p == ';') | |||
933 | { | |||
934 | ++p; | |||
935 | if (parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
936 | (debug_type **) NULL((void*)0)) | |||
937 | == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
938 | return FALSE0; | |||
939 | } | |||
940 | break; | |||
941 | } | |||
942 | /* Fall through. */ | |||
943 | case 'R': | |||
944 | /* Parameter which is in a register. */ | |||
945 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
946 | (debug_type **) NULL((void*)0)); | |||
947 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
948 | return FALSE0; | |||
949 | if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG, | |||
950 | value)) | |||
951 | return FALSE0; | |||
952 | break; | |||
953 | ||||
954 | case 'r': | |||
955 | /* Register variable (either global or local). */ | |||
956 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
957 | (debug_type **) NULL((void*)0)); | |||
958 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
959 | return FALSE0; | |||
960 | if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER, | |||
961 | value)) | |||
962 | return FALSE0; | |||
963 | ||||
964 | /* FIXME: At this point gdb checks to combine pairs of 'p' and | |||
965 | 'r' stabs into a single 'P' stab. */ | |||
966 | break; | |||
967 | ||||
968 | case 'S': | |||
969 | /* Static symbol at top level of file. */ | |||
970 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
971 | (debug_type **) NULL((void*)0)); | |||
972 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
973 | return FALSE0; | |||
974 | if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC, | |||
975 | value)) | |||
976 | return FALSE0; | |||
977 | break; | |||
978 | ||||
979 | case 't': | |||
980 | /* A typedef. */ | |||
981 | dtype = parse_stab_type (dhandle, info, name, &p, &slot); | |||
982 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
983 | return FALSE0; | |||
984 | if (name == NULL((void*)0)) | |||
985 | { | |||
986 | /* A nameless type. Nothing to do. */ | |||
987 | return TRUE1; | |||
988 | } | |||
989 | ||||
990 | dtype = debug_name_type (dhandle, name, dtype); | |||
991 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
992 | return FALSE0; | |||
993 | ||||
994 | if (slot != NULL((void*)0)) | |||
995 | *slot = dtype; | |||
996 | ||||
997 | break; | |||
998 | ||||
999 | case 'T': | |||
1000 | /* Struct, union, or enum tag. For GNU C++, this can be be followed | |||
1001 | by 't' which means we are typedef'ing it as well. */ | |||
1002 | if (*p != 't') | |||
1003 | { | |||
1004 | synonym = FALSE0; | |||
1005 | /* FIXME: gdb sets synonym to TRUE if the current language | |||
1006 | is C++. */ | |||
1007 | } | |||
1008 | else | |||
1009 | { | |||
1010 | synonym = TRUE1; | |||
1011 | ++p; | |||
1012 | } | |||
1013 | ||||
1014 | dtype = parse_stab_type (dhandle, info, name, &p, &slot); | |||
1015 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1016 | return FALSE0; | |||
1017 | if (name == NULL((void*)0)) | |||
1018 | return TRUE1; | |||
1019 | ||||
1020 | /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is | |||
1021 | a cross reference to itself. These are generated by some | |||
1022 | versions of g++. */ | |||
1023 | self_crossref = info->self_crossref; | |||
1024 | ||||
1025 | dtype = debug_tag_type (dhandle, name, dtype); | |||
1026 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1027 | return FALSE0; | |||
1028 | if (slot != NULL((void*)0)) | |||
1029 | *slot = dtype; | |||
1030 | ||||
1031 | /* See if we have a cross reference to this tag which we can now | |||
1032 | fill in. Avoid filling in a cross reference to ourselves, | |||
1033 | because that would lead to circular debugging information. */ | |||
1034 | if (! self_crossref) | |||
1035 | { | |||
1036 | register struct stab_tag **pst; | |||
1037 | ||||
1038 | for (pst = &info->tags; *pst != NULL((void*)0); pst = &(*pst)->next) | |||
1039 | { | |||
1040 | if ((*pst)->name[0] == name[0] | |||
1041 | && strcmp ((*pst)->name, name) == 0) | |||
1042 | { | |||
1043 | (*pst)->slot = dtype; | |||
1044 | *pst = (*pst)->next; | |||
1045 | break; | |||
1046 | } | |||
1047 | } | |||
1048 | } | |||
1049 | ||||
1050 | if (synonym) | |||
1051 | { | |||
1052 | dtype = debug_name_type (dhandle, name, dtype); | |||
1053 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1054 | return FALSE0; | |||
1055 | ||||
1056 | if (slot != NULL((void*)0)) | |||
1057 | *slot = dtype; | |||
1058 | } | |||
1059 | ||||
1060 | break; | |||
1061 | ||||
1062 | case 'V': | |||
1063 | /* Static symbol of local scope */ | |||
1064 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
1065 | (debug_type **) NULL((void*)0)); | |||
1066 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1067 | return FALSE0; | |||
1068 | /* FIXME: gdb checks os9k_stabs here. */ | |||
1069 | if (! stab_record_variable (dhandle, info, name, dtype, | |||
1070 | DEBUG_LOCAL_STATIC, value)) | |||
1071 | return FALSE0; | |||
1072 | break; | |||
1073 | ||||
1074 | case 'v': | |||
1075 | /* Reference parameter. */ | |||
1076 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
1077 | (debug_type **) NULL((void*)0)); | |||
1078 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1079 | return FALSE0; | |||
1080 | if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE, | |||
1081 | value)) | |||
1082 | return FALSE0; | |||
1083 | break; | |||
1084 | ||||
1085 | case 'a': | |||
1086 | /* Reference parameter which is in a register. */ | |||
1087 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
1088 | (debug_type **) NULL((void*)0)); | |||
1089 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1090 | return FALSE0; | |||
1091 | if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG, | |||
1092 | value)) | |||
1093 | return FALSE0; | |||
1094 | break; | |||
1095 | ||||
1096 | case 'X': | |||
1097 | /* This is used by Sun FORTRAN for "function result value". | |||
1098 | Sun claims ("dbx and dbxtool interfaces", 2nd ed) | |||
1099 | that Pascal uses it too, but when I tried it Pascal used | |||
1100 | "x:3" (local symbol) instead. */ | |||
1101 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), &p, | |||
1102 | (debug_type **) NULL((void*)0)); | |||
1103 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1104 | return FALSE0; | |||
1105 | if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, | |||
1106 | value)) | |||
1107 | return FALSE0; | |||
1108 | break; | |||
1109 | ||||
1110 | default: | |||
1111 | bad_stab (string); | |||
1112 | return FALSE0; | |||
1113 | } | |||
1114 | ||||
1115 | /* FIXME: gdb converts structure values to structure pointers in a | |||
1116 | couple of cases, depending upon the target. */ | |||
1117 | ||||
1118 | return TRUE1; | |||
1119 | } | |||
1120 | ||||
1121 | /* Parse a stabs type. The typename argument is non-NULL if this is a | |||
1122 | typedef or a tag definition. The pp argument points to the stab | |||
1123 | string, and is updated. The slotp argument points to a place to | |||
1124 | store the slot used if the type is being defined. */ | |||
1125 | ||||
1126 | static debug_type | |||
1127 | parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp) | |||
1128 | { | |||
1129 | const char *orig; | |||
1130 | int typenums[2]; | |||
1131 | int size; | |||
1132 | bfd_boolean stringp; | |||
1133 | int descriptor; | |||
1134 | debug_type dtype; | |||
1135 | ||||
1136 | if (slotp != NULL((void*)0)) | |||
1137 | *slotp = NULL((void*)0); | |||
1138 | ||||
1139 | orig = *pp; | |||
1140 | ||||
1141 | size = -1; | |||
1142 | stringp = FALSE0; | |||
1143 | ||||
1144 | info->self_crossref = FALSE0; | |||
1145 | ||||
1146 | /* Read type number if present. The type number may be omitted. | |||
1147 | for instance in a two-dimensional array declared with type | |||
1148 | "ar1;1;10;ar1;1;10;4". */ | |||
1149 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit )) && **pp != '(' && **pp != '-') | |||
1150 | { | |||
1151 | /* 'typenums=' not present, type is anonymous. Read and return | |||
1152 | the definition, but don't put it in the type vector. */ | |||
1153 | typenums[0] = typenums[1] = -1; | |||
1154 | } | |||
1155 | else | |||
1156 | { | |||
1157 | if (! parse_stab_type_number (pp, typenums)) | |||
1158 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1159 | ||||
1160 | if (**pp != '=') | |||
1161 | /* Type is not being defined here. Either it already | |||
1162 | exists, or this is a forward reference to it. */ | |||
1163 | return stab_find_type (dhandle, info, typenums); | |||
1164 | ||||
1165 | /* Only set the slot if the type is being defined. This means | |||
1166 | that the mapping from type numbers to types will only record | |||
1167 | the name of the typedef which defines a type. If we don't do | |||
1168 | this, then something like | |||
1169 | typedef int foo; | |||
1170 | int i; | |||
1171 | will record that i is of type foo. Unfortunately, stabs | |||
1172 | information is ambiguous about variable types. For this code, | |||
1173 | typedef int foo; | |||
1174 | int i; | |||
1175 | foo j; | |||
1176 | the stabs information records both i and j as having the same | |||
1177 | type. This could be fixed by patching the compiler. */ | |||
1178 | if (slotp != NULL((void*)0) && typenums[0] >= 0 && typenums[1] >= 0) | |||
1179 | *slotp = stab_find_slot (info, typenums); | |||
1180 | ||||
1181 | /* Type is being defined here. */ | |||
1182 | /* Skip the '='. */ | |||
1183 | ++*pp; | |||
1184 | ||||
1185 | while (**pp == '@') | |||
1186 | { | |||
1187 | const char *p = *pp + 1; | |||
1188 | const char *attr; | |||
1189 | ||||
1190 | if (ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit )) || *p == '(' || *p == '-') | |||
1191 | /* Member type. */ | |||
1192 | break; | |||
1193 | ||||
1194 | /* Type attributes. */ | |||
1195 | attr = p; | |||
1196 | ||||
1197 | for (; *p != ';'; ++p) | |||
1198 | { | |||
1199 | if (*p == '\0') | |||
1200 | { | |||
1201 | bad_stab (orig); | |||
1202 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1203 | } | |||
1204 | } | |||
1205 | *pp = p + 1; | |||
1206 | ||||
1207 | switch (*attr) | |||
1208 | { | |||
1209 | case 's': | |||
1210 | size = atoi (attr + 1); | |||
1211 | size /= 8; /* Size is in bits. We store it in bytes. */ | |||
1212 | if (size <= 0) | |||
1213 | size = -1; | |||
1214 | break; | |||
1215 | ||||
1216 | case 'S': | |||
1217 | stringp = TRUE1; | |||
1218 | break; | |||
1219 | ||||
1220 | default: | |||
1221 | /* Ignore unrecognized type attributes, so future | |||
1222 | compilers can invent new ones. */ | |||
1223 | break; | |||
1224 | } | |||
1225 | } | |||
1226 | } | |||
1227 | ||||
1228 | descriptor = **pp; | |||
1229 | ++*pp; | |||
1230 | ||||
1231 | switch (descriptor) | |||
1232 | { | |||
1233 | case 'x': | |||
1234 | { | |||
1235 | enum debug_type_kind code; | |||
1236 | const char *q1, *q2, *p; | |||
1237 | ||||
1238 | /* A cross reference to another type. */ | |||
1239 | switch (**pp) | |||
1240 | { | |||
1241 | case 's': | |||
1242 | code = DEBUG_KIND_STRUCT; | |||
1243 | break; | |||
1244 | case 'u': | |||
1245 | code = DEBUG_KIND_UNION; | |||
1246 | break; | |||
1247 | case 'e': | |||
1248 | code = DEBUG_KIND_ENUM; | |||
1249 | break; | |||
1250 | default: | |||
1251 | /* Complain and keep going, so compilers can invent new | |||
1252 | cross-reference types. */ | |||
1253 | warn_stab (orig, _("unrecognized cross reference type")("unrecognized cross reference type")); | |||
1254 | code = DEBUG_KIND_STRUCT; | |||
1255 | break; | |||
1256 | } | |||
1257 | ++*pp; | |||
1258 | ||||
1259 | q1 = strchr (*pp, '<'); | |||
1260 | p = strchr (*pp, ':'); | |||
1261 | if (p == NULL((void*)0)) | |||
1262 | { | |||
1263 | bad_stab (orig); | |||
1264 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1265 | } | |||
1266 | if (q1 != NULL((void*)0) && p > q1 && p[1] == ':') | |||
1267 | { | |||
1268 | int nest = 0; | |||
1269 | ||||
1270 | for (q2 = q1; *q2 != '\0'; ++q2) | |||
1271 | { | |||
1272 | if (*q2 == '<') | |||
1273 | ++nest; | |||
1274 | else if (*q2 == '>') | |||
1275 | --nest; | |||
1276 | else if (*q2 == ':' && nest == 0) | |||
1277 | break; | |||
1278 | } | |||
1279 | p = q2; | |||
1280 | if (*p != ':') | |||
1281 | { | |||
1282 | bad_stab (orig); | |||
1283 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1284 | } | |||
1285 | } | |||
1286 | ||||
1287 | /* Some versions of g++ can emit stabs like | |||
1288 | fleep:T20=xsfleep: | |||
1289 | which define structures in terms of themselves. We need to | |||
1290 | tell the caller to avoid building a circular structure. */ | |||
1291 | if (typename != NULL((void*)0) | |||
1292 | && strncmp (typename, *pp, p - *pp) == 0 | |||
1293 | && typename[p - *pp] == '\0') | |||
1294 | info->self_crossref = TRUE1; | |||
1295 | ||||
1296 | dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code); | |||
1297 | ||||
1298 | *pp = p + 1; | |||
1299 | } | |||
1300 | break; | |||
1301 | ||||
1302 | case '-': | |||
1303 | case '0': | |||
1304 | case '1': | |||
1305 | case '2': | |||
1306 | case '3': | |||
1307 | case '4': | |||
1308 | case '5': | |||
1309 | case '6': | |||
1310 | case '7': | |||
1311 | case '8': | |||
1312 | case '9': | |||
1313 | case '(': | |||
1314 | { | |||
1315 | const char *hold; | |||
1316 | int xtypenums[2]; | |||
1317 | ||||
1318 | /* This type is defined as another type. */ | |||
1319 | (*pp)--; | |||
1320 | hold = *pp; | |||
1321 | ||||
1322 | /* Peek ahead at the number to detect void. */ | |||
1323 | if (! parse_stab_type_number (pp, xtypenums)) | |||
1324 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1325 | ||||
1326 | if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1]) | |||
1327 | { | |||
1328 | /* This type is being defined as itself, which means that | |||
1329 | it is void. */ | |||
1330 | dtype = debug_make_void_type (dhandle); | |||
1331 | } | |||
1332 | else | |||
1333 | { | |||
1334 | *pp = hold; | |||
1335 | ||||
1336 | /* Go back to the number and have parse_stab_type get it. | |||
1337 | This means that we can deal with something like | |||
1338 | t(1,2)=(3,4)=... which the Lucid compiler uses. */ | |||
1339 | dtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1340 | pp, (debug_type **) NULL((void*)0)); | |||
1341 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1342 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1343 | } | |||
1344 | ||||
1345 | if (typenums[0] != -1) | |||
1346 | { | |||
1347 | if (! stab_record_type (dhandle, info, typenums, dtype)) | |||
1348 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1349 | } | |||
1350 | ||||
1351 | break; | |||
1352 | } | |||
1353 | ||||
1354 | case '*': | |||
1355 | dtype = debug_make_pointer_type (dhandle, | |||
1356 | parse_stab_type (dhandle, info, | |||
1357 | (const char *) NULL((void*)0), | |||
1358 | pp, | |||
1359 | (debug_type **) NULL((void*)0))); | |||
1360 | break; | |||
1361 | ||||
1362 | case '&': | |||
1363 | /* Reference to another type. */ | |||
1364 | dtype = (debug_make_reference_type | |||
1365 | (dhandle, | |||
1366 | parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
1367 | (debug_type **) NULL((void*)0)))); | |||
1368 | break; | |||
1369 | ||||
1370 | case 'f': | |||
1371 | /* Function returning another type. */ | |||
1372 | /* FIXME: gdb checks os9k_stabs here. */ | |||
1373 | dtype = (debug_make_function_type | |||
1374 | (dhandle, | |||
1375 | parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
1376 | (debug_type **) NULL((void*)0)), | |||
1377 | (debug_type *) NULL((void*)0), FALSE0)); | |||
1378 | break; | |||
1379 | ||||
1380 | case 'k': | |||
1381 | /* Const qualifier on some type (Sun). */ | |||
1382 | /* FIXME: gdb accepts 'c' here if os9k_stabs. */ | |||
1383 | dtype = debug_make_const_type (dhandle, | |||
1384 | parse_stab_type (dhandle, info, | |||
1385 | (const char *) NULL((void*)0), | |||
1386 | pp, | |||
1387 | (debug_type **) NULL((void*)0))); | |||
1388 | break; | |||
1389 | ||||
1390 | case 'B': | |||
1391 | /* Volatile qual on some type (Sun). */ | |||
1392 | /* FIXME: gdb accepts 'i' here if os9k_stabs. */ | |||
1393 | dtype = (debug_make_volatile_type | |||
1394 | (dhandle, | |||
1395 | parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
1396 | (debug_type **) NULL((void*)0)))); | |||
1397 | break; | |||
1398 | ||||
1399 | case '@': | |||
1400 | /* Offset (class & variable) type. This is used for a pointer | |||
1401 | relative to an object. */ | |||
1402 | { | |||
1403 | debug_type domain; | |||
1404 | debug_type memtype; | |||
1405 | ||||
1406 | /* Member type. */ | |||
1407 | ||||
1408 | domain = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
1409 | (debug_type **) NULL((void*)0)); | |||
1410 | if (domain == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1411 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1412 | ||||
1413 | if (**pp != ',') | |||
1414 | { | |||
1415 | bad_stab (orig); | |||
1416 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1417 | } | |||
1418 | ++*pp; | |||
1419 | ||||
1420 | memtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
1421 | (debug_type **) NULL((void*)0)); | |||
1422 | if (memtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1423 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1424 | ||||
1425 | dtype = debug_make_offset_type (dhandle, domain, memtype); | |||
1426 | } | |||
1427 | break; | |||
1428 | ||||
1429 | case '#': | |||
1430 | /* Method (class & fn) type. */ | |||
1431 | if (**pp == '#') | |||
1432 | { | |||
1433 | debug_type return_type; | |||
1434 | ||||
1435 | ++*pp; | |||
1436 | return_type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1437 | pp, (debug_type **) NULL((void*)0)); | |||
1438 | if (return_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1439 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1440 | if (**pp != ';') | |||
1441 | { | |||
1442 | bad_stab (orig); | |||
1443 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1444 | } | |||
1445 | ++*pp; | |||
1446 | dtype = debug_make_method_type (dhandle, return_type, | |||
1447 | DEBUG_TYPE_NULL((debug_type) ((void*)0)), | |||
1448 | (debug_type *) NULL((void*)0), FALSE0); | |||
1449 | } | |||
1450 | else | |||
1451 | { | |||
1452 | debug_type domain; | |||
1453 | debug_type return_type; | |||
1454 | debug_type *args; | |||
1455 | unsigned int n; | |||
1456 | unsigned int alloc; | |||
1457 | bfd_boolean varargs; | |||
1458 | ||||
1459 | domain = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1460 | pp, (debug_type **) NULL((void*)0)); | |||
1461 | if (domain == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1462 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1463 | ||||
1464 | if (**pp != ',') | |||
1465 | { | |||
1466 | bad_stab (orig); | |||
1467 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1468 | } | |||
1469 | ++*pp; | |||
1470 | ||||
1471 | return_type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1472 | pp, (debug_type **) NULL((void*)0)); | |||
1473 | if (return_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1474 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1475 | ||||
1476 | alloc = 10; | |||
1477 | args = (debug_type *) xmalloc (alloc * sizeof *args); | |||
1478 | n = 0; | |||
1479 | while (**pp != ';') | |||
1480 | { | |||
1481 | if (**pp != ',') | |||
1482 | { | |||
1483 | bad_stab (orig); | |||
1484 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1485 | } | |||
1486 | ++*pp; | |||
1487 | ||||
1488 | if (n + 1 >= alloc) | |||
1489 | { | |||
1490 | alloc += 10; | |||
1491 | args = ((debug_type *) | |||
1492 | xrealloc (args, alloc * sizeof *args)); | |||
1493 | } | |||
1494 | ||||
1495 | args[n] = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1496 | pp, (debug_type **) NULL((void*)0)); | |||
1497 | if (args[n] == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1498 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1499 | ++n; | |||
1500 | } | |||
1501 | ++*pp; | |||
1502 | ||||
1503 | /* If the last type is not void, then this function takes a | |||
1504 | variable number of arguments. Otherwise, we must strip | |||
1505 | the void type. */ | |||
1506 | if (n == 0 | |||
1507 | || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID) | |||
1508 | varargs = TRUE1; | |||
1509 | else | |||
1510 | { | |||
1511 | --n; | |||
1512 | varargs = FALSE0; | |||
1513 | } | |||
1514 | ||||
1515 | args[n] = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1516 | ||||
1517 | dtype = debug_make_method_type (dhandle, return_type, domain, args, | |||
1518 | varargs); | |||
1519 | } | |||
1520 | break; | |||
1521 | ||||
1522 | case 'r': | |||
1523 | /* Range type. */ | |||
1524 | dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums); | |||
1525 | break; | |||
1526 | ||||
1527 | case 'b': | |||
1528 | /* FIXME: gdb checks os9k_stabs here. */ | |||
1529 | /* Sun ACC builtin int type. */ | |||
1530 | dtype = parse_stab_sun_builtin_type (dhandle, pp); | |||
1531 | break; | |||
1532 | ||||
1533 | case 'R': | |||
1534 | /* Sun ACC builtin float type. */ | |||
1535 | dtype = parse_stab_sun_floating_type (dhandle, pp); | |||
1536 | break; | |||
1537 | ||||
1538 | case 'e': | |||
1539 | /* Enumeration type. */ | |||
1540 | dtype = parse_stab_enum_type (dhandle, pp); | |||
1541 | break; | |||
1542 | ||||
1543 | case 's': | |||
1544 | case 'u': | |||
1545 | /* Struct or union type. */ | |||
1546 | dtype = parse_stab_struct_type (dhandle, info, typename, pp, | |||
1547 | descriptor == 's', typenums); | |||
1548 | break; | |||
1549 | ||||
1550 | case 'a': | |||
1551 | /* Array type. */ | |||
1552 | if (**pp != 'r') | |||
1553 | { | |||
1554 | bad_stab (orig); | |||
1555 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1556 | } | |||
1557 | ++*pp; | |||
1558 | ||||
1559 | dtype = parse_stab_array_type (dhandle, info, pp, stringp); | |||
1560 | break; | |||
1561 | ||||
1562 | case 'S': | |||
1563 | dtype = debug_make_set_type (dhandle, | |||
1564 | parse_stab_type (dhandle, info, | |||
1565 | (const char *) NULL((void*)0), | |||
1566 | pp, | |||
1567 | (debug_type **) NULL((void*)0)), | |||
1568 | stringp); | |||
1569 | break; | |||
1570 | ||||
1571 | default: | |||
1572 | bad_stab (orig); | |||
1573 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1574 | } | |||
1575 | ||||
1576 | if (dtype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1577 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1578 | ||||
1579 | if (typenums[0] != -1) | |||
1580 | { | |||
1581 | if (! stab_record_type (dhandle, info, typenums, dtype)) | |||
1582 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1583 | } | |||
1584 | ||||
1585 | if (size != -1) | |||
1586 | { | |||
1587 | if (! debug_record_type_size (dhandle, dtype, (unsigned int) size)) | |||
1588 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1589 | } | |||
1590 | ||||
1591 | return dtype; | |||
1592 | } | |||
1593 | ||||
1594 | /* Read a number by which a type is referred to in dbx data, or | |||
1595 | perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a | |||
1596 | single number N is equivalent to (0,N). Return the two numbers by | |||
1597 | storing them in the vector TYPENUMS. */ | |||
1598 | ||||
1599 | static bfd_boolean | |||
1600 | parse_stab_type_number (const char **pp, int *typenums) | |||
1601 | { | |||
1602 | const char *orig; | |||
1603 | ||||
1604 | orig = *pp; | |||
1605 | ||||
1606 | if (**pp != '(') | |||
1607 | { | |||
1608 | typenums[0] = 0; | |||
1609 | typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1610 | } | |||
1611 | else | |||
1612 | { | |||
1613 | ++*pp; | |||
1614 | typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1615 | if (**pp != ',') | |||
1616 | { | |||
1617 | bad_stab (orig); | |||
1618 | return FALSE0; | |||
1619 | } | |||
1620 | ++*pp; | |||
1621 | typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1622 | if (**pp != ')') | |||
1623 | { | |||
1624 | bad_stab (orig); | |||
1625 | return FALSE0; | |||
1626 | } | |||
1627 | ++*pp; | |||
1628 | } | |||
1629 | ||||
1630 | return TRUE1; | |||
1631 | } | |||
1632 | ||||
1633 | /* Parse a range type. */ | |||
1634 | ||||
1635 | static debug_type | |||
1636 | parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums) | |||
1637 | { | |||
1638 | const char *orig; | |||
1639 | int rangenums[2]; | |||
1640 | bfd_boolean self_subrange; | |||
1641 | debug_type index_type; | |||
1642 | const char *s2, *s3; | |||
1643 | bfd_signed_vma n2, n3; | |||
1644 | bfd_boolean ov2, ov3; | |||
1645 | ||||
1646 | orig = *pp; | |||
1647 | ||||
1648 | index_type = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1649 | ||||
1650 | /* First comes a type we are a subrange of. | |||
1651 | In C it is usually 0, 1 or the type being defined. */ | |||
1652 | if (! parse_stab_type_number (pp, rangenums)) | |||
1653 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1654 | ||||
1655 | self_subrange = (rangenums[0] == typenums[0] | |||
1656 | && rangenums[1] == typenums[1]); | |||
1657 | ||||
1658 | if (**pp == '=') | |||
1659 | { | |||
1660 | *pp = orig; | |||
1661 | index_type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), | |||
1662 | pp, (debug_type **) NULL((void*)0)); | |||
1663 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1664 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1665 | } | |||
1666 | ||||
1667 | if (**pp == ';') | |||
1668 | ++*pp; | |||
1669 | ||||
1670 | /* The remaining two operands are usually lower and upper bounds of | |||
1671 | the range. But in some special cases they mean something else. */ | |||
1672 | s2 = *pp; | |||
1673 | n2 = parse_number (pp, &ov2); | |||
1674 | if (**pp != ';') | |||
1675 | { | |||
1676 | bad_stab (orig); | |||
1677 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1678 | } | |||
1679 | ++*pp; | |||
1680 | ||||
1681 | s3 = *pp; | |||
1682 | n3 = parse_number (pp, &ov3); | |||
1683 | if (**pp != ';') | |||
1684 | { | |||
1685 | bad_stab (orig); | |||
1686 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1687 | } | |||
1688 | ++*pp; | |||
1689 | ||||
1690 | if (ov2 || ov3) | |||
1691 | { | |||
1692 | /* gcc will emit range stabs for long long types. Handle this | |||
1693 | as a special case. FIXME: This needs to be more general. */ | |||
1694 | #define LLLOW"01000000000000000000000;" "01000000000000000000000;" | |||
1695 | #define LLHIGH"0777777777777777777777;" "0777777777777777777777;" | |||
1696 | #define ULLHIGH"01777777777777777777777;" "01777777777777777777777;" | |||
1697 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1698 | { | |||
1699 | if (strncmp (s2, LLLOW"01000000000000000000000;", sizeof LLLOW"01000000000000000000000;" - 1) == 0 | |||
1700 | && strncmp (s3, LLHIGH"0777777777777777777777;", sizeof LLHIGH"0777777777777777777777;" - 1) == 0) | |||
1701 | return debug_make_int_type (dhandle, 8, FALSE0); | |||
1702 | if (! ov2 | |||
1703 | && n2 == 0 | |||
1704 | && strncmp (s3, ULLHIGH"01777777777777777777777;", sizeof ULLHIGH"01777777777777777777777;" - 1) == 0) | |||
1705 | return debug_make_int_type (dhandle, 8, TRUE1); | |||
1706 | } | |||
1707 | ||||
1708 | warn_stab (orig, _("numeric overflow")("numeric overflow")); | |||
1709 | } | |||
1710 | ||||
1711 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1712 | { | |||
1713 | /* A type defined as a subrange of itself, with both bounds 0, | |||
1714 | is void. */ | |||
1715 | if (self_subrange && n2 == 0 && n3 == 0) | |||
1716 | return debug_make_void_type (dhandle); | |||
1717 | ||||
1718 | /* A type defined as a subrange of itself, with n2 positive and | |||
1719 | n3 zero, is a complex type, and n2 is the number of bytes. */ | |||
1720 | if (self_subrange && n3 == 0 && n2 > 0) | |||
1721 | return debug_make_complex_type (dhandle, n2); | |||
1722 | ||||
1723 | /* If n3 is zero and n2 is positive, this is a floating point | |||
1724 | type, and n2 is the number of bytes. */ | |||
1725 | if (n3 == 0 && n2 > 0) | |||
1726 | return debug_make_float_type (dhandle, n2); | |||
1727 | ||||
1728 | /* If the upper bound is -1, this is an unsigned int. */ | |||
1729 | if (n2 == 0 && n3 == -1) | |||
1730 | { | |||
1731 | /* When gcc is used with -gstabs, but not -gstabs+, it will emit | |||
1732 | long long int:t6=r1;0;-1; | |||
1733 | long long unsigned int:t7=r1;0;-1; | |||
1734 | We hack here to handle this reasonably. */ | |||
1735 | if (typename != NULL((void*)0)) | |||
1736 | { | |||
1737 | if (strcmp (typename, "long long int") == 0) | |||
1738 | return debug_make_int_type (dhandle, 8, FALSE0); | |||
1739 | else if (strcmp (typename, "long long unsigned int") == 0) | |||
1740 | return debug_make_int_type (dhandle, 8, TRUE1); | |||
1741 | } | |||
1742 | /* FIXME: The size here really depends upon the target. */ | |||
1743 | return debug_make_int_type (dhandle, 4, TRUE1); | |||
1744 | } | |||
1745 | ||||
1746 | /* A range of 0 to 127 is char. */ | |||
1747 | if (self_subrange && n2 == 0 && n3 == 127) | |||
1748 | return debug_make_int_type (dhandle, 1, FALSE0); | |||
1749 | ||||
1750 | /* FIXME: gdb checks for the language CHILL here. */ | |||
1751 | ||||
1752 | if (n2 == 0) | |||
1753 | { | |||
1754 | if (n3 < 0) | |||
1755 | return debug_make_int_type (dhandle, - n3, TRUE1); | |||
1756 | else if (n3 == 0xff) | |||
1757 | return debug_make_int_type (dhandle, 1, TRUE1); | |||
1758 | else if (n3 == 0xffff) | |||
1759 | return debug_make_int_type (dhandle, 2, TRUE1); | |||
1760 | else if (n3 == (bfd_signed_vma) 0xffffffff) | |||
1761 | return debug_make_int_type (dhandle, 4, TRUE1); | |||
1762 | #ifdef BFD64 | |||
1763 | else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff)) | |||
1764 | return debug_make_int_type (dhandle, 8, TRUE1); | |||
1765 | #endif | |||
1766 | } | |||
1767 | else if (n3 == 0 | |||
1768 | && n2 < 0 | |||
1769 | && (self_subrange || n2 == -8)) | |||
1770 | return debug_make_int_type (dhandle, - n2, TRUE1); | |||
1771 | else if (n2 == - n3 - 1 || n2 == n3 + 1) | |||
1772 | { | |||
1773 | if (n3 == 0x7f) | |||
1774 | return debug_make_int_type (dhandle, 1, FALSE0); | |||
1775 | else if (n3 == 0x7fff) | |||
1776 | return debug_make_int_type (dhandle, 2, FALSE0); | |||
1777 | else if (n3 == 0x7fffffff) | |||
1778 | return debug_make_int_type (dhandle, 4, FALSE0); | |||
1779 | #ifdef BFD64 | |||
1780 | else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff)) | |||
1781 | return debug_make_int_type (dhandle, 8, FALSE0); | |||
1782 | #endif | |||
1783 | } | |||
1784 | } | |||
1785 | ||||
1786 | /* At this point I don't have the faintest idea how to deal with a | |||
1787 | self_subrange type; I'm going to assume that this is used as an | |||
1788 | idiom, and that all of them are special cases. So . . . */ | |||
1789 | if (self_subrange) | |||
1790 | { | |||
1791 | bad_stab (orig); | |||
1792 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1793 | } | |||
1794 | ||||
1795 | index_type = stab_find_type (dhandle, info, rangenums); | |||
1796 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
1797 | { | |||
1798 | /* Does this actually ever happen? Is that why we are worrying | |||
1799 | about dealing with it rather than just calling error_type? */ | |||
1800 | warn_stab (orig, _("missing index type")("missing index type")); | |||
1801 | index_type = debug_make_int_type (dhandle, 4, FALSE0); | |||
1802 | } | |||
1803 | ||||
1804 | return debug_make_range_type (dhandle, index_type, n2, n3); | |||
1805 | } | |||
1806 | ||||
1807 | /* Sun's ACC uses a somewhat saner method for specifying the builtin | |||
1808 | typedefs in every file (for int, long, etc): | |||
1809 | ||||
1810 | type = b <signed> <width>; <offset>; <nbits> | |||
1811 | signed = u or s. Possible c in addition to u or s (for char?). | |||
1812 | offset = offset from high order bit to start bit of type. | |||
1813 | width is # bytes in object of this type, nbits is # bits in type. | |||
1814 | ||||
1815 | The width/offset stuff appears to be for small objects stored in | |||
1816 | larger ones (e.g. `shorts' in `int' registers). We ignore it for now, | |||
1817 | FIXME. */ | |||
1818 | ||||
1819 | static debug_type | |||
1820 | parse_stab_sun_builtin_type (void *dhandle, const char **pp) | |||
1821 | { | |||
1822 | const char *orig; | |||
1823 | bfd_boolean unsignedp; | |||
1824 | bfd_vma bits; | |||
1825 | ||||
1826 | orig = *pp; | |||
1827 | ||||
1828 | switch (**pp) | |||
1829 | { | |||
1830 | case 's': | |||
1831 | unsignedp = FALSE0; | |||
1832 | break; | |||
1833 | case 'u': | |||
1834 | unsignedp = TRUE1; | |||
1835 | break; | |||
1836 | default: | |||
1837 | bad_stab (orig); | |||
1838 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1839 | } | |||
1840 | ++*pp; | |||
1841 | ||||
1842 | /* For some odd reason, all forms of char put a c here. This is strange | |||
1843 | because no other type has this honor. We can safely ignore this because | |||
1844 | we actually determine 'char'acterness by the number of bits specified in | |||
1845 | the descriptor. */ | |||
1846 | if (**pp == 'c') | |||
1847 | ++*pp; | |||
1848 | ||||
1849 | /* The first number appears to be the number of bytes occupied | |||
1850 | by this type, except that unsigned short is 4 instead of 2. | |||
1851 | Since this information is redundant with the third number, | |||
1852 | we will ignore it. */ | |||
1853 | (void) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1854 | if (**pp != ';') | |||
1855 | { | |||
1856 | bad_stab (orig); | |||
1857 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1858 | } | |||
1859 | ++*pp; | |||
1860 | ||||
1861 | /* The second number is always 0, so ignore it too. */ | |||
1862 | (void) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1863 | if (**pp != ';') | |||
1864 | { | |||
1865 | bad_stab (orig); | |||
1866 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1867 | } | |||
1868 | ++*pp; | |||
1869 | ||||
1870 | /* The third number is the number of bits for this type. */ | |||
1871 | bits = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1872 | ||||
1873 | /* The type *should* end with a semicolon. If it are embedded | |||
1874 | in a larger type the semicolon may be the only way to know where | |||
1875 | the type ends. If this type is at the end of the stabstring we | |||
1876 | can deal with the omitted semicolon (but we don't have to like | |||
1877 | it). Don't bother to complain(), Sun's compiler omits the semicolon | |||
1878 | for "void". */ | |||
1879 | if (**pp == ';') | |||
1880 | ++*pp; | |||
1881 | ||||
1882 | if (bits == 0) | |||
1883 | return debug_make_void_type (dhandle); | |||
1884 | ||||
1885 | return debug_make_int_type (dhandle, bits / 8, unsignedp); | |||
1886 | } | |||
1887 | ||||
1888 | /* Parse a builtin floating type generated by the Sun compiler. */ | |||
1889 | ||||
1890 | static debug_type | |||
1891 | parse_stab_sun_floating_type (void *dhandle, const char **pp) | |||
1892 | { | |||
1893 | const char *orig; | |||
1894 | bfd_vma details; | |||
1895 | bfd_vma bytes; | |||
1896 | ||||
1897 | orig = *pp; | |||
1898 | ||||
1899 | /* The first number has more details about the type, for example | |||
1900 | FN_COMPLEX. */ | |||
1901 | details = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1902 | if (**pp != ';') | |||
1903 | { | |||
1904 | bad_stab (orig); | |||
1905 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1906 | } | |||
1907 | ||||
1908 | /* The second number is the number of bytes occupied by this type */ | |||
1909 | bytes = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1910 | if (**pp != ';') | |||
1911 | { | |||
1912 | bad_stab (orig); | |||
1913 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1914 | } | |||
1915 | ||||
1916 | if (details == NF_COMPLEX3 | |||
1917 | || details == NF_COMPLEX164 | |||
1918 | || details == NF_COMPLEX325) | |||
1919 | return debug_make_complex_type (dhandle, bytes); | |||
1920 | ||||
1921 | return debug_make_float_type (dhandle, bytes); | |||
1922 | } | |||
1923 | ||||
1924 | /* Handle an enum type. */ | |||
1925 | ||||
1926 | static debug_type | |||
1927 | parse_stab_enum_type (void *dhandle, const char **pp) | |||
1928 | { | |||
1929 | const char *orig; | |||
1930 | const char **names; | |||
1931 | bfd_signed_vma *values; | |||
1932 | unsigned int n; | |||
1933 | unsigned int alloc; | |||
1934 | ||||
1935 | orig = *pp; | |||
1936 | ||||
1937 | /* FIXME: gdb checks os9k_stabs here. */ | |||
1938 | ||||
1939 | /* The aix4 compiler emits an extra field before the enum members; | |||
1940 | my guess is it's a type of some sort. Just ignore it. */ | |||
1941 | if (**pp == '-') | |||
1942 | { | |||
1943 | while (**pp != ':') | |||
1944 | ++*pp; | |||
1945 | ++*pp; | |||
1946 | } | |||
1947 | ||||
1948 | /* Read the value-names and their values. | |||
1949 | The input syntax is NAME:VALUE,NAME:VALUE, and so on. | |||
1950 | A semicolon or comma instead of a NAME means the end. */ | |||
1951 | alloc = 10; | |||
1952 | names = (const char **) xmalloc (alloc * sizeof *names); | |||
1953 | values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values); | |||
1954 | n = 0; | |||
1955 | while (**pp != '\0' && **pp != ';' && **pp != ',') | |||
1956 | { | |||
1957 | const char *p; | |||
1958 | char *name; | |||
1959 | bfd_signed_vma val; | |||
1960 | ||||
1961 | p = *pp; | |||
1962 | while (*p != ':') | |||
1963 | ++p; | |||
1964 | ||||
1965 | name = savestring (*pp, p - *pp); | |||
1966 | ||||
1967 | *pp = p + 1; | |||
1968 | val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
1969 | if (**pp != ',') | |||
1970 | { | |||
1971 | bad_stab (orig); | |||
1972 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
1973 | } | |||
1974 | ++*pp; | |||
1975 | ||||
1976 | if (n + 1 >= alloc) | |||
1977 | { | |||
1978 | alloc += 10; | |||
1979 | names = ((const char **) | |||
1980 | xrealloc (names, alloc * sizeof *names)); | |||
1981 | values = ((bfd_signed_vma *) | |||
1982 | xrealloc (values, alloc * sizeof *values)); | |||
1983 | } | |||
1984 | ||||
1985 | names[n] = name; | |||
1986 | values[n] = val; | |||
1987 | ++n; | |||
1988 | } | |||
1989 | ||||
1990 | names[n] = NULL((void*)0); | |||
1991 | values[n] = 0; | |||
1992 | ||||
1993 | if (**pp == ';') | |||
1994 | ++*pp; | |||
1995 | ||||
1996 | return debug_make_enum_type (dhandle, names, values); | |||
1997 | } | |||
1998 | ||||
1999 | /* Read the description of a structure (or union type) and return an object | |||
2000 | describing the type. | |||
2001 | ||||
2002 | PP points to a character pointer that points to the next unconsumed token | |||
2003 | in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;", | |||
2004 | *PP will point to "4a:1,0,32;;". */ | |||
2005 | ||||
2006 | static debug_type | |||
2007 | parse_stab_struct_type (void *dhandle, struct stab_handle *info, | |||
2008 | const char *tagname, const char **pp, | |||
2009 | bfd_boolean structp, const int *typenums) | |||
2010 | { | |||
2011 | const char *orig; | |||
2012 | bfd_vma size; | |||
2013 | debug_baseclass *baseclasses; | |||
2014 | debug_field *fields; | |||
2015 | bfd_boolean statics; | |||
2016 | debug_method *methods; | |||
2017 | debug_type vptrbase; | |||
2018 | bfd_boolean ownvptr; | |||
2019 | ||||
2020 | orig = *pp; | |||
2021 | ||||
2022 | /* Get the size. */ | |||
2023 | size = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2024 | ||||
2025 | /* Get the other information. */ | |||
2026 | if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses) | |||
2027 | || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics) | |||
2028 | || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods) | |||
2029 | || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase, | |||
2030 | &ownvptr)) | |||
2031 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2032 | ||||
2033 | if (! statics | |||
2034 | && baseclasses == NULL((void*)0) | |||
2035 | && methods == NULL((void*)0) | |||
2036 | && vptrbase == DEBUG_TYPE_NULL((debug_type) ((void*)0)) | |||
2037 | && ! ownvptr) | |||
2038 | return debug_make_struct_type (dhandle, structp, size, fields); | |||
2039 | ||||
2040 | return debug_make_object_type (dhandle, structp, size, fields, baseclasses, | |||
2041 | methods, vptrbase, ownvptr); | |||
2042 | } | |||
2043 | ||||
2044 | /* The stabs for C++ derived classes contain baseclass information which | |||
2045 | is marked by a '!' character after the total size. This function is | |||
2046 | called when we encounter the baseclass marker, and slurps up all the | |||
2047 | baseclass information. | |||
2048 | ||||
2049 | Immediately following the '!' marker is the number of base classes that | |||
2050 | the class is derived from, followed by information for each base class. | |||
2051 | For each base class, there are two visibility specifiers, a bit offset | |||
2052 | to the base class information within the derived class, a reference to | |||
2053 | the type for the base class, and a terminating semicolon. | |||
2054 | ||||
2055 | A typical example, with two base classes, would be "!2,020,19;0264,21;". | |||
2056 | ^^ ^ ^ ^ ^ ^ ^ | |||
2057 | Baseclass information marker __________________|| | | | | | | | |||
2058 | Number of baseclasses __________________________| | | | | | | | |||
2059 | Visibility specifiers (2) ________________________| | | | | | | |||
2060 | Offset in bits from start of class _________________| | | | | | |||
2061 | Type number for base class ___________________________| | | | | |||
2062 | Visibility specifiers (2) _______________________________| | | | |||
2063 | Offset in bits from start of class ________________________| | | |||
2064 | Type number of base class ____________________________________| | |||
2065 | ||||
2066 | Return TRUE for success, FALSE for failure. */ | |||
2067 | ||||
2068 | static bfd_boolean | |||
2069 | parse_stab_baseclasses (void *dhandle, struct stab_handle *info, | |||
2070 | const char **pp, debug_baseclass **retp) | |||
2071 | { | |||
2072 | const char *orig; | |||
2073 | unsigned int c, i; | |||
2074 | debug_baseclass *classes; | |||
2075 | ||||
2076 | *retp = NULL((void*)0); | |||
2077 | ||||
2078 | orig = *pp; | |||
2079 | ||||
2080 | if (**pp != '!') | |||
2081 | { | |||
2082 | /* No base classes. */ | |||
2083 | return TRUE1; | |||
2084 | } | |||
2085 | ++*pp; | |||
2086 | ||||
2087 | c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2088 | ||||
2089 | if (**pp != ',') | |||
2090 | { | |||
2091 | bad_stab (orig); | |||
2092 | return FALSE0; | |||
2093 | } | |||
2094 | ++*pp; | |||
2095 | ||||
2096 | classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp)); | |||
2097 | ||||
2098 | for (i = 0; i < c; i++) | |||
2099 | { | |||
2100 | bfd_boolean virtual; | |||
2101 | enum debug_visibility visibility; | |||
2102 | bfd_vma bitpos; | |||
2103 | debug_type type; | |||
2104 | ||||
2105 | switch (**pp) | |||
2106 | { | |||
2107 | case '0': | |||
2108 | virtual = FALSE0; | |||
2109 | break; | |||
2110 | case '1': | |||
2111 | virtual = TRUE1; | |||
2112 | break; | |||
2113 | default: | |||
2114 | warn_stab (orig, _("unknown virtual character for baseclass")("unknown virtual character for baseclass")); | |||
2115 | virtual = FALSE0; | |||
2116 | break; | |||
2117 | } | |||
2118 | ++*pp; | |||
2119 | ||||
2120 | switch (**pp) | |||
2121 | { | |||
2122 | case '0': | |||
2123 | visibility = DEBUG_VISIBILITY_PRIVATE; | |||
2124 | break; | |||
2125 | case '1': | |||
2126 | visibility = DEBUG_VISIBILITY_PROTECTED; | |||
2127 | break; | |||
2128 | case '2': | |||
2129 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2130 | break; | |||
2131 | default: | |||
2132 | warn_stab (orig, _("unknown visibility character for baseclass")("unknown visibility character for baseclass")); | |||
2133 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2134 | break; | |||
2135 | } | |||
2136 | ++*pp; | |||
2137 | ||||
2138 | /* The remaining value is the bit offset of the portion of the | |||
2139 | object corresponding to this baseclass. Always zero in the | |||
2140 | absence of multiple inheritance. */ | |||
2141 | bitpos = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2142 | if (**pp != ',') | |||
2143 | { | |||
2144 | bad_stab (orig); | |||
2145 | return FALSE0; | |||
2146 | } | |||
2147 | ++*pp; | |||
2148 | ||||
2149 | type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2150 | (debug_type **) NULL((void*)0)); | |||
2151 | if (type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2152 | return FALSE0; | |||
2153 | ||||
2154 | classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual, | |||
2155 | visibility); | |||
2156 | if (classes[i] == DEBUG_BASECLASS_NULL((debug_baseclass) ((void*)0))) | |||
2157 | return FALSE0; | |||
2158 | ||||
2159 | if (**pp != ';') | |||
2160 | return FALSE0; | |||
2161 | ++*pp; | |||
2162 | } | |||
2163 | ||||
2164 | classes[i] = DEBUG_BASECLASS_NULL((debug_baseclass) ((void*)0)); | |||
2165 | ||||
2166 | *retp = classes; | |||
2167 | ||||
2168 | return TRUE1; | |||
2169 | } | |||
2170 | ||||
2171 | /* Read struct or class data fields. They have the form: | |||
2172 | ||||
2173 | NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ; | |||
2174 | ||||
2175 | At the end, we see a semicolon instead of a field. | |||
2176 | ||||
2177 | In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for | |||
2178 | a static field. | |||
2179 | ||||
2180 | The optional VISIBILITY is one of: | |||
2181 | ||||
2182 | '/0' (VISIBILITY_PRIVATE) | |||
2183 | '/1' (VISIBILITY_PROTECTED) | |||
2184 | '/2' (VISIBILITY_PUBLIC) | |||
2185 | '/9' (VISIBILITY_IGNORE) | |||
2186 | ||||
2187 | or nothing, for C style fields with public visibility. | |||
2188 | ||||
2189 | Returns 1 for success, 0 for failure. */ | |||
2190 | ||||
2191 | static bfd_boolean | |||
2192 | parse_stab_struct_fields (void *dhandle, struct stab_handle *info, | |||
2193 | const char **pp, debug_field **retp, | |||
2194 | bfd_boolean *staticsp) | |||
2195 | { | |||
2196 | const char *orig; | |||
2197 | const char *p; | |||
2198 | debug_field *fields; | |||
2199 | unsigned int c; | |||
2200 | unsigned int alloc; | |||
2201 | ||||
2202 | *retp = NULL((void*)0); | |||
2203 | *staticsp = FALSE0; | |||
2204 | ||||
2205 | orig = *pp; | |||
2206 | ||||
2207 | c = 0; | |||
2208 | alloc = 10; | |||
2209 | fields = (debug_field *) xmalloc (alloc * sizeof *fields); | |||
2210 | while (**pp != ';') | |||
2211 | { | |||
2212 | /* FIXME: gdb checks os9k_stabs here. */ | |||
2213 | ||||
2214 | p = *pp; | |||
2215 | ||||
2216 | /* Add 1 to c to leave room for NULL pointer at end. */ | |||
2217 | if (c + 1 >= alloc) | |||
2218 | { | |||
2219 | alloc += 10; | |||
2220 | fields = ((debug_field *) | |||
2221 | xrealloc (fields, alloc * sizeof *fields)); | |||
2222 | } | |||
2223 | ||||
2224 | /* If it starts with CPLUS_MARKER it is a special abbreviation, | |||
2225 | unless the CPLUS_MARKER is followed by an underscore, in | |||
2226 | which case it is just the name of an anonymous type, which we | |||
2227 | should handle like any other type name. We accept either '$' | |||
2228 | or '.', because a field name can never contain one of these | |||
2229 | characters except as a CPLUS_MARKER. */ | |||
2230 | ||||
2231 | if ((*p == '$' || *p == '.') && p[1] != '_') | |||
2232 | { | |||
2233 | ++*pp; | |||
2234 | if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c)) | |||
2235 | return FALSE0; | |||
2236 | ++c; | |||
2237 | continue; | |||
2238 | } | |||
2239 | ||||
2240 | /* Look for the ':' that separates the field name from the field | |||
2241 | values. Data members are delimited by a single ':', while member | |||
2242 | functions are delimited by a pair of ':'s. When we hit the member | |||
2243 | functions (if any), terminate scan loop and return. */ | |||
2244 | ||||
2245 | p = strchr (p, ':'); | |||
2246 | if (p == NULL((void*)0)) | |||
2247 | { | |||
2248 | bad_stab (orig); | |||
2249 | return FALSE0; | |||
2250 | } | |||
2251 | ||||
2252 | if (p[1] == ':') | |||
2253 | break; | |||
2254 | ||||
2255 | if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c, | |||
2256 | staticsp)) | |||
2257 | return FALSE0; | |||
2258 | ||||
2259 | ++c; | |||
2260 | } | |||
2261 | ||||
2262 | fields[c] = DEBUG_FIELD_NULL((debug_field) ((void*)0)); | |||
2263 | ||||
2264 | *retp = fields; | |||
2265 | ||||
2266 | return TRUE1; | |||
2267 | } | |||
2268 | ||||
2269 | /* Special GNU C++ name. */ | |||
2270 | ||||
2271 | static bfd_boolean | |||
2272 | parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info, | |||
2273 | const char **pp, debug_field *retp) | |||
2274 | { | |||
2275 | const char *orig; | |||
2276 | int cpp_abbrev; | |||
2277 | debug_type context; | |||
2278 | const char *name; | |||
2279 | const char *typename; | |||
2280 | debug_type type; | |||
2281 | bfd_vma bitpos; | |||
2282 | ||||
2283 | *retp = DEBUG_FIELD_NULL((debug_field) ((void*)0)); | |||
2284 | ||||
2285 | orig = *pp; | |||
2286 | ||||
2287 | if (**pp != 'v') | |||
2288 | { | |||
2289 | bad_stab (*pp); | |||
2290 | return FALSE0; | |||
2291 | } | |||
2292 | ++*pp; | |||
2293 | ||||
2294 | cpp_abbrev = **pp; | |||
2295 | ++*pp; | |||
2296 | ||||
2297 | /* At this point, *pp points to something like "22:23=*22...", where | |||
2298 | the type number before the ':' is the "context" and everything | |||
2299 | after is a regular type definition. Lookup the type, find it's | |||
2300 | name, and construct the field name. */ | |||
2301 | ||||
2302 | context = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2303 | (debug_type **) NULL((void*)0)); | |||
2304 | if (context == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2305 | return FALSE0; | |||
2306 | ||||
2307 | switch (cpp_abbrev) | |||
2308 | { | |||
2309 | case 'f': | |||
2310 | /* $vf -- a virtual function table pointer. */ | |||
2311 | name = "_vptr$"; | |||
2312 | break; | |||
2313 | case 'b': | |||
2314 | /* $vb -- a virtual bsomethingorother */ | |||
2315 | typename = debug_get_type_name (dhandle, context); | |||
2316 | if (typename == NULL((void*)0)) | |||
2317 | { | |||
2318 | warn_stab (orig, _("unnamed $vb type")("unnamed $vb type")); | |||
2319 | typename = "FOO"; | |||
2320 | } | |||
2321 | name = concat ("_vb$", typename, (const char *) NULL((void*)0)); | |||
2322 | break; | |||
2323 | default: | |||
2324 | warn_stab (orig, _("unrecognized C++ abbreviation")("unrecognized C++ abbreviation")); | |||
2325 | name = "INVALID_CPLUSPLUS_ABBREV"; | |||
2326 | break; | |||
2327 | } | |||
2328 | ||||
2329 | if (**pp != ':') | |||
2330 | { | |||
2331 | bad_stab (orig); | |||
2332 | return FALSE0; | |||
2333 | } | |||
2334 | ++*pp; | |||
2335 | ||||
2336 | type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2337 | (debug_type **) NULL((void*)0)); | |||
2338 | if (**pp != ',') | |||
2339 | { | |||
2340 | bad_stab (orig); | |||
2341 | return FALSE0; | |||
2342 | } | |||
2343 | ++*pp; | |||
2344 | ||||
2345 | bitpos = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2346 | if (**pp != ';') | |||
2347 | { | |||
2348 | bad_stab (orig); | |||
2349 | return FALSE0; | |||
2350 | } | |||
2351 | ++*pp; | |||
2352 | ||||
2353 | *retp = debug_make_field (dhandle, name, type, bitpos, 0, | |||
2354 | DEBUG_VISIBILITY_PRIVATE); | |||
2355 | if (*retp == DEBUG_FIELD_NULL((debug_field) ((void*)0))) | |||
2356 | return FALSE0; | |||
2357 | ||||
2358 | return TRUE1; | |||
2359 | } | |||
2360 | ||||
2361 | /* Parse a single field in a struct or union. */ | |||
2362 | ||||
2363 | static bfd_boolean | |||
2364 | parse_stab_one_struct_field (void *dhandle, struct stab_handle *info, | |||
2365 | const char **pp, const char *p, | |||
2366 | debug_field *retp, bfd_boolean *staticsp) | |||
2367 | { | |||
2368 | const char *orig; | |||
2369 | char *name; | |||
2370 | enum debug_visibility visibility; | |||
2371 | debug_type type; | |||
2372 | bfd_vma bitpos; | |||
2373 | bfd_vma bitsize; | |||
2374 | ||||
2375 | orig = *pp; | |||
2376 | ||||
2377 | /* FIXME: gdb checks ARM_DEMANGLING here. */ | |||
2378 | ||||
2379 | name = savestring (*pp, p - *pp); | |||
2380 | ||||
2381 | *pp = p + 1; | |||
2382 | ||||
2383 | if (**pp != '/') | |||
2384 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2385 | else | |||
2386 | { | |||
2387 | ++*pp; | |||
2388 | switch (**pp) | |||
2389 | { | |||
2390 | case '0': | |||
2391 | visibility = DEBUG_VISIBILITY_PRIVATE; | |||
2392 | break; | |||
2393 | case '1': | |||
2394 | visibility = DEBUG_VISIBILITY_PROTECTED; | |||
2395 | break; | |||
2396 | case '2': | |||
2397 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2398 | break; | |||
2399 | default: | |||
2400 | warn_stab (orig, _("unknown visibility character for field")("unknown visibility character for field")); | |||
2401 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2402 | break; | |||
2403 | } | |||
2404 | ++*pp; | |||
2405 | } | |||
2406 | ||||
2407 | type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2408 | (debug_type **) NULL((void*)0)); | |||
2409 | if (type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2410 | return FALSE0; | |||
2411 | ||||
2412 | if (**pp == ':') | |||
2413 | { | |||
2414 | char *varname; | |||
2415 | ||||
2416 | /* This is a static class member. */ | |||
2417 | ++*pp; | |||
2418 | p = strchr (*pp, ';'); | |||
2419 | if (p == NULL((void*)0)) | |||
2420 | { | |||
2421 | bad_stab (orig); | |||
2422 | return FALSE0; | |||
2423 | } | |||
2424 | ||||
2425 | varname = savestring (*pp, p - *pp); | |||
2426 | ||||
2427 | *pp = p + 1; | |||
2428 | ||||
2429 | *retp = debug_make_static_member (dhandle, name, type, varname, | |||
2430 | visibility); | |||
2431 | *staticsp = TRUE1; | |||
2432 | ||||
2433 | return TRUE1; | |||
2434 | } | |||
2435 | ||||
2436 | if (**pp != ',') | |||
2437 | { | |||
2438 | bad_stab (orig); | |||
2439 | return FALSE0; | |||
2440 | } | |||
2441 | ++*pp; | |||
2442 | ||||
2443 | bitpos = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2444 | if (**pp != ',') | |||
2445 | { | |||
2446 | bad_stab (orig); | |||
2447 | return FALSE0; | |||
2448 | } | |||
2449 | ++*pp; | |||
2450 | ||||
2451 | bitsize = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2452 | if (**pp != ';') | |||
2453 | { | |||
2454 | bad_stab (orig); | |||
2455 | return FALSE0; | |||
2456 | } | |||
2457 | ++*pp; | |||
2458 | ||||
2459 | if (bitpos == 0 && bitsize == 0) | |||
2460 | { | |||
2461 | /* This can happen in two cases: (1) at least for gcc 2.4.5 or | |||
2462 | so, it is a field which has been optimized out. The correct | |||
2463 | stab for this case is to use VISIBILITY_IGNORE, but that is a | |||
2464 | recent invention. (2) It is a 0-size array. For example | |||
2465 | union { int num; char str[0]; } foo. Printing "<no value>" | |||
2466 | for str in "p foo" is OK, since foo.str (and thus foo.str[3]) | |||
2467 | will continue to work, and a 0-size array as a whole doesn't | |||
2468 | have any contents to print. | |||
2469 | ||||
2470 | I suspect this probably could also happen with gcc -gstabs | |||
2471 | (not -gstabs+) for static fields, and perhaps other C++ | |||
2472 | extensions. Hopefully few people use -gstabs with gdb, since | |||
2473 | it is intended for dbx compatibility. */ | |||
2474 | visibility = DEBUG_VISIBILITY_IGNORE; | |||
2475 | } | |||
2476 | ||||
2477 | /* FIXME: gdb does some stuff here to mark fields as unpacked. */ | |||
2478 | ||||
2479 | *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility); | |||
2480 | ||||
2481 | return TRUE1; | |||
2482 | } | |||
2483 | ||||
2484 | /* Read member function stabs info for C++ classes. The form of each member | |||
2485 | function data is: | |||
2486 | ||||
2487 | NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ; | |||
2488 | ||||
2489 | An example with two member functions is: | |||
2490 | ||||
2491 | afunc1::20=##15;:i;2A.;afunc2::20:i;2A.; | |||
2492 | ||||
2493 | For the case of overloaded operators, the format is op$::*.funcs, where | |||
2494 | $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator | |||
2495 | name (such as `+=') and `.' marks the end of the operator name. */ | |||
2496 | ||||
2497 | static bfd_boolean | |||
2498 | parse_stab_members (void *dhandle, struct stab_handle *info, | |||
2499 | const char *tagname, const char **pp, | |||
2500 | const int *typenums, debug_method **retp) | |||
2501 | { | |||
2502 | const char *orig; | |||
2503 | debug_method *methods; | |||
2504 | unsigned int c; | |||
2505 | unsigned int alloc; | |||
2506 | ||||
2507 | *retp = NULL((void*)0); | |||
2508 | ||||
2509 | orig = *pp; | |||
2510 | ||||
2511 | alloc = 0; | |||
2512 | methods = NULL((void*)0); | |||
2513 | c = 0; | |||
2514 | ||||
2515 | while (**pp != ';') | |||
2516 | { | |||
2517 | const char *p; | |||
2518 | char *name; | |||
2519 | debug_method_variant *variants; | |||
2520 | unsigned int cvars; | |||
2521 | unsigned int allocvars; | |||
2522 | debug_type look_ahead_type; | |||
2523 | ||||
2524 | p = strchr (*pp, ':'); | |||
2525 | if (p == NULL((void*)0) || p[1] != ':') | |||
2526 | break; | |||
2527 | ||||
2528 | /* FIXME: Some systems use something other than '$' here. */ | |||
2529 | if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$') | |||
2530 | { | |||
2531 | name = savestring (*pp, p - *pp); | |||
2532 | *pp = p + 2; | |||
2533 | } | |||
2534 | else | |||
2535 | { | |||
2536 | /* This is a completely weird case. In order to stuff in the | |||
2537 | names that might contain colons (the usual name delimiter), | |||
2538 | Mike Tiemann defined a different name format which is | |||
2539 | signalled if the identifier is "op$". In that case, the | |||
2540 | format is "op$::XXXX." where XXXX is the name. This is | |||
2541 | used for names like "+" or "=". YUUUUUUUK! FIXME! */ | |||
2542 | *pp = p + 2; | |||
2543 | for (p = *pp; *p != '.' && *p != '\0'; p++) | |||
2544 | ; | |||
2545 | if (*p != '.') | |||
2546 | { | |||
2547 | bad_stab (orig); | |||
2548 | return FALSE0; | |||
2549 | } | |||
2550 | name = savestring (*pp, p - *pp); | |||
2551 | *pp = p + 1; | |||
2552 | } | |||
2553 | ||||
2554 | allocvars = 10; | |||
2555 | variants = ((debug_method_variant *) | |||
2556 | xmalloc (allocvars * sizeof *variants)); | |||
2557 | cvars = 0; | |||
2558 | ||||
2559 | look_ahead_type = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2560 | ||||
2561 | do | |||
2562 | { | |||
2563 | debug_type type; | |||
2564 | bfd_boolean stub; | |||
2565 | char *argtypes; | |||
2566 | enum debug_visibility visibility; | |||
2567 | bfd_boolean constp, volatilep, staticp; | |||
2568 | bfd_vma voffset; | |||
2569 | debug_type context; | |||
2570 | const char *physname; | |||
2571 | bfd_boolean varargs; | |||
2572 | ||||
2573 | if (look_ahead_type != DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2574 | { | |||
2575 | /* g++ version 1 kludge */ | |||
2576 | type = look_ahead_type; | |||
2577 | look_ahead_type = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2578 | } | |||
2579 | else | |||
2580 | { | |||
2581 | type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2582 | (debug_type **) NULL((void*)0)); | |||
2583 | if (type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2584 | return FALSE0; | |||
2585 | if (**pp != ':') | |||
2586 | { | |||
2587 | bad_stab (orig); | |||
2588 | return FALSE0; | |||
2589 | } | |||
2590 | } | |||
2591 | ||||
2592 | ++*pp; | |||
2593 | p = strchr (*pp, ';'); | |||
2594 | if (p == NULL((void*)0)) | |||
2595 | { | |||
2596 | bad_stab (orig); | |||
2597 | return FALSE0; | |||
2598 | } | |||
2599 | ||||
2600 | stub = FALSE0; | |||
2601 | if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD | |||
2602 | && debug_get_parameter_types (dhandle, type, &varargs) == NULL((void*)0)) | |||
2603 | stub = TRUE1; | |||
2604 | ||||
2605 | argtypes = savestring (*pp, p - *pp); | |||
2606 | *pp = p + 1; | |||
2607 | ||||
2608 | switch (**pp) | |||
2609 | { | |||
2610 | case '0': | |||
2611 | visibility = DEBUG_VISIBILITY_PRIVATE; | |||
2612 | break; | |||
2613 | case '1': | |||
2614 | visibility = DEBUG_VISIBILITY_PROTECTED; | |||
2615 | break; | |||
2616 | default: | |||
2617 | visibility = DEBUG_VISIBILITY_PUBLIC; | |||
2618 | break; | |||
2619 | } | |||
2620 | ++*pp; | |||
2621 | ||||
2622 | constp = FALSE0; | |||
2623 | volatilep = FALSE0; | |||
2624 | switch (**pp) | |||
2625 | { | |||
2626 | case 'A': | |||
2627 | /* Normal function. */ | |||
2628 | ++*pp; | |||
2629 | break; | |||
2630 | case 'B': | |||
2631 | /* const member function. */ | |||
2632 | constp = TRUE1; | |||
2633 | ++*pp; | |||
2634 | break; | |||
2635 | case 'C': | |||
2636 | /* volatile member function. */ | |||
2637 | volatilep = TRUE1; | |||
2638 | ++*pp; | |||
2639 | break; | |||
2640 | case 'D': | |||
2641 | /* const volatile member function. */ | |||
2642 | constp = TRUE1; | |||
2643 | volatilep = TRUE1; | |||
2644 | ++*pp; | |||
2645 | break; | |||
2646 | case '*': | |||
2647 | case '?': | |||
2648 | case '.': | |||
2649 | /* File compiled with g++ version 1; no information. */ | |||
2650 | break; | |||
2651 | default: | |||
2652 | warn_stab (orig, _("const/volatile indicator missing")("const/volatile indicator missing")); | |||
2653 | break; | |||
2654 | } | |||
2655 | ||||
2656 | staticp = FALSE0; | |||
2657 | switch (**pp) | |||
2658 | { | |||
2659 | case '*': | |||
2660 | /* virtual member function, followed by index. The sign | |||
2661 | bit is supposedly set to distinguish | |||
2662 | pointers-to-methods from virtual function indicies. */ | |||
2663 | ++*pp; | |||
2664 | voffset = parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
2665 | if (**pp != ';') | |||
2666 | { | |||
2667 | bad_stab (orig); | |||
2668 | return FALSE0; | |||
2669 | } | |||
2670 | ++*pp; | |||
2671 | voffset &= 0x7fffffff; | |||
2672 | ||||
2673 | if (**pp == ';' || **pp == '\0') | |||
2674 | { | |||
2675 | /* Must be g++ version 1. */ | |||
2676 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2677 | } | |||
2678 | else | |||
2679 | { | |||
2680 | /* Figure out from whence this virtual function | |||
2681 | came. It may belong to virtual function table of | |||
2682 | one of its baseclasses. */ | |||
2683 | look_ahead_type = parse_stab_type (dhandle, info, | |||
2684 | (const char *) NULL((void*)0), | |||
2685 | pp, | |||
2686 | (debug_type **) NULL((void*)0)); | |||
2687 | if (**pp == ':') | |||
2688 | { | |||
2689 | /* g++ version 1 overloaded methods. */ | |||
2690 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2691 | } | |||
2692 | else | |||
2693 | { | |||
2694 | context = look_ahead_type; | |||
2695 | look_ahead_type = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2696 | if (**pp != ';') | |||
2697 | { | |||
2698 | bad_stab (orig); | |||
2699 | return FALSE0; | |||
2700 | } | |||
2701 | ++*pp; | |||
2702 | } | |||
2703 | } | |||
2704 | break; | |||
2705 | ||||
2706 | case '?': | |||
2707 | /* static member function. */ | |||
2708 | ++*pp; | |||
2709 | staticp = TRUE1; | |||
2710 | voffset = 0; | |||
2711 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2712 | if (strncmp (argtypes, name, strlen (name)) != 0) | |||
2713 | stub = TRUE1; | |||
2714 | break; | |||
2715 | ||||
2716 | default: | |||
2717 | warn_stab (orig, "member function type missing"); | |||
2718 | voffset = 0; | |||
2719 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2720 | break; | |||
2721 | ||||
2722 | case '.': | |||
2723 | ++*pp; | |||
2724 | voffset = 0; | |||
2725 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2726 | break; | |||
2727 | } | |||
2728 | ||||
2729 | /* If the type is not a stub, then the argtypes string is | |||
2730 | the physical name of the function. Otherwise the | |||
2731 | argtypes string is the mangled form of the argument | |||
2732 | types, and the full type and the physical name must be | |||
2733 | extracted from them. */ | |||
2734 | if (! stub) | |||
2735 | physname = argtypes; | |||
2736 | else | |||
2737 | { | |||
2738 | debug_type class_type, return_type; | |||
2739 | ||||
2740 | class_type = stab_find_type (dhandle, info, typenums); | |||
2741 | if (class_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2742 | return FALSE0; | |||
2743 | return_type = debug_get_return_type (dhandle, type); | |||
2744 | if (return_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2745 | { | |||
2746 | bad_stab (orig); | |||
2747 | return FALSE0; | |||
2748 | } | |||
2749 | type = parse_stab_argtypes (dhandle, info, class_type, name, | |||
2750 | tagname, return_type, argtypes, | |||
2751 | constp, volatilep, &physname); | |||
2752 | if (type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
2753 | return FALSE0; | |||
2754 | } | |||
2755 | ||||
2756 | if (cvars + 1 >= allocvars) | |||
2757 | { | |||
2758 | allocvars += 10; | |||
2759 | variants = ((debug_method_variant *) | |||
2760 | xrealloc (variants, | |||
2761 | allocvars * sizeof *variants)); | |||
2762 | } | |||
2763 | ||||
2764 | if (! staticp) | |||
2765 | variants[cvars] = debug_make_method_variant (dhandle, physname, | |||
2766 | type, visibility, | |||
2767 | constp, volatilep, | |||
2768 | voffset, context); | |||
2769 | else | |||
2770 | variants[cvars] = debug_make_static_method_variant (dhandle, | |||
2771 | physname, | |||
2772 | type, | |||
2773 | visibility, | |||
2774 | constp, | |||
2775 | volatilep); | |||
2776 | if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL((debug_method_variant) ((void*)0))) | |||
2777 | return FALSE0; | |||
2778 | ||||
2779 | ++cvars; | |||
2780 | } | |||
2781 | while (**pp != ';' && **pp != '\0'); | |||
2782 | ||||
2783 | variants[cvars] = DEBUG_METHOD_VARIANT_NULL((debug_method_variant) ((void*)0)); | |||
2784 | ||||
2785 | if (**pp != '\0') | |||
2786 | ++*pp; | |||
2787 | ||||
2788 | if (c + 1 >= alloc) | |||
2789 | { | |||
2790 | alloc += 10; | |||
2791 | methods = ((debug_method *) | |||
2792 | xrealloc (methods, alloc * sizeof *methods)); | |||
2793 | } | |||
2794 | ||||
2795 | methods[c] = debug_make_method (dhandle, name, variants); | |||
2796 | ||||
2797 | ++c; | |||
2798 | } | |||
2799 | ||||
2800 | if (methods != NULL((void*)0)) | |||
2801 | methods[c] = DEBUG_METHOD_NULL((debug_method) ((void*)0)); | |||
2802 | ||||
2803 | *retp = methods; | |||
2804 | ||||
2805 | return TRUE1; | |||
2806 | } | |||
2807 | ||||
2808 | /* Parse a string representing argument types for a method. Stabs | |||
2809 | tries to save space by packing argument types into a mangled | |||
2810 | string. This string should give us enough information to extract | |||
2811 | both argument types and the physical name of the function, given | |||
2812 | the tag name. */ | |||
2813 | ||||
2814 | static debug_type | |||
2815 | parse_stab_argtypes (void *dhandle, struct stab_handle *info, | |||
2816 | debug_type class_type, const char *fieldname, | |||
2817 | const char *tagname, debug_type return_type, | |||
2818 | const char *argtypes, bfd_boolean constp, | |||
2819 | bfd_boolean volatilep, const char **pphysname) | |||
2820 | { | |||
2821 | bfd_boolean is_full_physname_constructor; | |||
2822 | bfd_boolean is_constructor; | |||
2823 | bfd_boolean is_destructor; | |||
2824 | bfd_boolean is_v3; | |||
2825 | debug_type *args; | |||
2826 | bfd_boolean varargs; | |||
2827 | unsigned int physname_len = 0; | |||
2828 | ||||
2829 | /* Constructors are sometimes handled specially. */ | |||
2830 | is_full_physname_constructor = ((argtypes[0] == '_' | |||
2831 | && argtypes[1] == '_' | |||
2832 | && (ISDIGIT (argtypes[2])(_sch_istable[(argtypes[2]) & 0xff] & (unsigned short )(_sch_isdigit)) | |||
2833 | || argtypes[2] == 'Q' | |||
2834 | || argtypes[2] == 't')) | |||
2835 | || strncmp (argtypes, "__ct", 4) == 0); | |||
2836 | ||||
2837 | is_constructor = (is_full_physname_constructor | |||
2838 | || (tagname != NULL((void*)0) | |||
2839 | && strcmp (fieldname, tagname) == 0)); | |||
2840 | is_destructor = ((argtypes[0] == '_' | |||
2841 | && (argtypes[1] == '$' || argtypes[1] == '.') | |||
2842 | && argtypes[2] == '_') | |||
2843 | || strncmp (argtypes, "__dt", 4) == 0); | |||
2844 | is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z'; | |||
2845 | ||||
2846 | if (is_destructor || is_full_physname_constructor || is_v3) | |||
2847 | *pphysname = argtypes; | |||
2848 | else | |||
2849 | { | |||
2850 | unsigned int len; | |||
2851 | const char *const_prefix; | |||
2852 | const char *volatile_prefix; | |||
2853 | char buf[20]; | |||
2854 | unsigned int mangled_name_len; | |||
2855 | char *physname; | |||
2856 | ||||
2857 | len = tagname == NULL((void*)0) ? 0 : strlen (tagname); | |||
2858 | const_prefix = constp ? "C" : ""; | |||
2859 | volatile_prefix = volatilep ? "V" : ""; | |||
2860 | ||||
2861 | if (len == 0) | |||
2862 | sprintf (buf, "__%s%s", const_prefix, volatile_prefix); | |||
2863 | else if (tagname != NULL((void*)0) && strchr (tagname, '<') != NULL((void*)0)) | |||
2864 | { | |||
2865 | /* Template methods are fully mangled. */ | |||
2866 | sprintf (buf, "__%s%s", const_prefix, volatile_prefix); | |||
2867 | tagname = NULL((void*)0); | |||
2868 | len = 0; | |||
2869 | } | |||
2870 | else | |||
2871 | sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len); | |||
2872 | ||||
2873 | mangled_name_len = ((is_constructor ? 0 : strlen (fieldname)) | |||
2874 | + strlen (buf) | |||
2875 | + len | |||
2876 | + strlen (argtypes) | |||
2877 | + 1); | |||
2878 | ||||
2879 | if (fieldname[0] == 'o' | |||
2880 | && fieldname[1] == 'p' | |||
2881 | && (fieldname[2] == '$' || fieldname[2] == '.')) | |||
2882 | { | |||
2883 | const char *opname; | |||
2884 | ||||
2885 | opname = cplus_mangle_opname (fieldname + 3, 0); | |||
2886 | if (opname == NULL((void*)0)) | |||
2887 | { | |||
2888 | fprintf (stderr(&__sF[2]), _("No mangling for \"%s\"\n")("No mangling for \"%s\"\n"), fieldname); | |||
2889 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2890 | } | |||
2891 | mangled_name_len += strlen (opname); | |||
2892 | physname = (char *) xmalloc (mangled_name_len); | |||
2893 | strncpy (physname, fieldname, 3); | |||
2894 | strcpy (physname + 3, opname); | |||
2895 | } | |||
2896 | else | |||
2897 | { | |||
2898 | physname = (char *) xmalloc (mangled_name_len); | |||
2899 | if (is_constructor) | |||
2900 | physname[0] = '\0'; | |||
2901 | else | |||
2902 | strcpy (physname, fieldname); | |||
2903 | } | |||
2904 | ||||
2905 | physname_len = strlen (physname); | |||
2906 | strcat (physname, buf); | |||
2907 | if (tagname != NULL((void*)0)) | |||
2908 | strcat (physname, tagname); | |||
2909 | strcat (physname, argtypes); | |||
2910 | ||||
2911 | *pphysname = physname; | |||
2912 | } | |||
2913 | ||||
2914 | if (*argtypes == '\0' || is_destructor) | |||
2915 | { | |||
2916 | args = (debug_type *) xmalloc (sizeof *args); | |||
2917 | *args = NULL((void*)0); | |||
2918 | return debug_make_method_type (dhandle, return_type, class_type, args, | |||
2919 | FALSE0); | |||
2920 | } | |||
2921 | ||||
2922 | args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len); | |||
2923 | if (args == NULL((void*)0)) | |||
2924 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2925 | ||||
2926 | return debug_make_method_type (dhandle, return_type, class_type, args, | |||
2927 | varargs); | |||
2928 | } | |||
2929 | ||||
2930 | /* The tail end of stabs for C++ classes that contain a virtual function | |||
2931 | pointer contains a tilde, a %, and a type number. | |||
2932 | The type number refers to the base class (possibly this class itself) which | |||
2933 | contains the vtable pointer for the current class. | |||
2934 | ||||
2935 | This function is called when we have parsed all the method declarations, | |||
2936 | so we can look for the vptr base class info. */ | |||
2937 | ||||
2938 | static bfd_boolean | |||
2939 | parse_stab_tilde_field (void *dhandle, struct stab_handle *info, | |||
2940 | const char **pp, const int *typenums, | |||
2941 | debug_type *retvptrbase, bfd_boolean *retownvptr) | |||
2942 | { | |||
2943 | const char *orig; | |||
2944 | const char *hold; | |||
2945 | int vtypenums[2]; | |||
2946 | ||||
2947 | *retvptrbase = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
2948 | *retownvptr = FALSE0; | |||
2949 | ||||
2950 | orig = *pp; | |||
2951 | ||||
2952 | /* If we are positioned at a ';', then skip it. */ | |||
2953 | if (**pp == ';') | |||
2954 | ++*pp; | |||
2955 | ||||
2956 | if (**pp != '~') | |||
2957 | return TRUE1; | |||
2958 | ||||
2959 | ++*pp; | |||
2960 | ||||
2961 | if (**pp == '=' || **pp == '+' || **pp == '-') | |||
2962 | { | |||
2963 | /* Obsolete flags that used to indicate the presence of | |||
2964 | constructors and/or destructors. */ | |||
2965 | ++*pp; | |||
2966 | } | |||
2967 | ||||
2968 | if (**pp != '%') | |||
2969 | return TRUE1; | |||
2970 | ||||
2971 | ++*pp; | |||
2972 | ||||
2973 | hold = *pp; | |||
2974 | ||||
2975 | /* The next number is the type number of the base class (possibly | |||
2976 | our own class) which supplies the vtable for this class. */ | |||
2977 | if (! parse_stab_type_number (pp, vtypenums)) | |||
2978 | return FALSE0; | |||
2979 | ||||
2980 | if (vtypenums[0] == typenums[0] | |||
2981 | && vtypenums[1] == typenums[1]) | |||
2982 | *retownvptr = TRUE1; | |||
2983 | else | |||
2984 | { | |||
2985 | debug_type vtype; | |||
2986 | const char *p; | |||
2987 | ||||
2988 | *pp = hold; | |||
2989 | ||||
2990 | vtype = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
2991 | (debug_type **) NULL((void*)0)); | |||
2992 | for (p = *pp; *p != ';' && *p != '\0'; p++) | |||
2993 | ; | |||
2994 | if (*p != ';') | |||
2995 | { | |||
2996 | bad_stab (orig); | |||
2997 | return FALSE0; | |||
2998 | } | |||
2999 | ||||
3000 | *retvptrbase = vtype; | |||
3001 | ||||
3002 | *pp = p + 1; | |||
3003 | } | |||
3004 | ||||
3005 | return TRUE1; | |||
3006 | } | |||
3007 | ||||
3008 | /* Read a definition of an array type. */ | |||
3009 | ||||
3010 | static debug_type | |||
3011 | parse_stab_array_type (void *dhandle, struct stab_handle *info, | |||
3012 | const char **pp, bfd_boolean stringp) | |||
3013 | { | |||
3014 | const char *orig; | |||
3015 | const char *p; | |||
3016 | int typenums[2]; | |||
3017 | debug_type index_type; | |||
3018 | bfd_boolean adjustable; | |||
3019 | bfd_signed_vma lower, upper; | |||
3020 | debug_type element_type; | |||
3021 | ||||
3022 | /* Format of an array type: | |||
3023 | "ar<index type>;lower;upper;<array_contents_type>". | |||
3024 | OS9000: "arlower,upper;<array_contents_type>". | |||
3025 | ||||
3026 | Fortran adjustable arrays use Adigits or Tdigits for lower or upper; | |||
3027 | for these, produce a type like float[][]. */ | |||
3028 | ||||
3029 | orig = *pp; | |||
3030 | ||||
3031 | /* FIXME: gdb checks os9k_stabs here. */ | |||
3032 | ||||
3033 | /* If the index type is type 0, we take it as int. */ | |||
3034 | p = *pp; | |||
3035 | if (! parse_stab_type_number (&p, typenums)) | |||
3036 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3037 | if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=') | |||
3038 | { | |||
3039 | index_type = debug_find_named_type (dhandle, "int"); | |||
3040 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
3041 | { | |||
3042 | index_type = debug_make_int_type (dhandle, 4, FALSE0); | |||
3043 | if (index_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
3044 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3045 | } | |||
3046 | *pp = p; | |||
3047 | } | |||
3048 | else | |||
3049 | { | |||
3050 | index_type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
3051 | (debug_type **) NULL((void*)0)); | |||
3052 | } | |||
3053 | ||||
3054 | if (**pp != ';') | |||
3055 | { | |||
3056 | bad_stab (orig); | |||
3057 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3058 | } | |||
3059 | ++*pp; | |||
3060 | ||||
3061 | adjustable = FALSE0; | |||
3062 | ||||
3063 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit )) && **pp != '-') | |||
3064 | { | |||
3065 | ++*pp; | |||
3066 | adjustable = TRUE1; | |||
3067 | } | |||
3068 | ||||
3069 | lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
3070 | if (**pp != ';') | |||
3071 | { | |||
3072 | bad_stab (orig); | |||
3073 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3074 | } | |||
3075 | ++*pp; | |||
3076 | ||||
3077 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit )) && **pp != '-') | |||
3078 | { | |||
3079 | ++*pp; | |||
3080 | adjustable = TRUE1; | |||
3081 | } | |||
3082 | ||||
3083 | upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL((void*)0)); | |||
3084 | if (**pp != ';') | |||
3085 | { | |||
3086 | bad_stab (orig); | |||
3087 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3088 | } | |||
3089 | ++*pp; | |||
3090 | ||||
3091 | element_type = parse_stab_type (dhandle, info, (const char *) NULL((void*)0), pp, | |||
3092 | (debug_type **) NULL((void*)0)); | |||
3093 | if (element_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
3094 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3095 | ||||
3096 | if (adjustable) | |||
3097 | { | |||
3098 | lower = 0; | |||
3099 | upper = -1; | |||
3100 | } | |||
3101 | ||||
3102 | return debug_make_array_type (dhandle, element_type, index_type, lower, | |||
3103 | upper, stringp); | |||
3104 | } | |||
3105 | ||||
3106 | /* This struct holds information about files we have seen using | |||
3107 | N_BINCL. */ | |||
3108 | ||||
3109 | struct bincl_file | |||
3110 | { | |||
3111 | /* The next N_BINCL file. */ | |||
3112 | struct bincl_file *next; | |||
3113 | /* The next N_BINCL on the stack. */ | |||
3114 | struct bincl_file *next_stack; | |||
3115 | /* The file name. */ | |||
3116 | const char *name; | |||
3117 | /* The hash value. */ | |||
3118 | bfd_vma hash; | |||
3119 | /* The file index. */ | |||
3120 | unsigned int file; | |||
3121 | /* The list of types defined in this file. */ | |||
3122 | struct stab_types *file_types; | |||
3123 | }; | |||
3124 | ||||
3125 | /* Start a new N_BINCL file, pushing it onto the stack. */ | |||
3126 | ||||
3127 | static void | |||
3128 | push_bincl (struct stab_handle *info, const char *name, bfd_vma hash) | |||
3129 | { | |||
3130 | struct bincl_file *n; | |||
3131 | ||||
3132 | n = (struct bincl_file *) xmalloc (sizeof *n); | |||
3133 | n->next = info->bincl_list; | |||
3134 | n->next_stack = info->bincl_stack; | |||
3135 | n->name = name; | |||
3136 | n->hash = hash; | |||
3137 | n->file = info->files; | |||
3138 | n->file_types = NULL((void*)0); | |||
3139 | info->bincl_list = n; | |||
3140 | info->bincl_stack = n; | |||
3141 | ||||
3142 | ++info->files; | |||
3143 | info->file_types = ((struct stab_types **) | |||
3144 | xrealloc (info->file_types, | |||
3145 | (info->files | |||
3146 | * sizeof *info->file_types))); | |||
3147 | info->file_types[n->file] = NULL((void*)0); | |||
3148 | } | |||
3149 | ||||
3150 | /* Finish an N_BINCL file, at an N_EINCL, popping the name off the | |||
3151 | stack. */ | |||
3152 | ||||
3153 | static const char * | |||
3154 | pop_bincl (struct stab_handle *info) | |||
3155 | { | |||
3156 | struct bincl_file *o; | |||
3157 | ||||
3158 | o = info->bincl_stack; | |||
3159 | if (o == NULL((void*)0)) | |||
3160 | return info->main_filename; | |||
3161 | info->bincl_stack = o->next_stack; | |||
3162 | ||||
3163 | o->file_types = info->file_types[o->file]; | |||
3164 | ||||
3165 | if (info->bincl_stack == NULL((void*)0)) | |||
3166 | return info->main_filename; | |||
3167 | return info->bincl_stack->name; | |||
3168 | } | |||
3169 | ||||
3170 | /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */ | |||
3171 | ||||
3172 | static bfd_boolean | |||
3173 | find_excl (struct stab_handle *info, const char *name, bfd_vma hash) | |||
3174 | { | |||
3175 | struct bincl_file *l; | |||
3176 | ||||
3177 | ++info->files; | |||
3178 | info->file_types = ((struct stab_types **) | |||
3179 | xrealloc (info->file_types, | |||
3180 | (info->files | |||
3181 | * sizeof *info->file_types))); | |||
3182 | ||||
3183 | for (l = info->bincl_list; l != NULL((void*)0); l = l->next) | |||
3184 | if (l->hash == hash && strcmp (l->name, name) == 0) | |||
3185 | break; | |||
3186 | if (l == NULL((void*)0)) | |||
3187 | { | |||
3188 | warn_stab (name, _("Undefined N_EXCL")("Undefined N_EXCL")); | |||
3189 | info->file_types[info->files - 1] = NULL((void*)0); | |||
3190 | return TRUE1; | |||
3191 | } | |||
3192 | ||||
3193 | info->file_types[info->files - 1] = l->file_types; | |||
3194 | ||||
3195 | return TRUE1; | |||
3196 | } | |||
3197 | ||||
3198 | /* Handle a variable definition. gcc emits variable definitions for a | |||
3199 | block before the N_LBRAC, so we must hold onto them until we see | |||
3200 | it. The SunPRO compiler emits variable definitions after the | |||
3201 | N_LBRAC, so we can call debug_record_variable immediately. */ | |||
3202 | ||||
3203 | static bfd_boolean | |||
3204 | stab_record_variable (void *dhandle, struct stab_handle *info, | |||
3205 | const char *name, debug_type type, | |||
3206 | enum debug_var_kind kind, bfd_vma val) | |||
3207 | { | |||
3208 | struct stab_pending_var *v; | |||
3209 | ||||
3210 | if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC) | |||
3211 | || ! info->within_function | |||
3212 | || (info->gcc_compiled == 0 && info->n_opt_found)) | |||
3213 | return debug_record_variable (dhandle, name, type, kind, val); | |||
3214 | ||||
3215 | v = (struct stab_pending_var *) xmalloc (sizeof *v); | |||
3216 | memset (v, 0, sizeof *v); | |||
3217 | ||||
3218 | v->next = info->pending; | |||
3219 | v->name = name; | |||
3220 | v->type = type; | |||
3221 | v->kind = kind; | |||
3222 | v->val = val; | |||
3223 | info->pending = v; | |||
3224 | ||||
3225 | return TRUE1; | |||
3226 | } | |||
3227 | ||||
3228 | /* Emit pending variable definitions. This is called after we see the | |||
3229 | N_LBRAC that starts the block. */ | |||
3230 | ||||
3231 | static bfd_boolean | |||
3232 | stab_emit_pending_vars (void *dhandle, struct stab_handle *info) | |||
3233 | { | |||
3234 | struct stab_pending_var *v; | |||
3235 | ||||
3236 | v = info->pending; | |||
3237 | while (v != NULL((void*)0)) | |||
3238 | { | |||
3239 | struct stab_pending_var *next; | |||
3240 | ||||
3241 | if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val)) | |||
3242 | return FALSE0; | |||
3243 | ||||
3244 | next = v->next; | |||
3245 | free (v); | |||
3246 | v = next; | |||
3247 | } | |||
3248 | ||||
3249 | info->pending = NULL((void*)0); | |||
3250 | ||||
3251 | return TRUE1; | |||
3252 | } | |||
3253 | ||||
3254 | /* Find the slot for a type in the database. */ | |||
3255 | ||||
3256 | static debug_type * | |||
3257 | stab_find_slot (struct stab_handle *info, const int *typenums) | |||
3258 | { | |||
3259 | int filenum; | |||
3260 | int index; | |||
3261 | struct stab_types **ps; | |||
3262 | ||||
3263 | filenum = typenums[0]; | |||
3264 | index = typenums[1]; | |||
3265 | ||||
3266 | if (filenum < 0 || (unsigned int) filenum >= info->files) | |||
3267 | { | |||
3268 | fprintf (stderr(&__sF[2]), _("Type file number %d out of range\n")("Type file number %d out of range\n"), filenum); | |||
3269 | return NULL((void*)0); | |||
3270 | } | |||
3271 | if (index < 0) | |||
3272 | { | |||
3273 | fprintf (stderr(&__sF[2]), _("Type index number %d out of range\n")("Type index number %d out of range\n"), index); | |||
3274 | return NULL((void*)0); | |||
3275 | } | |||
3276 | ||||
3277 | ps = info->file_types + filenum; | |||
3278 | ||||
3279 | while (index >= STAB_TYPES_SLOTS(16)) | |||
3280 | { | |||
3281 | if (*ps == NULL((void*)0)) | |||
3282 | { | |||
3283 | *ps = (struct stab_types *) xmalloc (sizeof **ps); | |||
3284 | memset (*ps, 0, sizeof **ps); | |||
3285 | } | |||
3286 | ps = &(*ps)->next; | |||
3287 | index -= STAB_TYPES_SLOTS(16); | |||
3288 | } | |||
3289 | if (*ps == NULL((void*)0)) | |||
3290 | { | |||
3291 | *ps = (struct stab_types *) xmalloc (sizeof **ps); | |||
3292 | memset (*ps, 0, sizeof **ps); | |||
3293 | } | |||
3294 | ||||
3295 | return (*ps)->types + index; | |||
3296 | } | |||
3297 | ||||
3298 | /* Find a type given a type number. If the type has not been | |||
3299 | allocated yet, create an indirect type. */ | |||
3300 | ||||
3301 | static debug_type | |||
3302 | stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums) | |||
3303 | { | |||
3304 | debug_type *slot; | |||
3305 | ||||
3306 | if (typenums[0] == 0 && typenums[1] < 0) | |||
3307 | { | |||
3308 | /* A negative type number indicates an XCOFF builtin type. */ | |||
3309 | return stab_xcoff_builtin_type (dhandle, info, typenums[1]); | |||
3310 | } | |||
3311 | ||||
3312 | slot = stab_find_slot (info, typenums); | |||
3313 | if (slot == NULL((void*)0)) | |||
3314 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3315 | ||||
3316 | if (*slot == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
3317 | return debug_make_indirect_type (dhandle, slot, (const char *) NULL((void*)0)); | |||
3318 | ||||
3319 | return *slot; | |||
3320 | } | |||
3321 | ||||
3322 | /* Record that a given type number refers to a given type. */ | |||
3323 | ||||
3324 | static bfd_boolean | |||
3325 | stab_record_type (void *dhandle ATTRIBUTE_UNUSED__attribute__ ((__unused__)), struct stab_handle *info, | |||
3326 | const int *typenums, debug_type type) | |||
3327 | { | |||
3328 | debug_type *slot; | |||
3329 | ||||
3330 | slot = stab_find_slot (info, typenums); | |||
3331 | if (slot == NULL((void*)0)) | |||
3332 | return FALSE0; | |||
3333 | ||||
3334 | /* gdb appears to ignore type redefinitions, so we do as well. */ | |||
3335 | ||||
3336 | *slot = type; | |||
3337 | ||||
3338 | return TRUE1; | |||
3339 | } | |||
3340 | ||||
3341 | /* Return an XCOFF builtin type. */ | |||
3342 | ||||
3343 | static debug_type | |||
3344 | stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info, | |||
3345 | int typenum) | |||
3346 | { | |||
3347 | debug_type rettype; | |||
3348 | const char *name; | |||
3349 | ||||
3350 | if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT34) | |||
3351 | { | |||
3352 | fprintf (stderr(&__sF[2]), _("Unrecognized XCOFF type %d\n")("Unrecognized XCOFF type %d\n"), typenum); | |||
3353 | return DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3354 | } | |||
3355 | if (info->xcoff_types[-typenum] != NULL((void*)0)) | |||
3356 | return info->xcoff_types[-typenum]; | |||
3357 | ||||
3358 | switch (-typenum) | |||
3359 | { | |||
3360 | case 1: | |||
3361 | /* The size of this and all the other types are fixed, defined | |||
3362 | by the debugging format. */ | |||
3363 | name = "int"; | |||
3364 | rettype = debug_make_int_type (dhandle, 4, FALSE0); | |||
3365 | break; | |||
3366 | case 2: | |||
3367 | name = "char"; | |||
3368 | rettype = debug_make_int_type (dhandle, 1, FALSE0); | |||
3369 | break; | |||
3370 | case 3: | |||
3371 | name = "short"; | |||
3372 | rettype = debug_make_int_type (dhandle, 2, FALSE0); | |||
3373 | break; | |||
3374 | case 4: | |||
3375 | name = "long"; | |||
3376 | rettype = debug_make_int_type (dhandle, 4, FALSE0); | |||
3377 | break; | |||
3378 | case 5: | |||
3379 | name = "unsigned char"; | |||
3380 | rettype = debug_make_int_type (dhandle, 1, TRUE1); | |||
3381 | break; | |||
3382 | case 6: | |||
3383 | name = "signed char"; | |||
3384 | rettype = debug_make_int_type (dhandle, 1, FALSE0); | |||
3385 | break; | |||
3386 | case 7: | |||
3387 | name = "unsigned short"; | |||
3388 | rettype = debug_make_int_type (dhandle, 2, TRUE1); | |||
3389 | break; | |||
3390 | case 8: | |||
3391 | name = "unsigned int"; | |||
3392 | rettype = debug_make_int_type (dhandle, 4, TRUE1); | |||
3393 | break; | |||
3394 | case 9: | |||
3395 | name = "unsigned"; | |||
3396 | rettype = debug_make_int_type (dhandle, 4, TRUE1); | |||
3397 | case 10: | |||
3398 | name = "unsigned long"; | |||
3399 | rettype = debug_make_int_type (dhandle, 4, TRUE1); | |||
3400 | break; | |||
3401 | case 11: | |||
3402 | name = "void"; | |||
3403 | rettype = debug_make_void_type (dhandle); | |||
3404 | break; | |||
3405 | case 12: | |||
3406 | /* IEEE single precision (32 bit). */ | |||
3407 | name = "float"; | |||
3408 | rettype = debug_make_float_type (dhandle, 4); | |||
3409 | break; | |||
3410 | case 13: | |||
3411 | /* IEEE double precision (64 bit). */ | |||
3412 | name = "double"; | |||
3413 | rettype = debug_make_float_type (dhandle, 8); | |||
3414 | break; | |||
3415 | case 14: | |||
3416 | /* This is an IEEE double on the RS/6000, and different machines | |||
3417 | with different sizes for "long double" should use different | |||
3418 | negative type numbers. See stabs.texinfo. */ | |||
3419 | name = "long double"; | |||
3420 | rettype = debug_make_float_type (dhandle, 8); | |||
3421 | break; | |||
3422 | case 15: | |||
3423 | name = "integer"; | |||
3424 | rettype = debug_make_int_type (dhandle, 4, FALSE0); | |||
3425 | break; | |||
3426 | case 16: | |||
3427 | name = "boolean"; | |||
3428 | rettype = debug_make_bool_type (dhandle, 4); | |||
3429 | break; | |||
3430 | case 17: | |||
3431 | name = "short real"; | |||
3432 | rettype = debug_make_float_type (dhandle, 4); | |||
3433 | break; | |||
3434 | case 18: | |||
3435 | name = "real"; | |||
3436 | rettype = debug_make_float_type (dhandle, 8); | |||
3437 | break; | |||
3438 | case 19: | |||
3439 | /* FIXME */ | |||
3440 | name = "stringptr"; | |||
3441 | rettype = NULL((void*)0); | |||
3442 | break; | |||
3443 | case 20: | |||
3444 | /* FIXME */ | |||
3445 | name = "character"; | |||
3446 | rettype = debug_make_int_type (dhandle, 1, TRUE1); | |||
3447 | break; | |||
3448 | case 21: | |||
3449 | name = "logical*1"; | |||
3450 | rettype = debug_make_bool_type (dhandle, 1); | |||
3451 | break; | |||
3452 | case 22: | |||
3453 | name = "logical*2"; | |||
3454 | rettype = debug_make_bool_type (dhandle, 2); | |||
3455 | break; | |||
3456 | case 23: | |||
3457 | name = "logical*4"; | |||
3458 | rettype = debug_make_bool_type (dhandle, 4); | |||
3459 | break; | |||
3460 | case 24: | |||
3461 | name = "logical"; | |||
3462 | rettype = debug_make_bool_type (dhandle, 4); | |||
3463 | break; | |||
3464 | case 25: | |||
3465 | /* Complex type consisting of two IEEE single precision values. */ | |||
3466 | name = "complex"; | |||
3467 | rettype = debug_make_complex_type (dhandle, 8); | |||
3468 | break; | |||
3469 | case 26: | |||
3470 | /* Complex type consisting of two IEEE double precision values. */ | |||
3471 | name = "double complex"; | |||
3472 | rettype = debug_make_complex_type (dhandle, 16); | |||
3473 | break; | |||
3474 | case 27: | |||
3475 | name = "integer*1"; | |||
3476 | rettype = debug_make_int_type (dhandle, 1, FALSE0); | |||
3477 | break; | |||
3478 | case 28: | |||
3479 | name = "integer*2"; | |||
3480 | rettype = debug_make_int_type (dhandle, 2, FALSE0); | |||
3481 | break; | |||
3482 | case 29: | |||
3483 | name = "integer*4"; | |||
3484 | rettype = debug_make_int_type (dhandle, 4, FALSE0); | |||
3485 | break; | |||
3486 | case 30: | |||
3487 | /* FIXME */ | |||
3488 | name = "wchar"; | |||
3489 | rettype = debug_make_int_type (dhandle, 2, FALSE0); | |||
3490 | break; | |||
3491 | case 31: | |||
3492 | name = "long long"; | |||
3493 | rettype = debug_make_int_type (dhandle, 8, FALSE0); | |||
3494 | break; | |||
3495 | case 32: | |||
3496 | name = "unsigned long long"; | |||
3497 | rettype = debug_make_int_type (dhandle, 8, TRUE1); | |||
3498 | break; | |||
3499 | case 33: | |||
3500 | name = "logical*8"; | |||
3501 | rettype = debug_make_bool_type (dhandle, 8); | |||
3502 | break; | |||
3503 | case 34: | |||
3504 | name = "integer*8"; | |||
3505 | rettype = debug_make_int_type (dhandle, 8, FALSE0); | |||
3506 | break; | |||
3507 | default: | |||
3508 | abort (); | |||
3509 | } | |||
3510 | ||||
3511 | rettype = debug_name_type (dhandle, name, rettype); | |||
3512 | ||||
3513 | info->xcoff_types[-typenum] = rettype; | |||
3514 | ||||
3515 | return rettype; | |||
3516 | } | |||
3517 | ||||
3518 | /* Find or create a tagged type. */ | |||
3519 | ||||
3520 | static debug_type | |||
3521 | stab_find_tagged_type (void *dhandle, struct stab_handle *info, | |||
3522 | const char *p, int len, enum debug_type_kind kind) | |||
3523 | { | |||
3524 | char *name; | |||
3525 | debug_type dtype; | |||
3526 | struct stab_tag *st; | |||
3527 | ||||
3528 | name = savestring (p, len); | |||
3529 | ||||
3530 | /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same | |||
3531 | namespace. This is right for C, and I don't know how to handle | |||
3532 | other languages. FIXME. */ | |||
3533 | dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL); | |||
3534 | if (dtype != DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
3535 | { | |||
3536 | free (name); | |||
3537 | return dtype; | |||
3538 | } | |||
3539 | ||||
3540 | /* We need to allocate an entry on the undefined tag list. */ | |||
3541 | for (st = info->tags; st != NULL((void*)0); st = st->next) | |||
3542 | { | |||
3543 | if (st->name[0] == name[0] | |||
3544 | && strcmp (st->name, name) == 0) | |||
3545 | { | |||
3546 | if (st->kind == DEBUG_KIND_ILLEGAL) | |||
3547 | st->kind = kind; | |||
3548 | free (name); | |||
3549 | break; | |||
3550 | } | |||
3551 | } | |||
3552 | if (st == NULL((void*)0)) | |||
3553 | { | |||
3554 | st = (struct stab_tag *) xmalloc (sizeof *st); | |||
3555 | memset (st, 0, sizeof *st); | |||
3556 | ||||
3557 | st->next = info->tags; | |||
3558 | st->name = name; | |||
3559 | st->kind = kind; | |||
3560 | st->slot = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
3561 | st->type = debug_make_indirect_type (dhandle, &st->slot, name); | |||
3562 | info->tags = st; | |||
3563 | } | |||
3564 | ||||
3565 | return st->type; | |||
3566 | } | |||
3567 | ||||
3568 | /* In order to get the correct argument types for a stubbed method, we | |||
3569 | need to extract the argument types from a C++ mangled string. | |||
3570 | Since the argument types can refer back to the return type, this | |||
3571 | means that we must demangle the entire physical name. In gdb this | |||
3572 | is done by calling cplus_demangle and running the results back | |||
3573 | through the C++ expression parser. Since we have no expression | |||
3574 | parser, we must duplicate much of the work of cplus_demangle here. | |||
3575 | ||||
3576 | We assume that GNU style demangling is used, since this is only | |||
3577 | done for method stubs, and only g++ should output that form of | |||
3578 | debugging information. */ | |||
3579 | ||||
3580 | /* This structure is used to hold a pointer to type information which | |||
3581 | demangling a string. */ | |||
3582 | ||||
3583 | struct stab_demangle_typestring | |||
3584 | { | |||
3585 | /* The start of the type. This is not null terminated. */ | |||
3586 | const char *typestring; | |||
3587 | /* The length of the type. */ | |||
3588 | unsigned int len; | |||
3589 | }; | |||
3590 | ||||
3591 | /* This structure is used to hold information while demangling a | |||
3592 | string. */ | |||
3593 | ||||
3594 | struct stab_demangle_info | |||
3595 | { | |||
3596 | /* The debugging information handle. */ | |||
3597 | void *dhandle; | |||
3598 | /* The stab information handle. */ | |||
3599 | struct stab_handle *info; | |||
3600 | /* The array of arguments we are building. */ | |||
3601 | debug_type *args; | |||
3602 | /* Whether the method takes a variable number of arguments. */ | |||
3603 | bfd_boolean varargs; | |||
3604 | /* The array of types we have remembered. */ | |||
3605 | struct stab_demangle_typestring *typestrings; | |||
3606 | /* The number of typestrings. */ | |||
3607 | unsigned int typestring_count; | |||
3608 | /* The number of typestring slots we have allocated. */ | |||
3609 | unsigned int typestring_alloc; | |||
3610 | }; | |||
3611 | ||||
3612 | static void stab_bad_demangle (const char *); | |||
3613 | static unsigned int stab_demangle_count (const char **); | |||
3614 | static bfd_boolean stab_demangle_get_count (const char **, unsigned int *); | |||
3615 | static bfd_boolean stab_demangle_prefix | |||
3616 | (struct stab_demangle_info *, const char **, unsigned int); | |||
3617 | static bfd_boolean stab_demangle_function_name | |||
3618 | (struct stab_demangle_info *, const char **, const char *); | |||
3619 | static bfd_boolean stab_demangle_signature | |||
3620 | (struct stab_demangle_info *, const char **); | |||
3621 | static bfd_boolean stab_demangle_qualified | |||
3622 | (struct stab_demangle_info *, const char **, debug_type *); | |||
3623 | static bfd_boolean stab_demangle_template | |||
3624 | (struct stab_demangle_info *, const char **, char **); | |||
3625 | static bfd_boolean stab_demangle_class | |||
3626 | (struct stab_demangle_info *, const char **, const char **); | |||
3627 | static bfd_boolean stab_demangle_args | |||
3628 | (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *); | |||
3629 | static bfd_boolean stab_demangle_arg | |||
3630 | (struct stab_demangle_info *, const char **, debug_type **, | |||
3631 | unsigned int *, unsigned int *); | |||
3632 | static bfd_boolean stab_demangle_type | |||
3633 | (struct stab_demangle_info *, const char **, debug_type *); | |||
3634 | static bfd_boolean stab_demangle_fund_type | |||
3635 | (struct stab_demangle_info *, const char **, debug_type *); | |||
3636 | static bfd_boolean stab_demangle_remember_type | |||
3637 | (struct stab_demangle_info *, const char *, int); | |||
3638 | ||||
3639 | /* Warn about a bad demangling. */ | |||
3640 | ||||
3641 | static void | |||
3642 | stab_bad_demangle (const char *s) | |||
3643 | { | |||
3644 | fprintf (stderr(&__sF[2]), _("bad mangled name `%s'\n")("bad mangled name `%s'\n"), s); | |||
3645 | } | |||
3646 | ||||
3647 | /* Get a count from a stab string. */ | |||
3648 | ||||
3649 | static unsigned int | |||
3650 | stab_demangle_count (const char **pp) | |||
3651 | { | |||
3652 | unsigned int count; | |||
3653 | ||||
3654 | count = 0; | |||
3655 | while (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
3656 | { | |||
3657 | count *= 10; | |||
3658 | count += **pp - '0'; | |||
3659 | ++*pp; | |||
3660 | } | |||
3661 | return count; | |||
3662 | } | |||
3663 | ||||
3664 | /* Require a count in a string. The count may be multiple digits, in | |||
3665 | which case it must end in an underscore. */ | |||
3666 | ||||
3667 | static bfd_boolean | |||
3668 | stab_demangle_get_count (const char **pp, unsigned int *pi) | |||
3669 | { | |||
3670 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
3671 | return FALSE0; | |||
3672 | ||||
3673 | *pi = **pp - '0'; | |||
3674 | ++*pp; | |||
3675 | if (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
3676 | { | |||
3677 | unsigned int count; | |||
3678 | const char *p; | |||
3679 | ||||
3680 | count = *pi; | |||
3681 | p = *pp; | |||
3682 | do | |||
3683 | { | |||
3684 | count *= 10; | |||
3685 | count += *p - '0'; | |||
3686 | ++p; | |||
3687 | } | |||
3688 | while (ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit ))); | |||
3689 | if (*p == '_') | |||
3690 | { | |||
3691 | *pp = p + 1; | |||
3692 | *pi = count; | |||
3693 | } | |||
3694 | } | |||
3695 | ||||
3696 | return TRUE1; | |||
3697 | } | |||
3698 | ||||
3699 | /* This function demangles a physical name, returning a NULL | |||
3700 | terminated array of argument types. */ | |||
3701 | ||||
3702 | static debug_type * | |||
3703 | stab_demangle_argtypes (void *dhandle, struct stab_handle *info, | |||
3704 | const char *physname, bfd_boolean *pvarargs, | |||
3705 | unsigned int physname_len) | |||
3706 | { | |||
3707 | struct stab_demangle_info minfo; | |||
3708 | ||||
3709 | /* Check for the g++ V3 ABI. */ | |||
3710 | if (physname[0] == '_' && physname[1] == 'Z') | |||
3711 | return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs); | |||
3712 | ||||
3713 | minfo.dhandle = dhandle; | |||
3714 | minfo.info = info; | |||
3715 | minfo.args = NULL((void*)0); | |||
3716 | minfo.varargs = FALSE0; | |||
3717 | minfo.typestring_alloc = 10; | |||
3718 | minfo.typestrings = ((struct stab_demangle_typestring *) | |||
3719 | xmalloc (minfo.typestring_alloc | |||
3720 | * sizeof *minfo.typestrings)); | |||
3721 | minfo.typestring_count = 0; | |||
3722 | ||||
3723 | /* cplus_demangle checks for special GNU mangled forms, but we can't | |||
3724 | see any of them in mangled method argument types. */ | |||
3725 | ||||
3726 | if (! stab_demangle_prefix (&minfo, &physname, physname_len)) | |||
3727 | goto error_return; | |||
3728 | ||||
3729 | if (*physname != '\0') | |||
3730 | { | |||
3731 | if (! stab_demangle_signature (&minfo, &physname)) | |||
3732 | goto error_return; | |||
3733 | } | |||
3734 | ||||
3735 | free (minfo.typestrings); | |||
3736 | minfo.typestrings = NULL((void*)0); | |||
3737 | ||||
3738 | if (minfo.args == NULL((void*)0)) | |||
3739 | fprintf (stderr(&__sF[2]), _("no argument types in mangled string\n")("no argument types in mangled string\n")); | |||
3740 | ||||
3741 | *pvarargs = minfo.varargs; | |||
3742 | return minfo.args; | |||
3743 | ||||
3744 | error_return: | |||
3745 | if (minfo.typestrings != NULL((void*)0)) | |||
3746 | free (minfo.typestrings); | |||
3747 | return NULL((void*)0); | |||
3748 | } | |||
3749 | ||||
3750 | /* Demangle the prefix of the mangled name. */ | |||
3751 | ||||
3752 | static bfd_boolean | |||
3753 | stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp, | |||
3754 | unsigned int physname_len) | |||
3755 | { | |||
3756 | const char *scan; | |||
3757 | unsigned int i; | |||
3758 | ||||
3759 | /* cplus_demangle checks for global constructors and destructors, | |||
3760 | but we can't see them in mangled argument types. */ | |||
3761 | ||||
3762 | if (physname_len) | |||
3763 | scan = *pp + physname_len; | |||
3764 | else | |||
3765 | { | |||
3766 | /* Look for `__'. */ | |||
3767 | scan = *pp; | |||
3768 | do | |||
3769 | scan = strchr (scan, '_'); | |||
3770 | while (scan != NULL((void*)0) && *++scan != '_'); | |||
3771 | ||||
3772 | if (scan == NULL((void*)0)) | |||
3773 | { | |||
3774 | stab_bad_demangle (*pp); | |||
3775 | return FALSE0; | |||
3776 | } | |||
3777 | ||||
3778 | --scan; | |||
3779 | ||||
3780 | /* We found `__'; move ahead to the last contiguous `__' pair. */ | |||
3781 | i = strspn (scan, "_"); | |||
3782 | if (i > 2) | |||
3783 | scan += i - 2; | |||
3784 | } | |||
3785 | ||||
3786 | if (scan == *pp | |||
3787 | && (ISDIGIT (scan[2])(_sch_istable[(scan[2]) & 0xff] & (unsigned short)(_sch_isdigit )) | |||
3788 | || scan[2] == 'Q' | |||
3789 | || scan[2] == 't')) | |||
3790 | { | |||
3791 | /* This is a GNU style constructor name. */ | |||
3792 | *pp = scan + 2; | |||
3793 | return TRUE1; | |||
3794 | } | |||
3795 | else if (scan == *pp | |||
3796 | && ! ISDIGIT (scan[2])(_sch_istable[(scan[2]) & 0xff] & (unsigned short)(_sch_isdigit )) | |||
3797 | && scan[2] != 't') | |||
3798 | { | |||
3799 | /* Look for the `__' that separates the prefix from the | |||
3800 | signature. */ | |||
3801 | while (*scan == '_') | |||
3802 | ++scan; | |||
3803 | scan = strstr (scan, "__"); | |||
3804 | if (scan == NULL((void*)0) || scan[2] == '\0') | |||
3805 | { | |||
3806 | stab_bad_demangle (*pp); | |||
3807 | return FALSE0; | |||
3808 | } | |||
3809 | ||||
3810 | return stab_demangle_function_name (minfo, pp, scan); | |||
3811 | } | |||
3812 | else if (scan[2] != '\0') | |||
3813 | { | |||
3814 | /* The name doesn't start with `__', but it does contain `__'. */ | |||
3815 | return stab_demangle_function_name (minfo, pp, scan); | |||
3816 | } | |||
3817 | else | |||
3818 | { | |||
3819 | stab_bad_demangle (*pp); | |||
3820 | return FALSE0; | |||
3821 | } | |||
3822 | /*NOTREACHED*/ | |||
3823 | } | |||
3824 | ||||
3825 | /* Demangle a function name prefix. The scan argument points to the | |||
3826 | double underscore which separates the function name from the | |||
3827 | signature. */ | |||
3828 | ||||
3829 | static bfd_boolean | |||
3830 | stab_demangle_function_name (struct stab_demangle_info *minfo, | |||
3831 | const char **pp, const char *scan) | |||
3832 | { | |||
3833 | const char *name; | |||
3834 | ||||
3835 | /* The string from *pp to scan is the name of the function. We | |||
3836 | don't care about the name, since we just looking for argument | |||
3837 | types. However, for conversion operators, the name may include a | |||
3838 | type which we must remember in order to handle backreferences. */ | |||
3839 | ||||
3840 | name = *pp; | |||
3841 | *pp = scan + 2; | |||
3842 | ||||
3843 | if (*pp - name >= 5 | |||
3844 | && strncmp (name, "type", 4) == 0 | |||
3845 | && (name[4] == '$' || name[4] == '.')) | |||
3846 | { | |||
3847 | const char *tem; | |||
3848 | ||||
3849 | /* This is a type conversion operator. */ | |||
3850 | tem = name + 5; | |||
3851 | if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL((void*)0))) | |||
3852 | return FALSE0; | |||
3853 | } | |||
3854 | else if (name[0] == '_' | |||
3855 | && name[1] == '_' | |||
3856 | && name[2] == 'o' | |||
3857 | && name[3] == 'p') | |||
3858 | { | |||
3859 | const char *tem; | |||
3860 | ||||
3861 | /* This is a type conversion operator. */ | |||
3862 | tem = name + 4; | |||
3863 | if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL((void*)0))) | |||
3864 | return FALSE0; | |||
3865 | } | |||
3866 | ||||
3867 | return TRUE1; | |||
3868 | } | |||
3869 | ||||
3870 | /* Demangle the signature. This is where the argument types are | |||
3871 | found. */ | |||
3872 | ||||
3873 | static bfd_boolean | |||
3874 | stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp) | |||
3875 | { | |||
3876 | const char *orig; | |||
3877 | bfd_boolean expect_func, func_done; | |||
3878 | const char *hold; | |||
3879 | ||||
3880 | orig = *pp; | |||
3881 | ||||
3882 | expect_func = FALSE0; | |||
3883 | func_done = FALSE0; | |||
3884 | hold = NULL((void*)0); | |||
3885 | ||||
3886 | while (**pp != '\0') | |||
3887 | { | |||
3888 | switch (**pp) | |||
3889 | { | |||
3890 | case 'Q': | |||
3891 | hold = *pp; | |||
3892 | if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL((void*)0)) | |||
3893 | || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) | |||
3894 | return FALSE0; | |||
3895 | expect_func = TRUE1; | |||
3896 | hold = NULL((void*)0); | |||
3897 | break; | |||
3898 | ||||
3899 | case 'S': | |||
3900 | /* Static member function. FIXME: Can this happen? */ | |||
3901 | if (hold == NULL((void*)0)) | |||
3902 | hold = *pp; | |||
3903 | ++*pp; | |||
3904 | break; | |||
3905 | ||||
3906 | case 'C': | |||
3907 | /* Const member function. */ | |||
3908 | if (hold == NULL((void*)0)) | |||
3909 | hold = *pp; | |||
3910 | ++*pp; | |||
3911 | break; | |||
3912 | ||||
3913 | case '0': case '1': case '2': case '3': case '4': | |||
3914 | case '5': case '6': case '7': case '8': case '9': | |||
3915 | if (hold == NULL((void*)0)) | |||
3916 | hold = *pp; | |||
3917 | if (! stab_demangle_class (minfo, pp, (const char **) NULL((void*)0)) | |||
3918 | || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) | |||
3919 | return FALSE0; | |||
3920 | expect_func = TRUE1; | |||
3921 | hold = NULL((void*)0); | |||
3922 | break; | |||
3923 | ||||
3924 | case 'F': | |||
3925 | /* Function. I don't know if this actually happens with g++ | |||
3926 | output. */ | |||
3927 | hold = NULL((void*)0); | |||
3928 | func_done = TRUE1; | |||
3929 | ++*pp; | |||
3930 | if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) | |||
3931 | return FALSE0; | |||
3932 | break; | |||
3933 | ||||
3934 | case 't': | |||
3935 | /* Template. */ | |||
3936 | if (hold == NULL((void*)0)) | |||
3937 | hold = *pp; | |||
3938 | if (! stab_demangle_template (minfo, pp, (char **) NULL((void*)0)) | |||
3939 | || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) | |||
3940 | return FALSE0; | |||
3941 | hold = NULL((void*)0); | |||
3942 | expect_func = TRUE1; | |||
3943 | break; | |||
3944 | ||||
3945 | case '_': | |||
3946 | /* At the outermost level, we cannot have a return type | |||
3947 | specified, so if we run into another '_' at this point we | |||
3948 | are dealing with a mangled name that is either bogus, or | |||
3949 | has been mangled by some algorithm we don't know how to | |||
3950 | deal with. So just reject the entire demangling. */ | |||
3951 | stab_bad_demangle (orig); | |||
3952 | return FALSE0; | |||
3953 | ||||
3954 | default: | |||
3955 | /* Assume we have stumbled onto the first outermost function | |||
3956 | argument token, and start processing args. */ | |||
3957 | func_done = TRUE1; | |||
3958 | if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) | |||
3959 | return FALSE0; | |||
3960 | break; | |||
3961 | } | |||
3962 | ||||
3963 | if (expect_func) | |||
3964 | { | |||
3965 | func_done = TRUE1; | |||
3966 | if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) | |||
3967 | return FALSE0; | |||
3968 | } | |||
3969 | } | |||
3970 | ||||
3971 | if (! func_done) | |||
3972 | { | |||
3973 | /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and | |||
3974 | bar__3fooi is 'foo::bar(int)'. We get here when we find the | |||
3975 | first case, and need to ensure that the '(void)' gets added | |||
3976 | to the current declp. */ | |||
3977 | if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) | |||
3978 | return FALSE0; | |||
3979 | } | |||
3980 | ||||
3981 | return TRUE1; | |||
3982 | } | |||
3983 | ||||
3984 | /* Demangle a qualified name, such as "Q25Outer5Inner" which is the | |||
3985 | mangled form of "Outer::Inner". */ | |||
3986 | ||||
3987 | static bfd_boolean | |||
3988 | stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp, | |||
3989 | debug_type *ptype) | |||
3990 | { | |||
3991 | const char *orig; | |||
3992 | const char *p; | |||
3993 | unsigned int qualifiers; | |||
3994 | debug_type context; | |||
3995 | ||||
3996 | orig = *pp; | |||
3997 | ||||
3998 | switch ((*pp)[1]) | |||
3999 | { | |||
4000 | case '_': | |||
4001 | /* GNU mangled name with more than 9 classes. The count is | |||
4002 | preceded by an underscore (to distinguish it from the <= 9 | |||
4003 | case) and followed by an underscore. */ | |||
4004 | p = *pp + 2; | |||
4005 | if (! ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit )) || *p == '0') | |||
4006 | { | |||
4007 | stab_bad_demangle (orig); | |||
4008 | return FALSE0; | |||
4009 | } | |||
4010 | qualifiers = atoi (p); | |||
4011 | while (ISDIGIT (*p)(_sch_istable[(*p) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4012 | ++p; | |||
4013 | if (*p != '_') | |||
4014 | { | |||
4015 | stab_bad_demangle (orig); | |||
4016 | return FALSE0; | |||
4017 | } | |||
4018 | *pp = p + 1; | |||
4019 | break; | |||
4020 | ||||
4021 | case '1': case '2': case '3': case '4': case '5': | |||
4022 | case '6': case '7': case '8': case '9': | |||
4023 | qualifiers = (*pp)[1] - '0'; | |||
4024 | /* Skip an optional underscore after the count. */ | |||
4025 | if ((*pp)[2] == '_') | |||
4026 | ++*pp; | |||
4027 | *pp += 2; | |||
4028 | break; | |||
4029 | ||||
4030 | case '0': | |||
4031 | default: | |||
4032 | stab_bad_demangle (orig); | |||
4033 | return FALSE0; | |||
4034 | } | |||
4035 | ||||
4036 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
4037 | ||||
4038 | /* Pick off the names. */ | |||
4039 | while (qualifiers-- > 0) | |||
4040 | { | |||
4041 | if (**pp == '_') | |||
4042 | ++*pp; | |||
4043 | if (**pp == 't') | |||
4044 | { | |||
4045 | char *name; | |||
4046 | ||||
4047 | if (! stab_demangle_template (minfo, pp, | |||
4048 | ptype != NULL((void*)0) ? &name : NULL((void*)0))) | |||
4049 | return FALSE0; | |||
4050 | ||||
4051 | if (ptype != NULL((void*)0)) | |||
4052 | { | |||
4053 | context = stab_find_tagged_type (minfo->dhandle, minfo->info, | |||
4054 | name, strlen (name), | |||
4055 | DEBUG_KIND_CLASS); | |||
4056 | free (name); | |||
4057 | if (context == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4058 | return FALSE0; | |||
4059 | } | |||
4060 | } | |||
4061 | else | |||
4062 | { | |||
4063 | unsigned int len; | |||
4064 | ||||
4065 | len = stab_demangle_count (pp); | |||
4066 | if (strlen (*pp) < len) | |||
4067 | { | |||
4068 | stab_bad_demangle (orig); | |||
4069 | return FALSE0; | |||
4070 | } | |||
4071 | ||||
4072 | if (ptype != NULL((void*)0)) | |||
4073 | { | |||
4074 | const debug_field *fields; | |||
4075 | ||||
4076 | fields = NULL((void*)0); | |||
4077 | if (context != DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4078 | fields = debug_get_fields (minfo->dhandle, context); | |||
4079 | ||||
4080 | context = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
4081 | ||||
4082 | if (fields != NULL((void*)0)) | |||
4083 | { | |||
4084 | char *name; | |||
4085 | ||||
4086 | /* Try to find the type by looking through the | |||
4087 | fields of context until we find a field with the | |||
4088 | same type. This ought to work for a class | |||
4089 | defined within a class, but it won't work for, | |||
4090 | e.g., an enum defined within a class. stabs does | |||
4091 | not give us enough information to figure out the | |||
4092 | latter case. */ | |||
4093 | ||||
4094 | name = savestring (*pp, len); | |||
4095 | ||||
4096 | for (; *fields != DEBUG_FIELD_NULL((debug_field) ((void*)0)); fields++) | |||
4097 | { | |||
4098 | debug_type ft; | |||
4099 | const char *dn; | |||
4100 | ||||
4101 | ft = debug_get_field_type (minfo->dhandle, *fields); | |||
4102 | if (ft == NULL((void*)0)) | |||
4103 | return FALSE0; | |||
4104 | dn = debug_get_type_name (minfo->dhandle, ft); | |||
4105 | if (dn != NULL((void*)0) && strcmp (dn, name) == 0) | |||
4106 | { | |||
4107 | context = ft; | |||
4108 | break; | |||
4109 | } | |||
4110 | } | |||
4111 | ||||
4112 | free (name); | |||
4113 | } | |||
4114 | ||||
4115 | if (context == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4116 | { | |||
4117 | /* We have to fall back on finding the type by name. | |||
4118 | If there are more types to come, then this must | |||
4119 | be a class. Otherwise, it could be anything. */ | |||
4120 | ||||
4121 | if (qualifiers == 0) | |||
4122 | { | |||
4123 | char *name; | |||
4124 | ||||
4125 | name = savestring (*pp, len); | |||
4126 | context = debug_find_named_type (minfo->dhandle, | |||
4127 | name); | |||
4128 | free (name); | |||
4129 | } | |||
4130 | ||||
4131 | if (context == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4132 | { | |||
4133 | context = stab_find_tagged_type (minfo->dhandle, | |||
4134 | minfo->info, | |||
4135 | *pp, len, | |||
4136 | (qualifiers == 0 | |||
4137 | ? DEBUG_KIND_ILLEGAL | |||
4138 | : DEBUG_KIND_CLASS)); | |||
4139 | if (context == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4140 | return FALSE0; | |||
4141 | } | |||
4142 | } | |||
4143 | } | |||
4144 | ||||
4145 | *pp += len; | |||
4146 | } | |||
4147 | } | |||
4148 | ||||
4149 | if (ptype != NULL((void*)0)) | |||
4150 | *ptype = context; | |||
4151 | ||||
4152 | return TRUE1; | |||
4153 | } | |||
4154 | ||||
4155 | /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a | |||
4156 | string representation of the template. */ | |||
4157 | ||||
4158 | static bfd_boolean | |||
4159 | stab_demangle_template (struct stab_demangle_info *minfo, const char **pp, | |||
4160 | char **pname) | |||
4161 | { | |||
4162 | const char *orig; | |||
4163 | unsigned int r, i; | |||
4164 | ||||
4165 | orig = *pp; | |||
4166 | ||||
4167 | ++*pp; | |||
4168 | ||||
4169 | /* Skip the template name. */ | |||
4170 | r = stab_demangle_count (pp); | |||
4171 | if (r == 0 || strlen (*pp) < r) | |||
4172 | { | |||
4173 | stab_bad_demangle (orig); | |||
4174 | return FALSE0; | |||
4175 | } | |||
4176 | *pp += r; | |||
4177 | ||||
4178 | /* Get the size of the parameter list. */ | |||
4179 | if (stab_demangle_get_count (pp, &r) == 0) | |||
4180 | { | |||
4181 | stab_bad_demangle (orig); | |||
4182 | return FALSE0; | |||
4183 | } | |||
4184 | ||||
4185 | for (i = 0; i < r; i++) | |||
4186 | { | |||
4187 | if (**pp == 'Z') | |||
4188 | { | |||
4189 | /* This is a type parameter. */ | |||
4190 | ++*pp; | |||
4191 | if (! stab_demangle_type (minfo, pp, (debug_type *) NULL((void*)0))) | |||
4192 | return FALSE0; | |||
4193 | } | |||
4194 | else | |||
4195 | { | |||
4196 | const char *old_p; | |||
4197 | bfd_boolean pointerp, realp, integralp, charp, boolp; | |||
4198 | bfd_boolean done; | |||
4199 | ||||
4200 | old_p = *pp; | |||
4201 | pointerp = FALSE0; | |||
4202 | realp = FALSE0; | |||
4203 | integralp = FALSE0; | |||
4204 | charp = FALSE0; | |||
4205 | boolp = FALSE0; | |||
4206 | done = FALSE0; | |||
4207 | ||||
4208 | /* This is a value parameter. */ | |||
4209 | ||||
4210 | if (! stab_demangle_type (minfo, pp, (debug_type *) NULL((void*)0))) | |||
4211 | return FALSE0; | |||
4212 | ||||
4213 | while (*old_p != '\0' && ! done) | |||
4214 | { | |||
4215 | switch (*old_p) | |||
4216 | { | |||
4217 | case 'P': | |||
4218 | case 'p': | |||
4219 | case 'R': | |||
4220 | pointerp = TRUE1; | |||
4221 | done = TRUE1; | |||
4222 | break; | |||
4223 | case 'C': /* Const. */ | |||
4224 | case 'S': /* Signed. */ | |||
4225 | case 'U': /* Unsigned. */ | |||
4226 | case 'V': /* Volatile. */ | |||
4227 | case 'F': /* Function. */ | |||
4228 | case 'M': /* Member function. */ | |||
4229 | case 'O': /* ??? */ | |||
4230 | ++old_p; | |||
4231 | break; | |||
4232 | case 'Q': /* Qualified name. */ | |||
4233 | integralp = TRUE1; | |||
4234 | done = TRUE1; | |||
4235 | break; | |||
4236 | case 'T': /* Remembered type. */ | |||
4237 | abort (); | |||
4238 | case 'v': /* Void. */ | |||
4239 | abort (); | |||
4240 | case 'x': /* Long long. */ | |||
4241 | case 'l': /* Long. */ | |||
4242 | case 'i': /* Int. */ | |||
4243 | case 's': /* Short. */ | |||
4244 | case 'w': /* Wchar_t. */ | |||
4245 | integralp = TRUE1; | |||
4246 | done = TRUE1; | |||
4247 | break; | |||
4248 | case 'b': /* Bool. */ | |||
4249 | boolp = TRUE1; | |||
4250 | done = TRUE1; | |||
4251 | break; | |||
4252 | case 'c': /* Char. */ | |||
4253 | charp = TRUE1; | |||
4254 | done = TRUE1; | |||
4255 | break; | |||
4256 | case 'r': /* Long double. */ | |||
4257 | case 'd': /* Double. */ | |||
4258 | case 'f': /* Float. */ | |||
4259 | realp = TRUE1; | |||
4260 | done = TRUE1; | |||
4261 | break; | |||
4262 | default: | |||
4263 | /* Assume it's a user defined integral type. */ | |||
4264 | integralp = TRUE1; | |||
4265 | done = TRUE1; | |||
4266 | break; | |||
4267 | } | |||
4268 | } | |||
4269 | ||||
4270 | if (integralp) | |||
4271 | { | |||
4272 | if (**pp == 'm') | |||
4273 | ++*pp; | |||
4274 | while (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4275 | ++*pp; | |||
4276 | } | |||
4277 | else if (charp) | |||
4278 | { | |||
4279 | unsigned int val; | |||
4280 | ||||
4281 | if (**pp == 'm') | |||
4282 | ++*pp; | |||
4283 | val = stab_demangle_count (pp); | |||
4284 | if (val == 0) | |||
4285 | { | |||
4286 | stab_bad_demangle (orig); | |||
4287 | return FALSE0; | |||
4288 | } | |||
4289 | } | |||
4290 | else if (boolp) | |||
4291 | { | |||
4292 | unsigned int val; | |||
4293 | ||||
4294 | val = stab_demangle_count (pp); | |||
4295 | if (val != 0 && val != 1) | |||
4296 | { | |||
4297 | stab_bad_demangle (orig); | |||
4298 | return FALSE0; | |||
4299 | } | |||
4300 | } | |||
4301 | else if (realp) | |||
4302 | { | |||
4303 | if (**pp == 'm') | |||
4304 | ++*pp; | |||
4305 | while (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4306 | ++*pp; | |||
4307 | if (**pp == '.') | |||
4308 | { | |||
4309 | ++*pp; | |||
4310 | while (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4311 | ++*pp; | |||
4312 | } | |||
4313 | if (**pp == 'e') | |||
4314 | { | |||
4315 | ++*pp; | |||
4316 | while (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4317 | ++*pp; | |||
4318 | } | |||
4319 | } | |||
4320 | else if (pointerp) | |||
4321 | { | |||
4322 | unsigned int len; | |||
4323 | ||||
4324 | len = stab_demangle_count (pp); | |||
4325 | if (len == 0) | |||
4326 | { | |||
4327 | stab_bad_demangle (orig); | |||
4328 | return FALSE0; | |||
4329 | } | |||
4330 | *pp += len; | |||
4331 | } | |||
4332 | } | |||
4333 | } | |||
4334 | ||||
4335 | /* We can translate this to a string fairly easily by invoking the | |||
4336 | regular demangling routine. */ | |||
4337 | if (pname != NULL((void*)0)) | |||
4338 | { | |||
4339 | char *s1, *s2, *s3, *s4 = NULL((void*)0); | |||
4340 | char *from, *to; | |||
4341 | ||||
4342 | s1 = savestring (orig, *pp - orig); | |||
4343 | ||||
4344 | s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL((void*)0)); | |||
4345 | ||||
4346 | free (s1); | |||
4347 | ||||
4348 | s3 = cplus_demangle (s2, DMGL_ANSI(1 << 1)); | |||
4349 | ||||
4350 | free (s2); | |||
4351 | ||||
4352 | if (s3 != NULL((void*)0)) | |||
4353 | s4 = strstr (s3, "::NoSuchStrinG"); | |||
4354 | if (s3 == NULL((void*)0) || s4 == NULL((void*)0)) | |||
4355 | { | |||
4356 | stab_bad_demangle (orig); | |||
4357 | if (s3 != NULL((void*)0)) | |||
4358 | free (s3); | |||
4359 | return FALSE0; | |||
4360 | } | |||
4361 | ||||
4362 | /* Eliminating all spaces, except those between > characters, | |||
4363 | makes it more likely that the demangled name will match the | |||
4364 | name which g++ used as the structure name. */ | |||
4365 | for (from = to = s3; from != s4; ++from) | |||
4366 | if (*from != ' ' | |||
4367 | || (from[1] == '>' && from > s3 && from[-1] == '>')) | |||
4368 | *to++ = *from; | |||
4369 | ||||
4370 | *pname = savestring (s3, to - s3); | |||
4371 | ||||
4372 | free (s3); | |||
4373 | } | |||
4374 | ||||
4375 | return TRUE1; | |||
4376 | } | |||
4377 | ||||
4378 | /* Demangle a class name. */ | |||
4379 | ||||
4380 | static bfd_boolean | |||
4381 | stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED__attribute__ ((__unused__)), | |||
4382 | const char **pp, const char **pstart) | |||
4383 | { | |||
4384 | const char *orig; | |||
4385 | unsigned int n; | |||
4386 | ||||
4387 | orig = *pp; | |||
4388 | ||||
4389 | n = stab_demangle_count (pp); | |||
4390 | if (strlen (*pp) < n) | |||
4391 | { | |||
4392 | stab_bad_demangle (orig); | |||
4393 | return FALSE0; | |||
4394 | } | |||
4395 | ||||
4396 | if (pstart != NULL((void*)0)) | |||
4397 | *pstart = *pp; | |||
4398 | ||||
4399 | *pp += n; | |||
4400 | ||||
4401 | return TRUE1; | |||
4402 | } | |||
4403 | ||||
4404 | /* Demangle function arguments. If the pargs argument is not NULL, it | |||
4405 | is set to a NULL terminated array holding the arguments. */ | |||
4406 | ||||
4407 | static bfd_boolean | |||
4408 | stab_demangle_args (struct stab_demangle_info *minfo, const char **pp, | |||
4409 | debug_type **pargs, bfd_boolean *pvarargs) | |||
4410 | { | |||
4411 | const char *orig; | |||
4412 | unsigned int alloc, count; | |||
4413 | ||||
4414 | orig = *pp; | |||
4415 | ||||
4416 | alloc = 10; | |||
4417 | if (pargs != NULL((void*)0)) | |||
4418 | { | |||
4419 | *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs); | |||
4420 | *pvarargs = FALSE0; | |||
4421 | } | |||
4422 | count = 0; | |||
4423 | ||||
4424 | while (**pp != '_' && **pp != '\0' && **pp != 'e') | |||
4425 | { | |||
4426 | if (**pp == 'N' || **pp == 'T') | |||
4427 | { | |||
4428 | char temptype; | |||
4429 | unsigned int r, t; | |||
4430 | ||||
4431 | temptype = **pp; | |||
4432 | ++*pp; | |||
4433 | ||||
4434 | if (temptype == 'T') | |||
4435 | r = 1; | |||
4436 | else | |||
4437 | { | |||
4438 | if (! stab_demangle_get_count (pp, &r)) | |||
4439 | { | |||
4440 | stab_bad_demangle (orig); | |||
4441 | return FALSE0; | |||
4442 | } | |||
4443 | } | |||
4444 | ||||
4445 | if (! stab_demangle_get_count (pp, &t)) | |||
4446 | { | |||
4447 | stab_bad_demangle (orig); | |||
4448 | return FALSE0; | |||
4449 | } | |||
4450 | ||||
4451 | if (t >= minfo->typestring_count) | |||
4452 | { | |||
4453 | stab_bad_demangle (orig); | |||
4454 | return FALSE0; | |||
4455 | } | |||
4456 | while (r-- > 0) | |||
4457 | { | |||
4458 | const char *tem; | |||
4459 | ||||
4460 | tem = minfo->typestrings[t].typestring; | |||
4461 | if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc)) | |||
4462 | return FALSE0; | |||
4463 | } | |||
4464 | } | |||
4465 | else | |||
4466 | { | |||
4467 | if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc)) | |||
4468 | return FALSE0; | |||
4469 | } | |||
4470 | } | |||
4471 | ||||
4472 | if (pargs != NULL((void*)0)) | |||
4473 | (*pargs)[count] = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
4474 | ||||
4475 | if (**pp == 'e') | |||
4476 | { | |||
4477 | if (pargs != NULL((void*)0)) | |||
4478 | *pvarargs = TRUE1; | |||
4479 | ++*pp; | |||
4480 | } | |||
4481 | ||||
4482 | return TRUE1; | |||
4483 | } | |||
4484 | ||||
4485 | /* Demangle a single argument. */ | |||
4486 | ||||
4487 | static bfd_boolean | |||
4488 | stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp, | |||
4489 | debug_type **pargs, unsigned int *pcount, | |||
4490 | unsigned int *palloc) | |||
4491 | { | |||
4492 | const char *start; | |||
4493 | debug_type type; | |||
4494 | ||||
4495 | start = *pp; | |||
4496 | if (! stab_demangle_type (minfo, pp, | |||
4497 | pargs == NULL((void*)0) ? (debug_type *) NULL((void*)0) : &type) | |||
4498 | || ! stab_demangle_remember_type (minfo, start, *pp - start)) | |||
4499 | return FALSE0; | |||
4500 | ||||
4501 | if (pargs != NULL((void*)0)) | |||
4502 | { | |||
4503 | if (type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4504 | return FALSE0; | |||
4505 | ||||
4506 | if (*pcount + 1 >= *palloc) | |||
4507 | { | |||
4508 | *palloc += 10; | |||
4509 | *pargs = ((debug_type *) | |||
4510 | xrealloc (*pargs, *palloc * sizeof **pargs)); | |||
4511 | } | |||
4512 | (*pargs)[*pcount] = type; | |||
4513 | ++*pcount; | |||
4514 | } | |||
4515 | ||||
4516 | return TRUE1; | |||
4517 | } | |||
4518 | ||||
4519 | /* Demangle a type. If the ptype argument is not NULL, *ptype is set | |||
4520 | to the newly allocated type. */ | |||
4521 | ||||
4522 | static bfd_boolean | |||
4523 | stab_demangle_type (struct stab_demangle_info *minfo, const char **pp, | |||
4524 | debug_type *ptype) | |||
4525 | { | |||
4526 | const char *orig; | |||
4527 | ||||
4528 | orig = *pp; | |||
4529 | ||||
4530 | switch (**pp) | |||
4531 | { | |||
4532 | case 'P': | |||
4533 | case 'p': | |||
4534 | /* A pointer type. */ | |||
4535 | ++*pp; | |||
4536 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4537 | return FALSE0; | |||
4538 | if (ptype != NULL((void*)0)) | |||
4539 | *ptype = debug_make_pointer_type (minfo->dhandle, *ptype); | |||
4540 | break; | |||
4541 | ||||
4542 | case 'R': | |||
4543 | /* A reference type. */ | |||
4544 | ++*pp; | |||
4545 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4546 | return FALSE0; | |||
4547 | if (ptype != NULL((void*)0)) | |||
4548 | *ptype = debug_make_reference_type (minfo->dhandle, *ptype); | |||
4549 | break; | |||
4550 | ||||
4551 | case 'A': | |||
4552 | /* An array. */ | |||
4553 | { | |||
4554 | unsigned long high; | |||
4555 | ||||
4556 | ++*pp; | |||
4557 | high = 0; | |||
4558 | while (**pp != '\0' && **pp != '_') | |||
4559 | { | |||
4560 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4561 | { | |||
4562 | stab_bad_demangle (orig); | |||
4563 | return FALSE0; | |||
4564 | } | |||
4565 | high *= 10; | |||
4566 | high += **pp - '0'; | |||
4567 | ++*pp; | |||
4568 | } | |||
4569 | if (**pp != '_') | |||
4570 | { | |||
4571 | stab_bad_demangle (orig); | |||
4572 | return FALSE0; | |||
4573 | } | |||
4574 | ++*pp; | |||
4575 | ||||
4576 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4577 | return FALSE0; | |||
4578 | if (ptype != NULL((void*)0)) | |||
4579 | { | |||
4580 | debug_type int_type; | |||
4581 | ||||
4582 | int_type = debug_find_named_type (minfo->dhandle, "int"); | |||
4583 | if (int_type == NULL((void*)0)) | |||
4584 | int_type = debug_make_int_type (minfo->dhandle, 4, FALSE0); | |||
4585 | *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type, | |||
4586 | 0, high, FALSE0); | |||
4587 | } | |||
4588 | } | |||
4589 | break; | |||
4590 | ||||
4591 | case 'T': | |||
4592 | /* A back reference to a remembered type. */ | |||
4593 | { | |||
4594 | unsigned int i; | |||
4595 | const char *p; | |||
4596 | ||||
4597 | ++*pp; | |||
4598 | if (! stab_demangle_get_count (pp, &i)) | |||
4599 | { | |||
4600 | stab_bad_demangle (orig); | |||
4601 | return FALSE0; | |||
4602 | } | |||
4603 | if (i >= minfo->typestring_count) | |||
4604 | { | |||
4605 | stab_bad_demangle (orig); | |||
4606 | return FALSE0; | |||
4607 | } | |||
4608 | p = minfo->typestrings[i].typestring; | |||
4609 | if (! stab_demangle_type (minfo, &p, ptype)) | |||
4610 | return FALSE0; | |||
4611 | } | |||
4612 | break; | |||
4613 | ||||
4614 | case 'F': | |||
4615 | /* A function. */ | |||
4616 | { | |||
4617 | debug_type *args; | |||
4618 | bfd_boolean varargs; | |||
4619 | ||||
4620 | ++*pp; | |||
4621 | if (! stab_demangle_args (minfo, pp, | |||
4622 | (ptype == NULL((void*)0) | |||
4623 | ? (debug_type **) NULL((void*)0) | |||
4624 | : &args), | |||
4625 | (ptype == NULL((void*)0) | |||
4626 | ? (bfd_boolean *) NULL((void*)0) | |||
4627 | : &varargs))) | |||
4628 | return FALSE0; | |||
4629 | if (**pp != '_') | |||
4630 | { | |||
4631 | /* cplus_demangle will accept a function without a return | |||
4632 | type, but I don't know when that will happen, or what | |||
4633 | to do if it does. */ | |||
4634 | stab_bad_demangle (orig); | |||
4635 | return FALSE0; | |||
4636 | } | |||
4637 | ++*pp; | |||
4638 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4639 | return FALSE0; | |||
4640 | if (ptype != NULL((void*)0)) | |||
4641 | *ptype = debug_make_function_type (minfo->dhandle, *ptype, args, | |||
4642 | varargs); | |||
4643 | ||||
4644 | } | |||
4645 | break; | |||
4646 | ||||
4647 | case 'M': | |||
4648 | case 'O': | |||
4649 | { | |||
4650 | bfd_boolean memberp, constp, volatilep; | |||
4651 | debug_type class_type = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
4652 | debug_type *args; | |||
4653 | bfd_boolean varargs; | |||
4654 | unsigned int n; | |||
4655 | const char *name; | |||
4656 | ||||
4657 | memberp = **pp == 'M'; | |||
4658 | constp = FALSE0; | |||
4659 | volatilep = FALSE0; | |||
4660 | args = NULL((void*)0); | |||
4661 | varargs = FALSE0; | |||
4662 | ||||
4663 | ++*pp; | |||
4664 | if (ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4665 | { | |||
4666 | n = stab_demangle_count (pp); | |||
4667 | if (strlen (*pp) < n) | |||
4668 | { | |||
4669 | stab_bad_demangle (orig); | |||
4670 | return FALSE0; | |||
4671 | } | |||
4672 | name = *pp; | |||
4673 | *pp += n; | |||
4674 | ||||
4675 | if (ptype != NULL((void*)0)) | |||
4676 | { | |||
4677 | class_type = stab_find_tagged_type (minfo->dhandle, | |||
4678 | minfo->info, | |||
4679 | name, (int) n, | |||
4680 | DEBUG_KIND_CLASS); | |||
4681 | if (class_type == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4682 | return FALSE0; | |||
4683 | } | |||
4684 | } | |||
4685 | else if (**pp == 'Q') | |||
4686 | { | |||
4687 | if (! stab_demangle_qualified (minfo, pp, | |||
4688 | (ptype == NULL((void*)0) | |||
4689 | ? (debug_type *) NULL((void*)0) | |||
4690 | : &class_type))) | |||
4691 | return FALSE0; | |||
4692 | } | |||
4693 | else | |||
4694 | { | |||
4695 | stab_bad_demangle (orig); | |||
4696 | return FALSE0; | |||
4697 | } | |||
4698 | ||||
4699 | if (memberp) | |||
4700 | { | |||
4701 | if (**pp == 'C') | |||
4702 | { | |||
4703 | constp = TRUE1; | |||
4704 | ++*pp; | |||
4705 | } | |||
4706 | else if (**pp == 'V') | |||
4707 | { | |||
4708 | volatilep = TRUE1; | |||
4709 | ++*pp; | |||
4710 | } | |||
4711 | if (**pp != 'F') | |||
4712 | { | |||
4713 | stab_bad_demangle (orig); | |||
4714 | return FALSE0; | |||
4715 | } | |||
4716 | ++*pp; | |||
4717 | if (! stab_demangle_args (minfo, pp, | |||
4718 | (ptype == NULL((void*)0) | |||
4719 | ? (debug_type **) NULL((void*)0) | |||
4720 | : &args), | |||
4721 | (ptype == NULL((void*)0) | |||
4722 | ? (bfd_boolean *) NULL((void*)0) | |||
4723 | : &varargs))) | |||
4724 | return FALSE0; | |||
4725 | } | |||
4726 | ||||
4727 | if (**pp != '_') | |||
4728 | { | |||
4729 | stab_bad_demangle (orig); | |||
4730 | return FALSE0; | |||
4731 | } | |||
4732 | ++*pp; | |||
4733 | ||||
4734 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4735 | return FALSE0; | |||
4736 | ||||
4737 | if (ptype != NULL((void*)0)) | |||
4738 | { | |||
4739 | if (! memberp) | |||
4740 | *ptype = debug_make_offset_type (minfo->dhandle, class_type, | |||
4741 | *ptype); | |||
4742 | else | |||
4743 | { | |||
4744 | /* FIXME: We have no way to record constp or | |||
4745 | volatilep. */ | |||
4746 | *ptype = debug_make_method_type (minfo->dhandle, *ptype, | |||
4747 | class_type, args, varargs); | |||
4748 | } | |||
4749 | } | |||
4750 | } | |||
4751 | break; | |||
4752 | ||||
4753 | case 'G': | |||
4754 | ++*pp; | |||
4755 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4756 | return FALSE0; | |||
4757 | break; | |||
4758 | ||||
4759 | case 'C': | |||
4760 | ++*pp; | |||
4761 | if (! stab_demangle_type (minfo, pp, ptype)) | |||
4762 | return FALSE0; | |||
4763 | if (ptype != NULL((void*)0)) | |||
4764 | *ptype = debug_make_const_type (minfo->dhandle, *ptype); | |||
4765 | break; | |||
4766 | ||||
4767 | case 'Q': | |||
4768 | { | |||
4769 | const char *hold; | |||
4770 | ||||
4771 | hold = *pp; | |||
4772 | if (! stab_demangle_qualified (minfo, pp, ptype)) | |||
4773 | return FALSE0; | |||
4774 | } | |||
4775 | break; | |||
4776 | ||||
4777 | default: | |||
4778 | if (! stab_demangle_fund_type (minfo, pp, ptype)) | |||
4779 | return FALSE0; | |||
4780 | break; | |||
4781 | } | |||
4782 | ||||
4783 | return TRUE1; | |||
4784 | } | |||
4785 | ||||
4786 | /* Demangle a fundamental type. If the ptype argument is not NULL, | |||
4787 | *ptype is set to the newly allocated type. */ | |||
4788 | ||||
4789 | static bfd_boolean | |||
4790 | stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp, | |||
4791 | debug_type *ptype) | |||
4792 | { | |||
4793 | const char *orig; | |||
4794 | bfd_boolean constp, volatilep, unsignedp, signedp; | |||
4795 | bfd_boolean done; | |||
4796 | ||||
4797 | orig = *pp; | |||
4798 | ||||
4799 | constp = FALSE0; | |||
4800 | volatilep = FALSE0; | |||
4801 | unsignedp = FALSE0; | |||
4802 | signedp = FALSE0; | |||
4803 | ||||
4804 | done = FALSE0; | |||
4805 | while (! done) | |||
4806 | { | |||
4807 | switch (**pp) | |||
4808 | { | |||
4809 | case 'C': | |||
4810 | constp = TRUE1; | |||
4811 | ++*pp; | |||
4812 | break; | |||
4813 | ||||
4814 | case 'U': | |||
4815 | unsignedp = TRUE1; | |||
4816 | ++*pp; | |||
4817 | break; | |||
4818 | ||||
4819 | case 'S': | |||
4820 | signedp = TRUE1; | |||
4821 | ++*pp; | |||
4822 | break; | |||
4823 | ||||
4824 | case 'V': | |||
4825 | volatilep = TRUE1; | |||
4826 | ++*pp; | |||
4827 | break; | |||
4828 | ||||
4829 | default: | |||
4830 | done = TRUE1; | |||
4831 | break; | |||
4832 | } | |||
4833 | } | |||
4834 | ||||
4835 | switch (**pp) | |||
4836 | { | |||
4837 | case '\0': | |||
4838 | case '_': | |||
4839 | /* cplus_demangle permits this, but I don't know what it means. */ | |||
4840 | stab_bad_demangle (orig); | |||
4841 | break; | |||
4842 | ||||
4843 | case 'v': /* void */ | |||
4844 | if (ptype != NULL((void*)0)) | |||
4845 | { | |||
4846 | *ptype = debug_find_named_type (minfo->dhandle, "void"); | |||
4847 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4848 | *ptype = debug_make_void_type (minfo->dhandle); | |||
4849 | } | |||
4850 | ++*pp; | |||
4851 | break; | |||
4852 | ||||
4853 | case 'x': /* long long */ | |||
4854 | if (ptype != NULL((void*)0)) | |||
4855 | { | |||
4856 | *ptype = debug_find_named_type (minfo->dhandle, | |||
4857 | (unsignedp | |||
4858 | ? "long long unsigned int" | |||
4859 | : "long long int")); | |||
4860 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4861 | *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp); | |||
4862 | } | |||
4863 | ++*pp; | |||
4864 | break; | |||
4865 | ||||
4866 | case 'l': /* long */ | |||
4867 | if (ptype != NULL((void*)0)) | |||
4868 | { | |||
4869 | *ptype = debug_find_named_type (minfo->dhandle, | |||
4870 | (unsignedp | |||
4871 | ? "long unsigned int" | |||
4872 | : "long int")); | |||
4873 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4874 | *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp); | |||
4875 | } | |||
4876 | ++*pp; | |||
4877 | break; | |||
4878 | ||||
4879 | case 'i': /* int */ | |||
4880 | if (ptype != NULL((void*)0)) | |||
4881 | { | |||
4882 | *ptype = debug_find_named_type (minfo->dhandle, | |||
4883 | (unsignedp | |||
4884 | ? "unsigned int" | |||
4885 | : "int")); | |||
4886 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4887 | *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp); | |||
4888 | } | |||
4889 | ++*pp; | |||
4890 | break; | |||
4891 | ||||
4892 | case 's': /* short */ | |||
4893 | if (ptype != NULL((void*)0)) | |||
4894 | { | |||
4895 | *ptype = debug_find_named_type (minfo->dhandle, | |||
4896 | (unsignedp | |||
4897 | ? "short unsigned int" | |||
4898 | : "short int")); | |||
4899 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4900 | *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp); | |||
4901 | } | |||
4902 | ++*pp; | |||
4903 | break; | |||
4904 | ||||
4905 | case 'b': /* bool */ | |||
4906 | if (ptype != NULL((void*)0)) | |||
4907 | { | |||
4908 | *ptype = debug_find_named_type (minfo->dhandle, "bool"); | |||
4909 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4910 | *ptype = debug_make_bool_type (minfo->dhandle, 4); | |||
4911 | } | |||
4912 | ++*pp; | |||
4913 | break; | |||
4914 | ||||
4915 | case 'c': /* char */ | |||
4916 | if (ptype != NULL((void*)0)) | |||
4917 | { | |||
4918 | *ptype = debug_find_named_type (minfo->dhandle, | |||
4919 | (unsignedp | |||
4920 | ? "unsigned char" | |||
4921 | : (signedp | |||
4922 | ? "signed char" | |||
4923 | : "char"))); | |||
4924 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4925 | *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp); | |||
4926 | } | |||
4927 | ++*pp; | |||
4928 | break; | |||
4929 | ||||
4930 | case 'w': /* wchar_t */ | |||
4931 | if (ptype != NULL((void*)0)) | |||
4932 | { | |||
4933 | *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t"); | |||
4934 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4935 | *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE1); | |||
4936 | } | |||
4937 | ++*pp; | |||
4938 | break; | |||
4939 | ||||
4940 | case 'r': /* long double */ | |||
4941 | if (ptype != NULL((void*)0)) | |||
4942 | { | |||
4943 | *ptype = debug_find_named_type (minfo->dhandle, "long double"); | |||
4944 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4945 | *ptype = debug_make_float_type (minfo->dhandle, 8); | |||
4946 | } | |||
4947 | ++*pp; | |||
4948 | break; | |||
4949 | ||||
4950 | case 'd': /* double */ | |||
4951 | if (ptype != NULL((void*)0)) | |||
4952 | { | |||
4953 | *ptype = debug_find_named_type (minfo->dhandle, "double"); | |||
4954 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4955 | *ptype = debug_make_float_type (minfo->dhandle, 8); | |||
4956 | } | |||
4957 | ++*pp; | |||
4958 | break; | |||
4959 | ||||
4960 | case 'f': /* float */ | |||
4961 | if (ptype != NULL((void*)0)) | |||
4962 | { | |||
4963 | *ptype = debug_find_named_type (minfo->dhandle, "float"); | |||
4964 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4965 | *ptype = debug_make_float_type (minfo->dhandle, 4); | |||
4966 | } | |||
4967 | ++*pp; | |||
4968 | break; | |||
4969 | ||||
4970 | case 'G': | |||
4971 | ++*pp; | |||
4972 | if (! ISDIGIT (**pp)(_sch_istable[(**pp) & 0xff] & (unsigned short)(_sch_isdigit ))) | |||
4973 | { | |||
4974 | stab_bad_demangle (orig); | |||
4975 | return FALSE0; | |||
4976 | } | |||
4977 | /* Fall through. */ | |||
4978 | case '0': case '1': case '2': case '3': case '4': | |||
4979 | case '5': case '6': case '7': case '8': case '9': | |||
4980 | { | |||
4981 | const char *hold; | |||
4982 | ||||
4983 | if (! stab_demangle_class (minfo, pp, &hold)) | |||
4984 | return FALSE0; | |||
4985 | if (ptype != NULL((void*)0)) | |||
4986 | { | |||
4987 | char *name; | |||
4988 | ||||
4989 | name = savestring (hold, *pp - hold); | |||
4990 | *ptype = debug_find_named_type (minfo->dhandle, name); | |||
4991 | free (name); | |||
4992 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
4993 | { | |||
4994 | /* FIXME: It is probably incorrect to assume that | |||
4995 | undefined types are tagged types. */ | |||
4996 | *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info, | |||
4997 | hold, *pp - hold, | |||
4998 | DEBUG_KIND_ILLEGAL); | |||
4999 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
5000 | return FALSE0; | |||
5001 | } | |||
5002 | } | |||
5003 | } | |||
5004 | break; | |||
5005 | ||||
5006 | case 't': | |||
5007 | { | |||
5008 | char *name; | |||
5009 | ||||
5010 | if (! stab_demangle_template (minfo, pp, | |||
5011 | ptype != NULL((void*)0) ? &name : NULL((void*)0))) | |||
5012 | return FALSE0; | |||
5013 | if (ptype != NULL((void*)0)) | |||
5014 | { | |||
5015 | *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info, | |||
5016 | name, strlen (name), | |||
5017 | DEBUG_KIND_CLASS); | |||
5018 | free (name); | |||
5019 | if (*ptype == DEBUG_TYPE_NULL((debug_type) ((void*)0))) | |||
5020 | return FALSE0; | |||
5021 | } | |||
5022 | } | |||
5023 | break; | |||
5024 | ||||
5025 | default: | |||
5026 | stab_bad_demangle (orig); | |||
5027 | return FALSE0; | |||
5028 | } | |||
5029 | ||||
5030 | if (ptype != NULL((void*)0)) | |||
5031 | { | |||
5032 | if (constp) | |||
5033 | *ptype = debug_make_const_type (minfo->dhandle, *ptype); | |||
5034 | if (volatilep) | |||
5035 | *ptype = debug_make_volatile_type (minfo->dhandle, *ptype); | |||
5036 | } | |||
5037 | ||||
5038 | return TRUE1; | |||
5039 | } | |||
5040 | ||||
5041 | /* Remember a type string in a demangled string. */ | |||
5042 | ||||
5043 | static bfd_boolean | |||
5044 | stab_demangle_remember_type (struct stab_demangle_info *minfo, | |||
5045 | const char *p, int len) | |||
5046 | { | |||
5047 | if (minfo->typestring_count >= minfo->typestring_alloc) | |||
5048 | { | |||
5049 | minfo->typestring_alloc += 10; | |||
5050 | minfo->typestrings = ((struct stab_demangle_typestring *) | |||
5051 | xrealloc (minfo->typestrings, | |||
5052 | (minfo->typestring_alloc | |||
5053 | * sizeof *minfo->typestrings))); | |||
5054 | } | |||
5055 | ||||
5056 | minfo->typestrings[minfo->typestring_count].typestring = p; | |||
5057 | minfo->typestrings[minfo->typestring_count].len = (unsigned int) len; | |||
5058 | ++minfo->typestring_count; | |||
5059 | ||||
5060 | return TRUE1; | |||
5061 | } | |||
5062 | ||||
5063 | /* Demangle names encoded using the g++ V3 ABI. The newer versions of | |||
5064 | g++ which use this ABI do not encode ordinary method argument types | |||
5065 | in a mangled name; they simply output the argument types. However, | |||
5066 | for a static method, g++ simply outputs the return type and the | |||
5067 | physical name. So in that case we need to demangle the name here. | |||
5068 | Here PHYSNAME is the physical name of the function, and we set the | |||
5069 | variable pointed at by PVARARGS to indicate whether this function | |||
5070 | is varargs. This returns NULL, or a NULL terminated array of | |||
5071 | argument types. */ | |||
5072 | ||||
5073 | static debug_type * | |||
5074 | stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info, | |||
5075 | const char *physname, bfd_boolean *pvarargs) | |||
5076 | { | |||
5077 | struct demangle_component *dc; | |||
5078 | void *mem; | |||
5079 | debug_type *pargs; | |||
5080 | ||||
5081 | dc = cplus_demangle_v3_components (physname, DMGL_PARAMS(1 << 0) | DMGL_ANSI(1 << 1), &mem); | |||
5082 | if (dc == NULL((void*)0)) | |||
5083 | { | |||
5084 | stab_bad_demangle (physname); | |||
5085 | return NULL((void*)0); | |||
5086 | } | |||
5087 | ||||
5088 | /* We expect to see TYPED_NAME, and the right subtree describes the | |||
5089 | function type. */ | |||
5090 | if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME | |||
5091 | || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) | |||
5092 | { | |||
5093 | fprintf (stderr(&__sF[2]), _("Demangled name is not a function\n")("Demangled name is not a function\n")); | |||
5094 | free (mem); | |||
5095 | return NULL((void*)0); | |||
5096 | } | |||
5097 | ||||
5098 | pargs = stab_demangle_v3_arglist (dhandle, info, | |||
5099 | dc->u.s_binary.right->u.s_binary.right, | |||
5100 | pvarargs); | |||
5101 | ||||
5102 | free (mem); | |||
5103 | ||||
5104 | return pargs; | |||
5105 | } | |||
5106 | ||||
5107 | /* Demangle an argument list in a struct demangle_component tree. | |||
5108 | Returns a DEBUG_TYPE_NULL terminated array of argument types, and | |||
5109 | sets *PVARARGS to indicate whether this is a varargs function. */ | |||
5110 | ||||
5111 | static debug_type * | |||
5112 | stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info, | |||
5113 | struct demangle_component *arglist, | |||
5114 | bfd_boolean *pvarargs) | |||
5115 | { | |||
5116 | struct demangle_component *dc; | |||
5117 | unsigned int alloc, count; | |||
5118 | debug_type *pargs; | |||
5119 | ||||
5120 | alloc = 10; | |||
5121 | pargs = (debug_type *) xmalloc (alloc * sizeof *pargs); | |||
5122 | *pvarargs = FALSE0; | |||
5123 | ||||
5124 | count = 0; | |||
5125 | ||||
5126 | for (dc = arglist; | |||
5127 | dc != NULL((void*)0); | |||
5128 | dc = dc->u.s_binary.right) | |||
5129 | { | |||
5130 | debug_type arg; | |||
5131 | bfd_boolean varargs; | |||
5132 | ||||
5133 | if (dc->type != DEMANGLE_COMPONENT_ARGLIST) | |||
5134 | { | |||
5135 | fprintf (stderr(&__sF[2]), _("Unexpected type in v3 arglist demangling\n")("Unexpected type in v3 arglist demangling\n")); | |||
5136 | free (pargs); | |||
5137 | return NULL((void*)0); | |||
5138 | } | |||
5139 | ||||
5140 | arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, | |||
5141 | NULL((void*)0), &varargs); | |||
5142 | if (arg == NULL((void*)0)) | |||
5143 | { | |||
5144 | if (varargs) | |||
5145 | { | |||
5146 | *pvarargs = TRUE1; | |||
5147 | continue; | |||
5148 | } | |||
5149 | free (pargs); | |||
5150 | return NULL((void*)0); | |||
5151 | } | |||
5152 | ||||
5153 | if (count + 1 >= alloc) | |||
5154 | { | |||
5155 | alloc += 10; | |||
5156 | pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs); | |||
5157 | } | |||
5158 | ||||
5159 | pargs[count] = arg; | |||
5160 | ++count; | |||
5161 | } | |||
5162 | ||||
5163 | pargs[count] = DEBUG_TYPE_NULL((debug_type) ((void*)0)); | |||
5164 | ||||
5165 | return pargs; | |||
5166 | } | |||
5167 | ||||
5168 | /* Convert a struct demangle_component tree describing an argument | |||
5169 | type into a debug_type. */ | |||
5170 | ||||
5171 | static debug_type | |||
5172 | stab_demangle_v3_arg (void *dhandle, struct stab_handle *info, | |||
5173 | struct demangle_component *dc, debug_type context, | |||
5174 | bfd_boolean *pvarargs) | |||
5175 | { | |||
5176 | debug_type dt; | |||
5177 | ||||
5178 | if (pvarargs != NULL((void*)0)) | |||
5179 | *pvarargs = FALSE0; | |||
5180 | ||||
5181 | switch (dc->type) | |||
5182 | { | |||
5183 | /* FIXME: These are demangle component types which we probably | |||
5184 | need to handle one way or another. */ | |||
5185 | case DEMANGLE_COMPONENT_LOCAL_NAME: | |||
5186 | case DEMANGLE_COMPONENT_TYPED_NAME: | |||
5187 | case DEMANGLE_COMPONENT_TEMPLATE_PARAM: | |||
5188 | case DEMANGLE_COMPONENT_CTOR: | |||
5189 | case DEMANGLE_COMPONENT_DTOR: | |||
5190 | case DEMANGLE_COMPONENT_JAVA_CLASS: | |||
5191 | case DEMANGLE_COMPONENT_RESTRICT_THIS: | |||
5192 | case DEMANGLE_COMPONENT_VOLATILE_THIS: | |||
5193 | case DEMANGLE_COMPONENT_CONST_THIS: | |||
5194 | case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: | |||
5195 | case DEMANGLE_COMPONENT_COMPLEX: | |||
5196 | case DEMANGLE_COMPONENT_IMAGINARY: | |||
5197 | case DEMANGLE_COMPONENT_VENDOR_TYPE: | |||
5198 | case DEMANGLE_COMPONENT_ARRAY_TYPE: | |||
5199 | case DEMANGLE_COMPONENT_PTRMEM_TYPE: | |||
5200 | case DEMANGLE_COMPONENT_ARGLIST: | |||
5201 | default: | |||
5202 | fprintf (stderr(&__sF[2]), _("Unrecognized demangle component %d\n")("Unrecognized demangle component %d\n"), | |||
5203 | (int) dc->type); | |||
5204 | return NULL((void*)0); | |||
5205 | ||||
5206 | case DEMANGLE_COMPONENT_NAME: | |||
5207 | if (context != NULL((void*)0)) | |||
5208 | { | |||
5209 | const debug_field *fields; | |||
5210 | ||||
5211 | fields = debug_get_fields (dhandle, context); | |||
5212 | if (fields != NULL((void*)0)) | |||
5213 | { | |||
5214 | /* Try to find this type by looking through the context | |||
5215 | class. */ | |||
5216 | for (; *fields != DEBUG_FIELD_NULL((debug_field) ((void*)0)); fields++) | |||
5217 | { | |||
5218 | debug_type ft; | |||
5219 | const char *dn; | |||
5220 | ||||
5221 | ft = debug_get_field_type (dhandle, *fields); | |||
5222 | if (ft == NULL((void*)0)) | |||
5223 | return NULL((void*)0); | |||
5224 | dn = debug_get_type_name (dhandle, ft); | |||
5225 | if (dn != NULL((void*)0) | |||
5226 | && (int) strlen (dn) == dc->u.s_name.len | |||
5227 | && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0) | |||
5228 | return ft; | |||
5229 | } | |||
5230 | } | |||
5231 | } | |||
5232 | return stab_find_tagged_type (dhandle, info, dc->u.s_name.s, | |||
5233 | dc->u.s_name.len, DEBUG_KIND_ILLEGAL); | |||
5234 | ||||
5235 | case DEMANGLE_COMPONENT_QUAL_NAME: | |||
5236 | context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, | |||
5237 | context, NULL((void*)0)); | |||
5238 | if (context == NULL((void*)0)) | |||
5239 | return NULL((void*)0); | |||
5240 | return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right, | |||
5241 | context, NULL((void*)0)); | |||
5242 | ||||
5243 | case DEMANGLE_COMPONENT_TEMPLATE: | |||
5244 | { | |||
5245 | char *p; | |||
5246 | size_t alc; | |||
5247 | ||||
5248 | /* We print this component to get a class name which we can | |||
5249 | use. FIXME: This probably won't work if the template uses | |||
5250 | template parameters which refer to an outer template. */ | |||
5251 | p = cplus_demangle_print (DMGL_PARAMS(1 << 0) | DMGL_ANSI(1 << 1), dc, 20, &alc); | |||
5252 | if (p == NULL((void*)0)) | |||
5253 | { | |||
5254 | fprintf (stderr(&__sF[2]), _("Failed to print demangled template\n")("Failed to print demangled template\n")); | |||
5255 | return NULL((void*)0); | |||
5256 | } | |||
5257 | dt = stab_find_tagged_type (dhandle, info, p, strlen (p), | |||
5258 | DEBUG_KIND_CLASS); | |||
5259 | free (p); | |||
5260 | return dt; | |||
5261 | } | |||
5262 | ||||
5263 | case DEMANGLE_COMPONENT_SUB_STD: | |||
5264 | return stab_find_tagged_type (dhandle, info, dc->u.s_string.string, | |||
5265 | dc->u.s_string.len, DEBUG_KIND_ILLEGAL); | |||
5266 | ||||
5267 | case DEMANGLE_COMPONENT_RESTRICT: | |||
5268 | case DEMANGLE_COMPONENT_VOLATILE: | |||
5269 | case DEMANGLE_COMPONENT_CONST: | |||
5270 | case DEMANGLE_COMPONENT_POINTER: | |||
5271 | case DEMANGLE_COMPONENT_REFERENCE: | |||
5272 | dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL((void*)0), | |||
5273 | NULL((void*)0)); | |||
5274 | if (dt == NULL((void*)0)) | |||
5275 | return NULL((void*)0); | |||
5276 | ||||
5277 | switch (dc->type) | |||
5278 | { | |||
5279 | default: | |||
5280 | abort (); | |||
5281 | case DEMANGLE_COMPONENT_RESTRICT: | |||
5282 | /* FIXME: We have no way to represent restrict. */ | |||
5283 | return dt; | |||
5284 | case DEMANGLE_COMPONENT_VOLATILE: | |||
5285 | return debug_make_volatile_type (dhandle, dt); | |||
5286 | case DEMANGLE_COMPONENT_CONST: | |||
5287 | return debug_make_const_type (dhandle, dt); | |||
5288 | case DEMANGLE_COMPONENT_POINTER: | |||
5289 | return debug_make_pointer_type (dhandle, dt); | |||
5290 | case DEMANGLE_COMPONENT_REFERENCE: | |||
5291 | return debug_make_reference_type (dhandle, dt); | |||
5292 | } | |||
5293 | ||||
5294 | case DEMANGLE_COMPONENT_FUNCTION_TYPE: | |||
5295 | { | |||
5296 | debug_type *pargs; | |||
5297 | bfd_boolean varargs; | |||
5298 | ||||
5299 | if (dc->u.s_binary.left == NULL((void*)0)) | |||
5300 | { | |||
5301 | /* In this case the return type is actually unknown. | |||
5302 | However, I'm not sure this will ever arise in practice; | |||
5303 | normally an unknown return type would only appear at | |||
5304 | the top level, which is handled above. */ | |||
5305 | dt = debug_make_void_type (dhandle); | |||
5306 | } | |||
5307 | else | |||
5308 | dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL((void*)0), | |||
5309 | NULL((void*)0)); | |||
5310 | if (dt == NULL((void*)0)) | |||
5311 | return NULL((void*)0); | |||
5312 | ||||
5313 | pargs = stab_demangle_v3_arglist (dhandle, info, | |||
5314 | dc->u.s_binary.right, | |||
5315 | &varargs); | |||
5316 | if (pargs == NULL((void*)0)) | |||
5317 | return NULL((void*)0); | |||
5318 | ||||
5319 | return debug_make_function_type (dhandle, dt, pargs, varargs); | |||
5320 | } | |||
5321 | ||||
5322 | case DEMANGLE_COMPONENT_BUILTIN_TYPE: | |||
5323 | { | |||
5324 | char *p; | |||
5325 | size_t alc; | |||
5326 | debug_type ret; | |||
5327 | ||||
5328 | /* We print this component in order to find out the type name. | |||
5329 | FIXME: Should we instead expose the | |||
5330 | demangle_builtin_type_info structure? */ | |||
5331 | p = cplus_demangle_print (DMGL_PARAMS(1 << 0) | DMGL_ANSI(1 << 1), dc, 20, &alc); | |||
5332 | if (p == NULL((void*)0)) | |||
5333 | { | |||
5334 | fprintf (stderr(&__sF[2]), _("Couldn't get demangled builtin type\n")("Couldn't get demangled builtin type\n")); | |||
5335 | return NULL((void*)0); | |||
5336 | } | |||
5337 | ||||
5338 | /* The mangling is based on the type, but does not itself | |||
5339 | indicate what the sizes are. So we have to guess. */ | |||
5340 | if (strcmp (p, "signed char") == 0) | |||
5341 | ret = debug_make_int_type (dhandle, 1, FALSE0); | |||
5342 | else if (strcmp (p, "bool") == 0) | |||
5343 | ret = debug_make_bool_type (dhandle, 1); | |||
5344 | else if (strcmp (p, "char") == 0) | |||
5345 | ret = debug_make_int_type (dhandle, 1, FALSE0); | |||
5346 | else if (strcmp (p, "double") == 0) | |||
5347 | ret = debug_make_float_type (dhandle, 8); | |||
5348 | else if (strcmp (p, "long double") == 0) | |||
5349 | ret = debug_make_float_type (dhandle, 8); | |||
5350 | else if (strcmp (p, "float") == 0) | |||
5351 | ret = debug_make_float_type (dhandle, 4); | |||
5352 | else if (strcmp (p, "__float128") == 0) | |||
5353 | ret = debug_make_float_type (dhandle, 16); | |||
5354 | else if (strcmp (p, "unsigned char") == 0) | |||
5355 | ret = debug_make_int_type (dhandle, 1, TRUE1); | |||
5356 | else if (strcmp (p, "int") == 0) | |||
5357 | ret = debug_make_int_type (dhandle, 4, FALSE0); | |||
5358 | else if (strcmp (p, "unsigned int") == 0) | |||
5359 | ret = debug_make_int_type (dhandle, 4, TRUE1); | |||
5360 | else if (strcmp (p, "long") == 0) | |||
5361 | ret = debug_make_int_type (dhandle, 4, FALSE0); | |||
5362 | else if (strcmp (p, "unsigned long") == 0) | |||
5363 | ret = debug_make_int_type (dhandle, 4, TRUE1); | |||
5364 | else if (strcmp (p, "__int128") == 0) | |||
5365 | ret = debug_make_int_type (dhandle, 16, FALSE0); | |||
5366 | else if (strcmp (p, "unsigned __int128") == 0) | |||
5367 | ret = debug_make_int_type (dhandle, 16, TRUE1); | |||
5368 | else if (strcmp (p, "short") == 0) | |||
5369 | ret = debug_make_int_type (dhandle, 2, FALSE0); | |||
5370 | else if (strcmp (p, "unsigned short") == 0) | |||
5371 | ret = debug_make_int_type (dhandle, 2, TRUE1); | |||
5372 | else if (strcmp (p, "void") == 0) | |||
5373 | ret = debug_make_void_type (dhandle); | |||
5374 | else if (strcmp (p, "wchar_t") == 0) | |||
5375 | ret = debug_make_int_type (dhandle, 4, TRUE1); | |||
5376 | else if (strcmp (p, "long long") == 0) | |||
5377 | ret = debug_make_int_type (dhandle, 8, FALSE0); | |||
5378 | else if (strcmp (p, "unsigned long long") == 0) | |||
5379 | ret = debug_make_int_type (dhandle, 8, TRUE1); | |||
5380 | else if (strcmp (p, "...") == 0) | |||
5381 | { | |||
5382 | if (pvarargs == NULL((void*)0)) | |||
5383 | fprintf (stderr(&__sF[2]), _("Unexpected demangled varargs\n")("Unexpected demangled varargs\n")); | |||
5384 | else | |||
5385 | *pvarargs = TRUE1; | |||
5386 | ret = NULL((void*)0); | |||
5387 | } | |||
5388 | else | |||
5389 | { | |||
5390 | fprintf (stderr(&__sF[2]), _("Unrecognized demangled builtin type\n")("Unrecognized demangled builtin type\n")); | |||
5391 | ret = NULL((void*)0); | |||
5392 | } | |||
5393 | ||||
5394 | free (p); | |||
5395 | ||||
5396 | return ret; | |||
5397 | } | |||
5398 | } | |||
5399 | } |