daily update
[binutils.git] / binutils / stabs.c
blobea0a61e411890378de2fa39f115846dd7bc95956
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>.
6 This file is part of GNU Binutils.
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.
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.
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. */
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. */
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"
39 /* The number of predefined XCOFF types. */
41 #define XCOFF_TYPE_COUNT 34
43 /* This structure is used as a handle so that the stab parsing doesn't
44 need to use any static variables. */
46 struct stab_handle
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;
101 /* A list of these structures is used to hold pending variable
102 definitions seen before the N_LBRAC of a block. */
104 struct stab_pending_var
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;
118 /* A list of these structures is used to hold the types for a single
119 file. */
121 struct stab_types
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];
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. */
133 struct stab_tag
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;
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 *);
210 /* Save a string in memory. */
212 static char *
213 savestring (const char *start, int len)
215 char *ret;
217 ret = (char *) xmalloc (len + 1);
218 memcpy (ret, start, len);
219 ret[len] = '\0';
220 return ret;
223 /* Read a number from a string. */
225 static bfd_vma
226 parse_number (const char **pp, bfd_boolean *poverflow)
228 unsigned long ul;
229 const char *orig;
231 if (poverflow != NULL)
232 *poverflow = FALSE;
234 orig = *pp;
236 errno = 0;
237 ul = strtoul (*pp, (char **) pp, 0);
238 if (ul + 1 != 0 || errno == 0)
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;
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))
252 const char *p;
253 bfd_boolean neg;
254 int base;
255 bfd_vma over, lastdig;
256 bfd_boolean overflow;
257 bfd_vma v;
259 /* Our own version of strtoul, for a bfd_vma. */
260 p = orig;
262 neg = FALSE;
263 if (*p == '+')
264 ++p;
265 else if (*p == '-')
267 neg = TRUE;
268 ++p;
271 base = 10;
272 if (*p == '0')
274 if (p[1] == 'x' || p[1] == 'X')
276 base = 16;
277 p += 2;
279 else
281 base = 8;
282 ++p;
286 over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
287 lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
289 overflow = FALSE;
290 v = 0;
291 while (1)
293 int d;
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;
305 if (d >= base)
306 break;
308 if (v > over || (v == over && (bfd_vma) d > lastdig))
310 overflow = TRUE;
311 break;
315 if (! overflow)
317 if (neg)
318 v = - v;
319 return v;
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"));
330 return 0;
333 /* Give an error for a bad stab string. */
335 static void
336 bad_stab (const char *p)
338 fprintf (stderr, _("Bad stab: %s\n"), p);
341 /* Warn about something in a stab string. */
343 static void
344 warn_stab (const char *p, const char *err)
346 fprintf (stderr, _("Warning: %s: %s\n"), err, p);
349 /* Create a handle to parse stabs symbols with. */
351 void *
352 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
353 asymbol **syms, long symcount)
355 struct stab_handle *ret;
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;
370 /* When we have processed all the stabs information, we need to go
371 through and fill in all the undefined tags. */
373 bfd_boolean
374 finish_stab (void *dhandle, void *handle)
376 struct stab_handle *info = (struct stab_handle *) handle;
377 struct stab_tag *st;
379 if (info->within_function)
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;
388 for (st = info->tags; st != NULL; st = st->next)
390 enum debug_type_kind kind;
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;
400 return TRUE;
403 /* Handle a single stabs symbol. */
405 bfd_boolean
406 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
407 const char *string)
409 struct stab_handle *info = (struct stab_handle *) handle;
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))
418 if (! debug_set_filename (dhandle, info->so_string))
419 return FALSE;
420 info->main_filename = info->so_string;
422 info->gcc_compiled = 0;
423 info->n_opt_found = FALSE;
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;
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;
438 info->so_string = NULL;
440 /* Now process whatever type we just got. */
443 switch (type)
445 case N_FN:
446 case N_FN_SEQ:
447 break;
449 case N_LBRAC:
450 /* Ignore extra outermost context from SunPRO cc and acc. */
451 if (info->n_opt_found && desc == 1)
452 break;
454 if (! info->within_function)
456 fprintf (stderr, _("N_LBRAC not within function\n"));
457 return FALSE;
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;
467 /* Emit any pending variable definitions. */
468 if (! stab_emit_pending_vars (dhandle, info))
469 return FALSE;
471 ++info->block_depth;
472 break;
474 case N_RBRAC:
475 /* Ignore extra outermost context from SunPRO cc and acc. */
476 if (info->n_opt_found && desc == 1)
477 break;
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;
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;
492 --info->block_depth;
493 if (info->block_depth < 0)
495 fprintf (stderr, _("Too many N_RBRACs\n"));
496 return FALSE;
498 break;
500 case N_SO:
501 /* This always ends a function. */
502 if (info->within_function)
504 bfd_vma endval;
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;
518 /* An empty string is emitted by gcc at the end of a compilation
519 unit. */
520 if (*string == '\0')
521 return TRUE;
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
531 char *f;
533 f = info->so_string;
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);
543 info->so_value = value;
545 break;
547 case N_SOL:
548 /* Start an include file. */
549 if (! debug_start_source (dhandle, string))
550 return FALSE;
551 break;
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;
560 case N_EINCL:
561 /* End an N_BINCL include. */
562 if (! debug_start_source (dhandle, pop_bincl (info)))
563 return FALSE;
564 break;
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;
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;
580 case N_BCOMM:
581 if (! debug_start_common_block (dhandle, string))
582 return FALSE;
583 break;
585 case N_ECOMM:
586 if (! debug_end_common_block (dhandle, string))
587 return FALSE;
588 break;
590 case N_FUN:
591 if (*string == '\0')
593 if (info->within_function)
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;
605 break;
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;
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:
626 const char *colon;
628 colon = strchr (string, ':');
629 if (colon != NULL
630 && (colon[1] == 'f' || colon[1] == 'F'))
632 if (info->within_function)
634 bfd_vma endval;
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;
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;
652 if (! parse_stab_string (dhandle, info, type, desc, value, string))
653 return FALSE;
655 break;
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;
666 case N_OBJ:
667 case N_ENDM:
668 case N_MAIN:
669 case N_WARNING:
670 break;
673 return TRUE;
676 /* Parse the stabs string. */
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)
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;
691 p = strchr (string, ':');
692 if (p == NULL)
693 return TRUE;
695 while (p[1] == ':')
697 p += 2;
698 p = strchr (p, ':');
699 if (p == NULL)
701 bad_stab (string);
702 return FALSE;
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;
714 /* FIXME: Sometimes the special C++ names start with '.'. */
715 name = NULL;
716 if (string[0] == '$')
718 switch (string[1])
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;
741 if (name == NULL)
743 if (p == string || (string[0] == ' ' && p == string + 1))
744 name = NULL;
745 else
746 name = savestring (string, p - string);
749 ++p;
750 if (ISDIGIT (*p) || *p == '(' || *p == '-')
751 type = 'l';
752 else
753 type = *p++;
755 switch (type)
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 != '=')
766 bad_stab (string);
767 return FALSE;
769 ++p;
770 switch (*p++)
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 != ',')
799 bad_stab (string);
800 return FALSE;
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;
810 break;
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;
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;
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 == ';')
838 ++p;
839 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
840 (debug_type **) NULL)
841 == DEBUG_TYPE_NULL)
842 return FALSE;
845 break;
847 case 'G':
849 char leading;
850 long c;
851 asymbol **ps;
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)
862 const char *n;
864 n = bfd_asymbol_name (*ps);
865 if (leading != '\0' && *n == leading)
866 ++n;
867 if (*n == *name && strcmp (n, name) == 0)
868 break;
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;
876 break;
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;
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
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)
907 debug_type ftype;
909 ftype = debug_make_function_type (dhandle, dtype,
910 (debug_type *) NULL, FALSE);
911 dtype = debug_make_pointer_type (dhandle, ftype);
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;
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;
926 case 'P':
927 if (stabtype == N_FUN)
929 /* Prototype of a function referenced by this file. */
930 while (*p == ';')
932 ++p;
933 if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
934 (debug_type **) NULL)
935 == DEBUG_TYPE_NULL)
936 return FALSE;
938 break;
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;
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;
962 /* FIXME: At this point gdb checks to combine pairs of 'p' and
963 'r' stabs into a single 'P' stab. */
964 break;
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;
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)
984 /* A nameless type. Nothing to do. */
985 return TRUE;
988 dtype = debug_name_type (dhandle, name, dtype);
989 if (dtype == DEBUG_TYPE_NULL)
990 return FALSE;
992 if (slot != NULL)
993 *slot = dtype;
995 break;
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')
1002 synonym = FALSE;
1003 /* FIXME: gdb sets synonym to TRUE if the current language
1004 is C++. */
1006 else
1008 synonym = TRUE;
1009 ++p;
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;
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;
1023 dtype = debug_tag_type (dhandle, name, dtype);
1024 if (dtype == DEBUG_TYPE_NULL)
1025 return FALSE;
1026 if (slot != NULL)
1027 *slot = dtype;
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)
1034 register struct stab_tag **pst;
1036 for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1038 if ((*pst)->name[0] == name[0]
1039 && strcmp ((*pst)->name, name) == 0)
1041 (*pst)->slot = dtype;
1042 *pst = (*pst)->next;
1043 break;
1048 if (synonym)
1050 dtype = debug_name_type (dhandle, name, dtype);
1051 if (dtype == DEBUG_TYPE_NULL)
1052 return FALSE;
1054 if (slot != NULL)
1055 *slot = dtype;
1058 break;
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;
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;
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;
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;
1108 default:
1109 bad_stab (string);
1110 return FALSE;
1113 /* FIXME: gdb converts structure values to structure pointers in a
1114 couple of cases, depending upon the target. */
1116 return TRUE;
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. */
1124 static debug_type
1125 parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp)
1127 const char *orig;
1128 int typenums[2];
1129 int size;
1130 bfd_boolean stringp;
1131 int descriptor;
1132 debug_type dtype;
1134 if (slotp != NULL)
1135 *slotp = NULL;
1137 orig = *pp;
1139 size = -1;
1140 stringp = FALSE;
1142 info->self_crossref = FALSE;
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 != '-')
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;
1153 else
1155 if (! parse_stab_type_number (pp, typenums))
1156 return DEBUG_TYPE_NULL;
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);
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);
1179 /* Type is being defined here. */
1180 /* Skip the '='. */
1181 ++*pp;
1183 while (**pp == '@')
1185 const char *p = *pp + 1;
1186 const char *attr;
1188 if (ISDIGIT (*p) || *p == '(' || *p == '-')
1189 /* Member type. */
1190 break;
1192 /* Type attributes. */
1193 attr = p;
1195 for (; *p != ';'; ++p)
1197 if (*p == '\0')
1199 bad_stab (orig);
1200 return DEBUG_TYPE_NULL;
1203 *pp = p + 1;
1205 switch (*attr)
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;
1214 case 'S':
1215 stringp = TRUE;
1216 break;
1218 default:
1219 /* Ignore unrecognized type attributes, so future
1220 compilers can invent new ones. */
1221 break;
1226 descriptor = **pp;
1227 ++*pp;
1229 switch (descriptor)
1231 case 'x':
1233 enum debug_type_kind code;
1234 const char *q1, *q2, *p;
1236 /* A cross reference to another type. */
1237 switch (**pp)
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;
1255 ++*pp;
1257 q1 = strchr (*pp, '<');
1258 p = strchr (*pp, ':');
1259 if (p == NULL)
1261 bad_stab (orig);
1262 return DEBUG_TYPE_NULL;
1264 if (q1 != NULL && p > q1 && p[1] == ':')
1266 int nest = 0;
1268 for (q2 = q1; *q2 != '\0'; ++q2)
1270 if (*q2 == '<')
1271 ++nest;
1272 else if (*q2 == '>')
1273 --nest;
1274 else if (*q2 == ':' && nest == 0)
1275 break;
1277 p = q2;
1278 if (*p != ':')
1280 bad_stab (orig);
1281 return DEBUG_TYPE_NULL;
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;
1294 dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1296 *pp = p + 1;
1298 break;
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 '(':
1313 const char *hold;
1314 int xtypenums[2];
1316 /* This type is defined as another type. */
1317 (*pp)--;
1318 hold = *pp;
1320 /* Peek ahead at the number to detect void. */
1321 if (! parse_stab_type_number (pp, xtypenums))
1322 return DEBUG_TYPE_NULL;
1324 if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1326 /* This type is being defined as itself, which means that
1327 it is void. */
1328 dtype = debug_make_void_type (dhandle);
1330 else
1332 *pp = hold;
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;
1343 if (typenums[0] != -1)
1345 if (! stab_record_type (dhandle, info, typenums, dtype))
1346 return DEBUG_TYPE_NULL;
1349 break;
1352 case '*':
1353 dtype = debug_make_pointer_type (dhandle,
1354 parse_stab_type (dhandle, info,
1355 (const char *) NULL,
1357 (debug_type **) NULL));
1358 break;
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;
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;
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,
1385 (debug_type **) NULL));
1386 break;
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;
1397 case '@':
1398 /* Offset (class & variable) type. This is used for a pointer
1399 relative to an object. */
1401 debug_type domain;
1402 debug_type memtype;
1404 /* Member type. */
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;
1411 if (**pp != ',')
1413 bad_stab (orig);
1414 return DEBUG_TYPE_NULL;
1416 ++*pp;
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;
1423 dtype = debug_make_offset_type (dhandle, domain, memtype);
1425 break;
1427 case '#':
1428 /* Method (class & fn) type. */
1429 if (**pp == '#')
1431 debug_type return_type;
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 != ';')
1440 bad_stab (orig);
1441 return DEBUG_TYPE_NULL;
1443 ++*pp;
1444 dtype = debug_make_method_type (dhandle, return_type,
1445 DEBUG_TYPE_NULL,
1446 (debug_type *) NULL, FALSE);
1448 else
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;
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;
1462 if (**pp != ',')
1464 bad_stab (orig);
1465 return DEBUG_TYPE_NULL;
1467 ++*pp;
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;
1474 alloc = 10;
1475 args = (debug_type *) xmalloc (alloc * sizeof *args);
1476 n = 0;
1477 while (**pp != ';')
1479 if (**pp != ',')
1481 bad_stab (orig);
1482 return DEBUG_TYPE_NULL;
1484 ++*pp;
1486 if (n + 1 >= alloc)
1488 alloc += 10;
1489 args = ((debug_type *)
1490 xrealloc (args, alloc * sizeof *args));
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;
1499 ++*pp;
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
1509 --n;
1510 varargs = FALSE;
1513 args[n] = DEBUG_TYPE_NULL;
1515 dtype = debug_make_method_type (dhandle, return_type, domain, args,
1516 varargs);
1518 break;
1520 case 'r':
1521 /* Range type. */
1522 dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums);
1523 break;
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;
1531 case 'R':
1532 /* Sun ACC builtin float type. */
1533 dtype = parse_stab_sun_floating_type (dhandle, pp);
1534 break;
1536 case 'e':
1537 /* Enumeration type. */
1538 dtype = parse_stab_enum_type (dhandle, pp);
1539 break;
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;
1548 case 'a':
1549 /* Array type. */
1550 if (**pp != 'r')
1552 bad_stab (orig);
1553 return DEBUG_TYPE_NULL;
1555 ++*pp;
1557 dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1558 break;
1560 case 'S':
1561 dtype = debug_make_set_type (dhandle,
1562 parse_stab_type (dhandle, info,
1563 (const char *) NULL,
1565 (debug_type **) NULL),
1566 stringp);
1567 break;
1569 default:
1570 bad_stab (orig);
1571 return DEBUG_TYPE_NULL;
1574 if (dtype == DEBUG_TYPE_NULL)
1575 return DEBUG_TYPE_NULL;
1577 if (typenums[0] != -1)
1579 if (! stab_record_type (dhandle, info, typenums, dtype))
1580 return DEBUG_TYPE_NULL;
1583 if (size != -1)
1585 if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1586 return DEBUG_TYPE_NULL;
1589 return dtype;
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. */
1597 static bfd_boolean
1598 parse_stab_type_number (const char **pp, int *typenums)
1600 const char *orig;
1602 orig = *pp;
1604 if (**pp != '(')
1606 typenums[0] = 0;
1607 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1609 else
1611 ++*pp;
1612 typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1613 if (**pp != ',')
1615 bad_stab (orig);
1616 return FALSE;
1618 ++*pp;
1619 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1620 if (**pp != ')')
1622 bad_stab (orig);
1623 return FALSE;
1625 ++*pp;
1628 return TRUE;
1631 /* Parse a range type. */
1633 static debug_type
1634 parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums)
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;
1644 orig = *pp;
1646 index_type = DEBUG_TYPE_NULL;
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;
1653 self_subrange = (rangenums[0] == typenums[0]
1654 && rangenums[1] == typenums[1]);
1656 if (**pp == '=')
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;
1665 if (**pp == ';')
1666 ++*pp;
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 != ';')
1674 bad_stab (orig);
1675 return DEBUG_TYPE_NULL;
1677 ++*pp;
1679 s3 = *pp;
1680 n3 = parse_number (pp, &ov3);
1681 if (**pp != ';')
1683 bad_stab (orig);
1684 return DEBUG_TYPE_NULL;
1686 ++*pp;
1688 if (ov2 || ov3)
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)
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);
1706 warn_stab (orig, _("numeric overflow"));
1709 if (index_type == DEBUG_TYPE_NULL)
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);
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);
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);
1726 /* If the upper bound is -1, this is an unsigned int. */
1727 if (n2 == 0 && n3 == -1)
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)
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);
1740 /* FIXME: The size here really depends upon the target. */
1741 return debug_make_int_type (dhandle, 4, TRUE);
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);
1748 /* FIXME: gdb checks for the language CHILL here. */
1750 if (n2 == 0)
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
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)
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
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)
1789 bad_stab (orig);
1790 return DEBUG_TYPE_NULL;
1793 index_type = stab_find_type (dhandle, info, rangenums);
1794 if (index_type == DEBUG_TYPE_NULL)
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);
1802 return debug_make_range_type (dhandle, index_type, n2, n3);
1805 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1806 typedefs in every file (for int, long, etc):
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.
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. */
1817 static debug_type
1818 parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1820 const char *orig;
1821 bfd_boolean unsignedp;
1822 bfd_vma bits;
1824 orig = *pp;
1826 switch (**pp)
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;
1838 ++*pp;
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;
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 != ';')
1854 bad_stab (orig);
1855 return DEBUG_TYPE_NULL;
1857 ++*pp;
1859 /* The second number is always 0, so ignore it too. */
1860 (void) parse_number (pp, (bfd_boolean *) NULL);
1861 if (**pp != ';')
1863 bad_stab (orig);
1864 return DEBUG_TYPE_NULL;
1866 ++*pp;
1868 /* The third number is the number of bits for this type. */
1869 bits = parse_number (pp, (bfd_boolean *) NULL);
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;
1880 if (bits == 0)
1881 return debug_make_void_type (dhandle);
1883 return debug_make_int_type (dhandle, bits / 8, unsignedp);
1886 /* Parse a builtin floating type generated by the Sun compiler. */
1888 static debug_type
1889 parse_stab_sun_floating_type (void *dhandle, const char **pp)
1891 const char *orig;
1892 bfd_vma details;
1893 bfd_vma bytes;
1895 orig = *pp;
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 != ';')
1902 bad_stab (orig);
1903 return DEBUG_TYPE_NULL;
1906 /* The second number is the number of bytes occupied by this type */
1907 bytes = parse_number (pp, (bfd_boolean *) NULL);
1908 if (**pp != ';')
1910 bad_stab (orig);
1911 return DEBUG_TYPE_NULL;
1914 if (details == NF_COMPLEX
1915 || details == NF_COMPLEX16
1916 || details == NF_COMPLEX32)
1917 return debug_make_complex_type (dhandle, bytes);
1919 return debug_make_float_type (dhandle, bytes);
1922 /* Handle an enum type. */
1924 static debug_type
1925 parse_stab_enum_type (void *dhandle, const char **pp)
1927 const char *orig;
1928 const char **names;
1929 bfd_signed_vma *values;
1930 unsigned int n;
1931 unsigned int alloc;
1933 orig = *pp;
1935 /* FIXME: gdb checks os9k_stabs here. */
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 == '-')
1941 while (**pp != ':')
1942 ++*pp;
1943 ++*pp;
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 != ',')
1955 const char *p;
1956 char *name;
1957 bfd_signed_vma val;
1959 p = *pp;
1960 while (*p != ':')
1961 ++p;
1963 name = savestring (*pp, p - *pp);
1965 *pp = p + 1;
1966 val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1967 if (**pp != ',')
1969 bad_stab (orig);
1970 return DEBUG_TYPE_NULL;
1972 ++*pp;
1974 if (n + 1 >= alloc)
1976 alloc += 10;
1977 names = ((const char **)
1978 xrealloc (names, alloc * sizeof *names));
1979 values = ((bfd_signed_vma *)
1980 xrealloc (values, alloc * sizeof *values));
1983 names[n] = name;
1984 values[n] = val;
1985 ++n;
1988 names[n] = NULL;
1989 values[n] = 0;
1991 if (**pp == ';')
1992 ++*pp;
1994 return debug_make_enum_type (dhandle, names, values);
1997 /* Read the description of a structure (or union type) and return an object
1998 describing the type.
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;;". */
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)
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;
2018 orig = *pp;
2020 /* Get the size. */
2021 size = parse_number (pp, (bfd_boolean *) NULL);
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;
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);
2038 return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2039 methods, vptrbase, ownvptr);
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.
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.
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 ____________________________________|
2064 Return TRUE for success, FALSE for failure. */
2066 static bfd_boolean
2067 parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2068 const char **pp, debug_baseclass **retp)
2070 const char *orig;
2071 unsigned int c, i;
2072 debug_baseclass *classes;
2074 *retp = NULL;
2076 orig = *pp;
2078 if (**pp != '!')
2080 /* No base classes. */
2081 return TRUE;
2083 ++*pp;
2085 c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2087 if (**pp != ',')
2089 bad_stab (orig);
2090 return FALSE;
2092 ++*pp;
2094 classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2096 for (i = 0; i < c; i++)
2098 bfd_boolean virtual;
2099 enum debug_visibility visibility;
2100 bfd_vma bitpos;
2101 debug_type type;
2103 switch (**pp)
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;
2116 ++*pp;
2118 switch (**pp)
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;
2134 ++*pp;
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 != ',')
2142 bad_stab (orig);
2143 return FALSE;
2145 ++*pp;
2147 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2148 (debug_type **) NULL);
2149 if (type == DEBUG_TYPE_NULL)
2150 return FALSE;
2152 classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual,
2153 visibility);
2154 if (classes[i] == DEBUG_BASECLASS_NULL)
2155 return FALSE;
2157 if (**pp != ';')
2158 return FALSE;
2159 ++*pp;
2162 classes[i] = DEBUG_BASECLASS_NULL;
2164 *retp = classes;
2166 return TRUE;
2169 /* Read struct or class data fields. They have the form:
2171 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2173 At the end, we see a semicolon instead of a field.
2175 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2176 a static field.
2178 The optional VISIBILITY is one of:
2180 '/0' (VISIBILITY_PRIVATE)
2181 '/1' (VISIBILITY_PROTECTED)
2182 '/2' (VISIBILITY_PUBLIC)
2183 '/9' (VISIBILITY_IGNORE)
2185 or nothing, for C style fields with public visibility.
2187 Returns 1 for success, 0 for failure. */
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)
2194 const char *orig;
2195 const char *p;
2196 debug_field *fields;
2197 unsigned int c;
2198 unsigned int alloc;
2200 *retp = NULL;
2201 *staticsp = FALSE;
2203 orig = *pp;
2205 c = 0;
2206 alloc = 10;
2207 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2208 while (**pp != ';')
2210 /* FIXME: gdb checks os9k_stabs here. */
2212 p = *pp;
2214 /* Add 1 to c to leave room for NULL pointer at end. */
2215 if (c + 1 >= alloc)
2217 alloc += 10;
2218 fields = ((debug_field *)
2219 xrealloc (fields, alloc * sizeof *fields));
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. */
2229 if ((*p == '$' || *p == '.') && p[1] != '_')
2231 ++*pp;
2232 if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2233 return FALSE;
2234 ++c;
2235 continue;
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. */
2243 p = strchr (p, ':');
2244 if (p == NULL)
2246 bad_stab (orig);
2247 return FALSE;
2250 if (p[1] == ':')
2251 break;
2253 if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2254 staticsp))
2255 return FALSE;
2257 ++c;
2260 fields[c] = DEBUG_FIELD_NULL;
2262 *retp = fields;
2264 return TRUE;
2267 /* Special GNU C++ name. */
2269 static bfd_boolean
2270 parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2271 const char **pp, debug_field *retp)
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;
2281 *retp = DEBUG_FIELD_NULL;
2283 orig = *pp;
2285 if (**pp != 'v')
2287 bad_stab (*pp);
2288 return FALSE;
2290 ++*pp;
2292 cpp_abbrev = **pp;
2293 ++*pp;
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. */
2300 context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2301 (debug_type **) NULL);
2302 if (context == DEBUG_TYPE_NULL)
2303 return FALSE;
2305 switch (cpp_abbrev)
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)
2316 warn_stab (orig, _("unnamed $vb type"));
2317 typename = "FOO";
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;
2327 if (**pp != ':')
2329 bad_stab (orig);
2330 return FALSE;
2332 ++*pp;
2334 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2335 (debug_type **) NULL);
2336 if (**pp != ',')
2338 bad_stab (orig);
2339 return FALSE;
2341 ++*pp;
2343 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2344 if (**pp != ';')
2346 bad_stab (orig);
2347 return FALSE;
2349 ++*pp;
2351 *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2352 DEBUG_VISIBILITY_PRIVATE);
2353 if (*retp == DEBUG_FIELD_NULL)
2354 return FALSE;
2356 return TRUE;
2359 /* Parse a single field in a struct or union. */
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)
2366 const char *orig;
2367 char *name;
2368 enum debug_visibility visibility;
2369 debug_type type;
2370 bfd_vma bitpos;
2371 bfd_vma bitsize;
2373 orig = *pp;
2375 /* FIXME: gdb checks ARM_DEMANGLING here. */
2377 name = savestring (*pp, p - *pp);
2379 *pp = p + 1;
2381 if (**pp != '/')
2382 visibility = DEBUG_VISIBILITY_PUBLIC;
2383 else
2385 ++*pp;
2386 switch (**pp)
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;
2402 ++*pp;
2405 type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2406 (debug_type **) NULL);
2407 if (type == DEBUG_TYPE_NULL)
2408 return FALSE;
2410 if (**pp == ':')
2412 char *varname;
2414 /* This is a static class member. */
2415 ++*pp;
2416 p = strchr (*pp, ';');
2417 if (p == NULL)
2419 bad_stab (orig);
2420 return FALSE;
2423 varname = savestring (*pp, p - *pp);
2425 *pp = p + 1;
2427 *retp = debug_make_static_member (dhandle, name, type, varname,
2428 visibility);
2429 *staticsp = TRUE;
2431 return TRUE;
2434 if (**pp != ',')
2436 bad_stab (orig);
2437 return FALSE;
2439 ++*pp;
2441 bitpos = parse_number (pp, (bfd_boolean *) NULL);
2442 if (**pp != ',')
2444 bad_stab (orig);
2445 return FALSE;
2447 ++*pp;
2449 bitsize = parse_number (pp, (bfd_boolean *) NULL);
2450 if (**pp != ';')
2452 bad_stab (orig);
2453 return FALSE;
2455 ++*pp;
2457 if (bitpos == 0 && bitsize == 0)
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.
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;
2475 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2477 *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2479 return TRUE;
2482 /* Read member function stabs info for C++ classes. The form of each member
2483 function data is:
2485 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2487 An example with two member functions is:
2489 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
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. */
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)
2500 const char *orig;
2501 debug_method *methods;
2502 unsigned int c;
2503 unsigned int alloc;
2505 *retp = NULL;
2507 orig = *pp;
2509 alloc = 0;
2510 methods = NULL;
2511 c = 0;
2513 while (**pp != ';')
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;
2522 p = strchr (*pp, ':');
2523 if (p == NULL || p[1] != ':')
2524 break;
2526 /* FIXME: Some systems use something other than '$' here. */
2527 if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2529 name = savestring (*pp, p - *pp);
2530 *pp = p + 2;
2532 else
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++)
2543 if (*p != '.')
2545 bad_stab (orig);
2546 return FALSE;
2548 name = savestring (*pp, p - *pp);
2549 *pp = p + 1;
2552 allocvars = 10;
2553 variants = ((debug_method_variant *)
2554 xmalloc (allocvars * sizeof *variants));
2555 cvars = 0;
2557 look_ahead_type = DEBUG_TYPE_NULL;
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;
2571 if (look_ahead_type != DEBUG_TYPE_NULL)
2573 /* g++ version 1 kludge */
2574 type = look_ahead_type;
2575 look_ahead_type = DEBUG_TYPE_NULL;
2577 else
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 != ':')
2585 bad_stab (orig);
2586 return FALSE;
2590 ++*pp;
2591 p = strchr (*pp, ';');
2592 if (p == NULL)
2594 bad_stab (orig);
2595 return FALSE;
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;
2603 argtypes = savestring (*pp, p - *pp);
2604 *pp = p + 1;
2606 switch (**pp)
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;
2618 ++*pp;
2620 constp = FALSE;
2621 volatilep = FALSE;
2622 switch (**pp)
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;
2654 staticp = FALSE;
2655 switch (**pp)
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 != ';')
2665 bad_stab (orig);
2666 return FALSE;
2668 ++*pp;
2669 voffset &= 0x7fffffff;
2671 if (**pp == ';' || *pp == '\0')
2673 /* Must be g++ version 1. */
2674 context = DEBUG_TYPE_NULL;
2676 else
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,
2684 (debug_type **) NULL);
2685 if (**pp == ':')
2687 /* g++ version 1 overloaded methods. */
2688 context = DEBUG_TYPE_NULL;
2690 else
2692 context = look_ahead_type;
2693 look_ahead_type = DEBUG_TYPE_NULL;
2694 if (**pp != ';')
2696 bad_stab (orig);
2697 return FALSE;
2699 ++*pp;
2702 break;
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;
2714 default:
2715 warn_stab (orig, "member function type missing");
2716 voffset = 0;
2717 context = DEBUG_TYPE_NULL;
2718 break;
2720 case '.':
2721 ++*pp;
2722 voffset = 0;
2723 context = DEBUG_TYPE_NULL;
2724 break;
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
2736 debug_type class_type, return_type;
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)
2744 bad_stab (orig);
2745 return FALSE;
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;
2754 if (cvars + 1 >= allocvars)
2756 allocvars += 10;
2757 variants = ((debug_method_variant *)
2758 xrealloc (variants,
2759 allocvars * sizeof *variants));
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;
2777 ++cvars;
2779 while (**pp != ';' && **pp != '\0');
2781 variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2783 if (**pp != '\0')
2784 ++*pp;
2786 if (c + 1 >= alloc)
2788 alloc += 10;
2789 methods = ((debug_method *)
2790 xrealloc (methods, alloc * sizeof *methods));
2793 methods[c] = debug_make_method (dhandle, name, variants);
2795 ++c;
2798 if (methods != NULL)
2799 methods[c] = DEBUG_METHOD_NULL;
2801 *retp = methods;
2803 return TRUE;
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. */
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)
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;
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"));
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';
2844 if (is_destructor || is_full_physname_constructor || is_v3)
2845 *pphysname = argtypes;
2846 else
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;
2855 len = tagname == NULL ? 0 : strlen (tagname);
2856 const_prefix = constp ? "C" : "";
2857 volatile_prefix = volatilep ? "V" : "";
2859 if (len == 0)
2860 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2861 else if (tagname != NULL && strchr (tagname, '<') != NULL)
2863 /* Template methods are fully mangled. */
2864 sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2865 tagname = NULL;
2866 len = 0;
2868 else
2869 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2871 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2872 + strlen (buf)
2873 + len
2874 + strlen (argtypes)
2875 + 1);
2877 if (fieldname[0] == 'o'
2878 && fieldname[1] == 'p'
2879 && (fieldname[2] == '$' || fieldname[2] == '.'))
2881 const char *opname;
2883 opname = cplus_mangle_opname (fieldname + 3, 0);
2884 if (opname == NULL)
2886 fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2887 return DEBUG_TYPE_NULL;
2889 mangled_name_len += strlen (opname);
2890 physname = (char *) xmalloc (mangled_name_len);
2891 strncpy (physname, fieldname, 3);
2892 strcpy (physname + 3, opname);
2894 else
2896 physname = (char *) xmalloc (mangled_name_len);
2897 if (is_constructor)
2898 physname[0] = '\0';
2899 else
2900 strcpy (physname, fieldname);
2903 physname_len = strlen (physname);
2904 strcat (physname, buf);
2905 if (tagname != NULL)
2906 strcat (physname, tagname);
2907 strcat (physname, argtypes);
2909 *pphysname = physname;
2912 if (*argtypes == '\0' || is_destructor)
2914 args = (debug_type *) xmalloc (sizeof *args);
2915 *args = NULL;
2916 return debug_make_method_type (dhandle, return_type, class_type, args,
2917 FALSE);
2920 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2921 if (args == NULL)
2922 return DEBUG_TYPE_NULL;
2924 return debug_make_method_type (dhandle, return_type, class_type, args,
2925 varargs);
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.
2933 This function is called when we have parsed all the method declarations,
2934 so we can look for the vptr base class info. */
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)
2941 const char *orig;
2942 const char *hold;
2943 int vtypenums[2];
2945 *retvptrbase = DEBUG_TYPE_NULL;
2946 *retownvptr = FALSE;
2948 orig = *pp;
2950 /* If we are positioned at a ';', then skip it. */
2951 if (**pp == ';')
2952 ++*pp;
2954 if (**pp != '~')
2955 return TRUE;
2957 ++*pp;
2959 if (**pp == '=' || **pp == '+' || **pp == '-')
2961 /* Obsolete flags that used to indicate the presence of
2962 constructors and/or destructors. */
2963 ++*pp;
2966 if (**pp != '%')
2967 return TRUE;
2969 ++*pp;
2971 hold = *pp;
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;
2978 if (vtypenums[0] == typenums[0]
2979 && vtypenums[1] == typenums[1])
2980 *retownvptr = TRUE;
2981 else
2983 debug_type vtype;
2984 const char *p;
2986 *pp = hold;
2988 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2989 (debug_type **) NULL);
2990 for (p = *pp; *p != ';' && *p != '\0'; p++)
2992 if (*p != ';')
2994 bad_stab (orig);
2995 return FALSE;
2998 *retvptrbase = vtype;
3000 *pp = p + 1;
3003 return TRUE;
3006 /* Read a definition of an array type. */
3008 static debug_type
3009 parse_stab_array_type (void *dhandle, struct stab_handle *info,
3010 const char **pp, bfd_boolean stringp)
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;
3020 /* Format of an array type:
3021 "ar<index type>;lower;upper;<array_contents_type>".
3022 OS9000: "arlower,upper;<array_contents_type>".
3024 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3025 for these, produce a type like float[][]. */
3027 orig = *pp;
3029 /* FIXME: gdb checks os9k_stabs here. */
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 != '=')
3037 index_type = debug_find_named_type (dhandle, "int");
3038 if (index_type == DEBUG_TYPE_NULL)
3040 index_type = debug_make_int_type (dhandle, 4, FALSE);
3041 if (index_type == DEBUG_TYPE_NULL)
3042 return DEBUG_TYPE_NULL;
3044 *pp = p;
3046 else
3048 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3049 (debug_type **) NULL);
3052 if (**pp != ';')
3054 bad_stab (orig);
3055 return DEBUG_TYPE_NULL;
3057 ++*pp;
3059 adjustable = FALSE;
3061 if (! ISDIGIT (**pp) && **pp != '-')
3063 ++*pp;
3064 adjustable = TRUE;
3067 lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3068 if (**pp != ';')
3070 bad_stab (orig);
3071 return DEBUG_TYPE_NULL;
3073 ++*pp;
3075 if (! ISDIGIT (**pp) && **pp != '-')
3077 ++*pp;
3078 adjustable = TRUE;
3081 upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3082 if (**pp != ';')
3084 bad_stab (orig);
3085 return DEBUG_TYPE_NULL;
3087 ++*pp;
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;
3094 if (adjustable)
3096 lower = 0;
3097 upper = -1;
3100 return debug_make_array_type (dhandle, element_type, index_type, lower,
3101 upper, stringp);
3104 /* This struct holds information about files we have seen using
3105 N_BINCL. */
3107 struct bincl_file
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;
3123 /* Start a new N_BINCL file, pushing it onto the stack. */
3125 static void
3126 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3128 struct bincl_file *n;
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;
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;
3148 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3149 stack. */
3151 static const char *
3152 pop_bincl (struct stab_handle *info)
3154 struct bincl_file *o;
3156 o = info->bincl_stack;
3157 if (o == NULL)
3158 return info->main_filename;
3159 info->bincl_stack = o->next_stack;
3161 o->file_types = info->file_types[o->file];
3163 if (info->bincl_stack == NULL)
3164 return info->main_filename;
3165 return info->bincl_stack->name;
3168 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3170 static bfd_boolean
3171 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3173 struct bincl_file *l;
3175 ++info->files;
3176 info->file_types = ((struct stab_types **)
3177 xrealloc (info->file_types,
3178 (info->files
3179 * sizeof *info->file_types)));
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)
3186 warn_stab (name, _("Undefined N_EXCL"));
3187 info->file_types[info->files - 1] = NULL;
3188 return TRUE;
3191 info->file_types[info->files - 1] = l->file_types;
3193 return TRUE;
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. */
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)
3206 struct stab_pending_var *v;
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);
3213 v = (struct stab_pending_var *) xmalloc (sizeof *v);
3214 memset (v, 0, sizeof *v);
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;
3223 return TRUE;
3226 /* Emit pending variable definitions. This is called after we see the
3227 N_LBRAC that starts the block. */
3229 static bfd_boolean
3230 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3232 struct stab_pending_var *v;
3234 v = info->pending;
3235 while (v != NULL)
3237 struct stab_pending_var *next;
3239 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3240 return FALSE;
3242 next = v->next;
3243 free (v);
3244 v = next;
3247 info->pending = NULL;
3249 return TRUE;
3252 /* Find the slot for a type in the database. */
3254 static debug_type *
3255 stab_find_slot (struct stab_handle *info, const int *typenums)
3257 int filenum;
3258 int index;
3259 struct stab_types **ps;
3261 filenum = typenums[0];
3262 index = typenums[1];
3264 if (filenum < 0 || (unsigned int) filenum >= info->files)
3266 fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3267 return NULL;
3269 if (index < 0)
3271 fprintf (stderr, _("Type index number %d out of range\n"), index);
3272 return NULL;
3275 ps = info->file_types + filenum;
3277 while (index >= STAB_TYPES_SLOTS)
3279 if (*ps == NULL)
3281 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3282 memset (*ps, 0, sizeof **ps);
3284 ps = &(*ps)->next;
3285 index -= STAB_TYPES_SLOTS;
3287 if (*ps == NULL)
3289 *ps = (struct stab_types *) xmalloc (sizeof **ps);
3290 memset (*ps, 0, sizeof **ps);
3293 return (*ps)->types + index;
3296 /* Find a type given a type number. If the type has not been
3297 allocated yet, create an indirect type. */
3299 static debug_type
3300 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3302 debug_type *slot;
3304 if (typenums[0] == 0 && typenums[1] < 0)
3306 /* A negative type number indicates an XCOFF builtin type. */
3307 return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3310 slot = stab_find_slot (info, typenums);
3311 if (slot == NULL)
3312 return DEBUG_TYPE_NULL;
3314 if (*slot == DEBUG_TYPE_NULL)
3315 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3317 return *slot;
3320 /* Record that a given type number refers to a given type. */
3322 static bfd_boolean
3323 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3324 const int *typenums, debug_type type)
3326 debug_type *slot;
3328 slot = stab_find_slot (info, typenums);
3329 if (slot == NULL)
3330 return FALSE;
3332 /* gdb appears to ignore type redefinitions, so we do as well. */
3334 *slot = type;
3336 return TRUE;
3339 /* Return an XCOFF builtin type. */
3341 static debug_type
3342 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3343 int typenum)
3345 debug_type rettype;
3346 const char *name;
3348 if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3350 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3351 return DEBUG_TYPE_NULL;
3353 if (info->xcoff_types[-typenum] != NULL)
3354 return info->xcoff_types[-typenum];
3356 switch (-typenum)
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 ();
3509 rettype = debug_name_type (dhandle, name, rettype);
3511 info->xcoff_types[-typenum] = rettype;
3513 return rettype;
3516 /* Find or create a tagged type. */
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)
3522 char *name;
3523 debug_type dtype;
3524 struct stab_tag *st;
3526 name = savestring (p, len);
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)
3534 free (name);
3535 return dtype;
3538 /* We need to allocate an entry on the undefined tag list. */
3539 for (st = info->tags; st != NULL; st = st->next)
3541 if (st->name[0] == name[0]
3542 && strcmp (st->name, name) == 0)
3544 if (st->kind == DEBUG_KIND_ILLEGAL)
3545 st->kind = kind;
3546 free (name);
3547 break;
3550 if (st == NULL)
3552 st = (struct stab_tag *) xmalloc (sizeof *st);
3553 memset (st, 0, sizeof *st);
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;
3563 return st->type;
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.
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. */
3578 /* This structure is used to hold a pointer to type information which
3579 demangling a string. */
3581 struct stab_demangle_typestring
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;
3589 /* This structure is used to hold information while demangling a
3590 string. */
3592 struct stab_demangle_info
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;
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);
3637 /* Warn about a bad demangling. */
3639 static void
3640 stab_bad_demangle (const char *s)
3642 fprintf (stderr, _("bad mangled name `%s'\n"), s);
3645 /* Get a count from a stab string. */
3647 static unsigned int
3648 stab_demangle_count (const char **pp)
3650 unsigned int count;
3652 count = 0;
3653 while (ISDIGIT (**pp))
3655 count *= 10;
3656 count += **pp - '0';
3657 ++*pp;
3659 return count;
3662 /* Require a count in a string. The count may be multiple digits, in
3663 which case it must end in an underscore. */
3665 static bfd_boolean
3666 stab_demangle_get_count (const char **pp, unsigned int *pi)
3668 if (! ISDIGIT (**pp))
3669 return FALSE;
3671 *pi = **pp - '0';
3672 ++*pp;
3673 if (ISDIGIT (**pp))
3675 unsigned int count;
3676 const char *p;
3678 count = *pi;
3679 p = *pp;
3682 count *= 10;
3683 count += *p - '0';
3684 ++p;
3686 while (ISDIGIT (*p));
3687 if (*p == '_')
3689 *pp = p + 1;
3690 *pi = count;
3694 return TRUE;
3697 /* This function demangles a physical name, returning a NULL
3698 terminated array of argument types. */
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)
3705 struct stab_demangle_info minfo;
3707 /* Check for the g++ V3 ABI. */
3708 if (physname[0] == '_' && physname[1] == 'Z')
3709 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
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;
3721 /* cplus_demangle checks for special GNU mangled forms, but we can't
3722 see any of them in mangled method argument types. */
3724 if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3725 goto error_return;
3727 if (*physname != '\0')
3729 if (! stab_demangle_signature (&minfo, &physname))
3730 goto error_return;
3733 free (minfo.typestrings);
3734 minfo.typestrings = NULL;
3736 if (minfo.args == NULL)
3737 fprintf (stderr, _("no argument types in mangled string\n"));
3739 *pvarargs = minfo.varargs;
3740 return minfo.args;
3742 error_return:
3743 if (minfo.typestrings != NULL)
3744 free (minfo.typestrings);
3745 return NULL;
3748 /* Demangle the prefix of the mangled name. */
3750 static bfd_boolean
3751 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3752 unsigned int physname_len)
3754 const char *scan;
3755 unsigned int i;
3757 /* cplus_demangle checks for global constructors and destructors,
3758 but we can't see them in mangled argument types. */
3760 if (physname_len)
3761 scan = *pp + physname_len;
3762 else
3764 /* Look for `__'. */
3765 scan = *pp;
3767 scan = strchr (scan, '_');
3768 while (scan != NULL && *++scan != '_');
3770 if (scan == NULL)
3772 stab_bad_demangle (*pp);
3773 return FALSE;
3776 --scan;
3778 /* We found `__'; move ahead to the last contiguous `__' pair. */
3779 i = strspn (scan, "_");
3780 if (i > 2)
3781 scan += i - 2;
3784 if (scan == *pp
3785 && (ISDIGIT (scan[2])
3786 || scan[2] == 'Q'
3787 || scan[2] == 't'))
3789 /* This is a GNU style constructor name. */
3790 *pp = scan + 2;
3791 return TRUE;
3793 else if (scan == *pp
3794 && ! ISDIGIT (scan[2])
3795 && scan[2] != 't')
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')
3804 stab_bad_demangle (*pp);
3805 return FALSE;
3808 return stab_demangle_function_name (minfo, pp, scan);
3810 else if (scan[2] != '\0')
3812 /* The name doesn't start with `__', but it does contain `__'. */
3813 return stab_demangle_function_name (minfo, pp, scan);
3815 else
3817 stab_bad_demangle (*pp);
3818 return FALSE;
3820 /*NOTREACHED*/
3823 /* Demangle a function name prefix. The scan argument points to the
3824 double underscore which separates the function name from the
3825 signature. */
3827 static bfd_boolean
3828 stab_demangle_function_name (struct stab_demangle_info *minfo,
3829 const char **pp, const char *scan)
3831 const char *name;
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. */
3838 name = *pp;
3839 *pp = scan + 2;
3841 if (*pp - name >= 5
3842 && CONST_STRNEQ (name, "type")
3843 && (name[4] == '$' || name[4] == '.'))
3845 const char *tem;
3847 /* This is a type conversion operator. */
3848 tem = name + 5;
3849 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3850 return FALSE;
3852 else if (name[0] == '_'
3853 && name[1] == '_'
3854 && name[2] == 'o'
3855 && name[3] == 'p')
3857 const char *tem;
3859 /* This is a type conversion operator. */
3860 tem = name + 4;
3861 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3862 return FALSE;
3865 return TRUE;
3868 /* Demangle the signature. This is where the argument types are
3869 found. */
3871 static bfd_boolean
3872 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3874 const char *orig;
3875 bfd_boolean expect_func, func_done;
3876 const char *hold;
3878 orig = *pp;
3880 expect_func = FALSE;
3881 func_done = FALSE;
3882 hold = NULL;
3884 while (**pp != '\0')
3886 switch (**pp)
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;
3897 case 'S':
3898 /* Static member function. FIXME: Can this happen? */
3899 if (hold == NULL)
3900 hold = *pp;
3901 ++*pp;
3902 break;
3904 case 'C':
3905 /* Const member function. */
3906 if (hold == NULL)
3907 hold = *pp;
3908 ++*pp;
3909 break;
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;
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;
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;
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;
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;
3961 if (expect_func)
3963 func_done = TRUE;
3964 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3965 return FALSE;
3969 if (! func_done)
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;
3979 return TRUE;
3982 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
3983 mangled form of "Outer::Inner". */
3985 static bfd_boolean
3986 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
3987 debug_type *ptype)
3989 const char *orig;
3990 const char *p;
3991 unsigned int qualifiers;
3992 debug_type context;
3994 orig = *pp;
3996 switch ((*pp)[1])
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')
4005 stab_bad_demangle (orig);
4006 return FALSE;
4008 qualifiers = atoi (p);
4009 while (ISDIGIT (*p))
4010 ++p;
4011 if (*p != '_')
4013 stab_bad_demangle (orig);
4014 return FALSE;
4016 *pp = p + 1;
4017 break;
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;
4028 case '0':
4029 default:
4030 stab_bad_demangle (orig);
4031 return FALSE;
4034 context = DEBUG_TYPE_NULL;
4036 /* Pick off the names. */
4037 while (qualifiers-- > 0)
4039 if (**pp == '_')
4040 ++*pp;
4041 if (**pp == 't')
4043 char *name;
4045 if (! stab_demangle_template (minfo, pp,
4046 ptype != NULL ? &name : NULL))
4047 return FALSE;
4049 if (ptype != NULL)
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;
4059 else
4061 unsigned int len;
4063 len = stab_demangle_count (pp);
4064 if (strlen (*pp) < len)
4066 stab_bad_demangle (orig);
4067 return FALSE;
4070 if (ptype != NULL)
4072 const debug_field *fields;
4074 fields = NULL;
4075 if (context != DEBUG_TYPE_NULL)
4076 fields = debug_get_fields (minfo->dhandle, context);
4078 context = DEBUG_TYPE_NULL;
4080 if (fields != NULL)
4082 char *name;
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. */
4092 name = savestring (*pp, len);
4094 for (; *fields != DEBUG_FIELD_NULL; fields++)
4096 debug_type ft;
4097 const char *dn;
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)
4105 context = ft;
4106 break;
4110 free (name);
4113 if (context == DEBUG_TYPE_NULL)
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. */
4119 if (qualifiers == 0)
4121 char *name;
4123 name = savestring (*pp, len);
4124 context = debug_find_named_type (minfo->dhandle,
4125 name);
4126 free (name);
4129 if (context == DEBUG_TYPE_NULL)
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;
4143 *pp += len;
4147 if (ptype != NULL)
4148 *ptype = context;
4150 return TRUE;
4153 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4154 string representation of the template. */
4156 static bfd_boolean
4157 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4158 char **pname)
4160 const char *orig;
4161 unsigned int r, i;
4163 orig = *pp;
4165 ++*pp;
4167 /* Skip the template name. */
4168 r = stab_demangle_count (pp);
4169 if (r == 0 || strlen (*pp) < r)
4171 stab_bad_demangle (orig);
4172 return FALSE;
4174 *pp += r;
4176 /* Get the size of the parameter list. */
4177 if (stab_demangle_get_count (pp, &r) == 0)
4179 stab_bad_demangle (orig);
4180 return FALSE;
4183 for (i = 0; i < r; i++)
4185 if (**pp == 'Z')
4187 /* This is a type parameter. */
4188 ++*pp;
4189 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4190 return FALSE;
4192 else
4194 const char *old_p;
4195 bfd_boolean pointerp, realp, integralp, charp, boolp;
4196 bfd_boolean done;
4198 old_p = *pp;
4199 pointerp = FALSE;
4200 realp = FALSE;
4201 integralp = FALSE;
4202 charp = FALSE;
4203 boolp = FALSE;
4204 done = FALSE;
4206 /* This is a value parameter. */
4208 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4209 return FALSE;
4211 while (*old_p != '\0' && ! done)
4213 switch (*old_p)
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;
4268 if (integralp)
4270 if (**pp == 'm')
4271 ++*pp;
4272 while (ISDIGIT (**pp))
4273 ++*pp;
4275 else if (charp)
4277 unsigned int val;
4279 if (**pp == 'm')
4280 ++*pp;
4281 val = stab_demangle_count (pp);
4282 if (val == 0)
4284 stab_bad_demangle (orig);
4285 return FALSE;
4288 else if (boolp)
4290 unsigned int val;
4292 val = stab_demangle_count (pp);
4293 if (val != 0 && val != 1)
4295 stab_bad_demangle (orig);
4296 return FALSE;
4299 else if (realp)
4301 if (**pp == 'm')
4302 ++*pp;
4303 while (ISDIGIT (**pp))
4304 ++*pp;
4305 if (**pp == '.')
4307 ++*pp;
4308 while (ISDIGIT (**pp))
4309 ++*pp;
4311 if (**pp == 'e')
4313 ++*pp;
4314 while (ISDIGIT (**pp))
4315 ++*pp;
4318 else if (pointerp)
4320 unsigned int len;
4322 len = stab_demangle_count (pp);
4323 if (len == 0)
4325 stab_bad_demangle (orig);
4326 return FALSE;
4328 *pp += len;
4333 /* We can translate this to a string fairly easily by invoking the
4334 regular demangling routine. */
4335 if (pname != NULL)
4337 char *s1, *s2, *s3, *s4 = NULL;
4338 char *from, *to;
4340 s1 = savestring (orig, *pp - orig);
4342 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4344 free (s1);
4346 s3 = cplus_demangle (s2, DMGL_ANSI);
4348 free (s2);
4350 if (s3 != NULL)
4351 s4 = strstr (s3, "::NoSuchStrinG");
4352 if (s3 == NULL || s4 == NULL)
4354 stab_bad_demangle (orig);
4355 if (s3 != NULL)
4356 free (s3);
4357 return FALSE;
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;
4368 *pname = savestring (s3, to - s3);
4370 free (s3);
4373 return TRUE;
4376 /* Demangle a class name. */
4378 static bfd_boolean
4379 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4380 const char **pp, const char **pstart)
4382 const char *orig;
4383 unsigned int n;
4385 orig = *pp;
4387 n = stab_demangle_count (pp);
4388 if (strlen (*pp) < n)
4390 stab_bad_demangle (orig);
4391 return FALSE;
4394 if (pstart != NULL)
4395 *pstart = *pp;
4397 *pp += n;
4399 return TRUE;
4402 /* Demangle function arguments. If the pargs argument is not NULL, it
4403 is set to a NULL terminated array holding the arguments. */
4405 static bfd_boolean
4406 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4407 debug_type **pargs, bfd_boolean *pvarargs)
4409 const char *orig;
4410 unsigned int alloc, count;
4412 orig = *pp;
4414 alloc = 10;
4415 if (pargs != NULL)
4417 *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4418 *pvarargs = FALSE;
4420 count = 0;
4422 while (**pp != '_' && **pp != '\0' && **pp != 'e')
4424 if (**pp == 'N' || **pp == 'T')
4426 char temptype;
4427 unsigned int r, t;
4429 temptype = **pp;
4430 ++*pp;
4432 if (temptype == 'T')
4433 r = 1;
4434 else
4436 if (! stab_demangle_get_count (pp, &r))
4438 stab_bad_demangle (orig);
4439 return FALSE;
4443 if (! stab_demangle_get_count (pp, &t))
4445 stab_bad_demangle (orig);
4446 return FALSE;
4449 if (t >= minfo->typestring_count)
4451 stab_bad_demangle (orig);
4452 return FALSE;
4454 while (r-- > 0)
4456 const char *tem;
4458 tem = minfo->typestrings[t].typestring;
4459 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4460 return FALSE;
4463 else
4465 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4466 return FALSE;
4470 if (pargs != NULL)
4471 (*pargs)[count] = DEBUG_TYPE_NULL;
4473 if (**pp == 'e')
4475 if (pargs != NULL)
4476 *pvarargs = TRUE;
4477 ++*pp;
4480 return TRUE;
4483 /* Demangle a single argument. */
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)
4490 const char *start;
4491 debug_type type;
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;
4499 if (pargs != NULL)
4501 if (type == DEBUG_TYPE_NULL)
4502 return FALSE;
4504 if (*pcount + 1 >= *palloc)
4506 *palloc += 10;
4507 *pargs = ((debug_type *)
4508 xrealloc (*pargs, *palloc * sizeof **pargs));
4510 (*pargs)[*pcount] = type;
4511 ++*pcount;
4514 return TRUE;
4517 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4518 to the newly allocated type. */
4520 static bfd_boolean
4521 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4522 debug_type *ptype)
4524 const char *orig;
4526 orig = *pp;
4528 switch (**pp)
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;
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;
4549 case 'A':
4550 /* An array. */
4552 unsigned long high;
4554 ++*pp;
4555 high = 0;
4556 while (**pp != '\0' && **pp != '_')
4558 if (! ISDIGIT (**pp))
4560 stab_bad_demangle (orig);
4561 return FALSE;
4563 high *= 10;
4564 high += **pp - '0';
4565 ++*pp;
4567 if (**pp != '_')
4569 stab_bad_demangle (orig);
4570 return FALSE;
4572 ++*pp;
4574 if (! stab_demangle_type (minfo, pp, ptype))
4575 return FALSE;
4576 if (ptype != NULL)
4578 debug_type int_type;
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);
4587 break;
4589 case 'T':
4590 /* A back reference to a remembered type. */
4592 unsigned int i;
4593 const char *p;
4595 ++*pp;
4596 if (! stab_demangle_get_count (pp, &i))
4598 stab_bad_demangle (orig);
4599 return FALSE;
4601 if (i >= minfo->typestring_count)
4603 stab_bad_demangle (orig);
4604 return FALSE;
4606 p = minfo->typestrings[i].typestring;
4607 if (! stab_demangle_type (minfo, &p, ptype))
4608 return FALSE;
4610 break;
4612 case 'F':
4613 /* A function. */
4615 debug_type *args;
4616 bfd_boolean varargs;
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 != '_')
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;
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);
4643 break;
4645 case 'M':
4646 case 'O':
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;
4655 memberp = **pp == 'M';
4656 constp = FALSE;
4657 volatilep = FALSE;
4658 args = NULL;
4659 varargs = FALSE;
4661 ++*pp;
4662 if (ISDIGIT (**pp))
4664 n = stab_demangle_count (pp);
4665 if (strlen (*pp) < n)
4667 stab_bad_demangle (orig);
4668 return FALSE;
4670 name = *pp;
4671 *pp += n;
4673 if (ptype != NULL)
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;
4683 else if (**pp == 'Q')
4685 if (! stab_demangle_qualified (minfo, pp,
4686 (ptype == NULL
4687 ? (debug_type *) NULL
4688 : &class_type)))
4689 return FALSE;
4691 else
4693 stab_bad_demangle (orig);
4694 return FALSE;
4697 if (memberp)
4699 if (**pp == 'C')
4701 constp = TRUE;
4702 ++*pp;
4704 else if (**pp == 'V')
4706 volatilep = TRUE;
4707 ++*pp;
4709 if (**pp != 'F')
4711 stab_bad_demangle (orig);
4712 return FALSE;
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;
4725 if (**pp != '_')
4727 stab_bad_demangle (orig);
4728 return FALSE;
4730 ++*pp;
4732 if (! stab_demangle_type (minfo, pp, ptype))
4733 return FALSE;
4735 if (ptype != NULL)
4737 if (! memberp)
4738 *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4739 *ptype);
4740 else
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);
4749 break;
4751 case 'G':
4752 ++*pp;
4753 if (! stab_demangle_type (minfo, pp, ptype))
4754 return FALSE;
4755 break;
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;
4765 case 'Q':
4767 const char *hold;
4769 hold = *pp;
4770 if (! stab_demangle_qualified (minfo, pp, ptype))
4771 return FALSE;
4773 break;
4775 default:
4776 if (! stab_demangle_fund_type (minfo, pp, ptype))
4777 return FALSE;
4778 break;
4781 return TRUE;
4784 /* Demangle a fundamental type. If the ptype argument is not NULL,
4785 *ptype is set to the newly allocated type. */
4787 static bfd_boolean
4788 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4789 debug_type *ptype)
4791 const char *orig;
4792 bfd_boolean constp, volatilep, unsignedp, signedp;
4793 bfd_boolean done;
4795 orig = *pp;
4797 constp = FALSE;
4798 volatilep = FALSE;
4799 unsignedp = FALSE;
4800 signedp = FALSE;
4802 done = FALSE;
4803 while (! done)
4805 switch (**pp)
4807 case 'C':
4808 constp = TRUE;
4809 ++*pp;
4810 break;
4812 case 'U':
4813 unsignedp = TRUE;
4814 ++*pp;
4815 break;
4817 case 'S':
4818 signedp = TRUE;
4819 ++*pp;
4820 break;
4822 case 'V':
4823 volatilep = TRUE;
4824 ++*pp;
4825 break;
4827 default:
4828 done = TRUE;
4829 break;
4833 switch (**pp)
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;
4841 case 'v': /* void */
4842 if (ptype != NULL)
4844 *ptype = debug_find_named_type (minfo->dhandle, "void");
4845 if (*ptype == DEBUG_TYPE_NULL)
4846 *ptype = debug_make_void_type (minfo->dhandle);
4848 ++*pp;
4849 break;
4851 case 'x': /* long long */
4852 if (ptype != NULL)
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);
4861 ++*pp;
4862 break;
4864 case 'l': /* long */
4865 if (ptype != NULL)
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);
4874 ++*pp;
4875 break;
4877 case 'i': /* int */
4878 if (ptype != NULL)
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);
4887 ++*pp;
4888 break;
4890 case 's': /* short */
4891 if (ptype != NULL)
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);
4900 ++*pp;
4901 break;
4903 case 'b': /* bool */
4904 if (ptype != NULL)
4906 *ptype = debug_find_named_type (minfo->dhandle, "bool");
4907 if (*ptype == DEBUG_TYPE_NULL)
4908 *ptype = debug_make_bool_type (minfo->dhandle, 4);
4910 ++*pp;
4911 break;
4913 case 'c': /* char */
4914 if (ptype != NULL)
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);
4925 ++*pp;
4926 break;
4928 case 'w': /* wchar_t */
4929 if (ptype != NULL)
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);
4935 ++*pp;
4936 break;
4938 case 'r': /* long double */
4939 if (ptype != NULL)
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);
4945 ++*pp;
4946 break;
4948 case 'd': /* double */
4949 if (ptype != NULL)
4951 *ptype = debug_find_named_type (minfo->dhandle, "double");
4952 if (*ptype == DEBUG_TYPE_NULL)
4953 *ptype = debug_make_float_type (minfo->dhandle, 8);
4955 ++*pp;
4956 break;
4958 case 'f': /* float */
4959 if (ptype != NULL)
4961 *ptype = debug_find_named_type (minfo->dhandle, "float");
4962 if (*ptype == DEBUG_TYPE_NULL)
4963 *ptype = debug_make_float_type (minfo->dhandle, 4);
4965 ++*pp;
4966 break;
4968 case 'G':
4969 ++*pp;
4970 if (! ISDIGIT (**pp))
4972 stab_bad_demangle (orig);
4973 return FALSE;
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':
4979 const char *hold;
4981 if (! stab_demangle_class (minfo, pp, &hold))
4982 return FALSE;
4983 if (ptype != NULL)
4985 char *name;
4987 name = savestring (hold, *pp - hold);
4988 *ptype = debug_find_named_type (minfo->dhandle, name);
4989 free (name);
4990 if (*ptype == DEBUG_TYPE_NULL)
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;
5002 break;
5004 case 't':
5006 char *name;
5008 if (! stab_demangle_template (minfo, pp,
5009 ptype != NULL ? &name : NULL))
5010 return FALSE;
5011 if (ptype != NULL)
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;
5021 break;
5023 default:
5024 stab_bad_demangle (orig);
5025 return FALSE;
5028 if (ptype != NULL)
5030 if (constp)
5031 *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5032 if (volatilep)
5033 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5036 return TRUE;
5039 /* Remember a type string in a demangled string. */
5041 static bfd_boolean
5042 stab_demangle_remember_type (struct stab_demangle_info *minfo,
5043 const char *p, int len)
5045 if (minfo->typestring_count >= minfo->typestring_alloc)
5047 minfo->typestring_alloc += 10;
5048 minfo->typestrings = ((struct stab_demangle_typestring *)
5049 xrealloc (minfo->typestrings,
5050 (minfo->typestring_alloc
5051 * sizeof *minfo->typestrings)));
5054 minfo->typestrings[minfo->typestring_count].typestring = p;
5055 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5056 ++minfo->typestring_count;
5058 return TRUE;
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. */
5071 static debug_type *
5072 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5073 const char *physname, bfd_boolean *pvarargs)
5075 struct demangle_component *dc;
5076 void *mem;
5077 debug_type *pargs;
5079 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem);
5080 if (dc == NULL)
5082 stab_bad_demangle (physname);
5083 return NULL;
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)
5091 fprintf (stderr, _("Demangled name is not a function\n"));
5092 free (mem);
5093 return NULL;
5096 pargs = stab_demangle_v3_arglist (dhandle, info,
5097 dc->u.s_binary.right->u.s_binary.right,
5098 pvarargs);
5100 free (mem);
5102 return pargs;
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. */
5109 static debug_type *
5110 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5111 struct demangle_component *arglist,
5112 bfd_boolean *pvarargs)
5114 struct demangle_component *dc;
5115 unsigned int alloc, count;
5116 debug_type *pargs;
5118 alloc = 10;
5119 pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5120 *pvarargs = FALSE;
5122 count = 0;
5124 for (dc = arglist;
5125 dc != NULL;
5126 dc = dc->u.s_binary.right)
5128 debug_type arg;
5129 bfd_boolean varargs;
5131 if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5133 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5134 free (pargs);
5135 return NULL;
5138 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5139 NULL, &varargs);
5140 if (arg == NULL)
5142 if (varargs)
5144 *pvarargs = TRUE;
5145 continue;
5147 free (pargs);
5148 return NULL;
5151 if (count + 1 >= alloc)
5153 alloc += 10;
5154 pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5157 pargs[count] = arg;
5158 ++count;
5161 pargs[count] = DEBUG_TYPE_NULL;
5163 return pargs;
5166 /* Convert a struct demangle_component tree describing an argument
5167 type into a debug_type. */
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)
5174 debug_type dt;
5176 if (pvarargs != NULL)
5177 *pvarargs = FALSE;
5179 switch (dc->type)
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;
5204 case DEMANGLE_COMPONENT_NAME:
5205 if (context != NULL)
5207 const debug_field *fields;
5209 fields = debug_get_fields (dhandle, context);
5210 if (fields != NULL)
5212 /* Try to find this type by looking through the context
5213 class. */
5214 for (; *fields != DEBUG_FIELD_NULL; fields++)
5216 debug_type ft;
5217 const char *dn;
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;
5230 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5231 dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
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);
5241 case DEMANGLE_COMPONENT_TEMPLATE:
5243 char *p;
5244 size_t alc;
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)
5252 fprintf (stderr, _("Failed to print demangled template\n"));
5253 return NULL;
5255 dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5256 DEBUG_KIND_CLASS);
5257 free (p);
5258 return dt;
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);
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;
5275 switch (dc->type)
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);
5292 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5294 debug_type *pargs;
5295 bfd_boolean varargs;
5297 if (dc->u.s_binary.left == NULL)
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);
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;
5311 pargs = stab_demangle_v3_arglist (dhandle, info,
5312 dc->u.s_binary.right,
5313 &varargs);
5314 if (pargs == NULL)
5315 return NULL;
5317 return debug_make_function_type (dhandle, dt, pargs, varargs);
5320 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5322 char *p;
5323 size_t alc;
5324 debug_type ret;
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)
5332 fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5333 return NULL;
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)
5380 if (pvarargs == NULL)
5381 fprintf (stderr, _("Unexpected demangled varargs\n"));
5382 else
5383 *pvarargs = TRUE;
5384 ret = NULL;
5386 else
5388 fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5389 ret = NULL;
5392 free (p);
5394 return ret;