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