Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / binutils / stabs.c
1 /* stabs.c -- Parse stabs debugging information
2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3    2005, 2006, 2007, 2008, 2009, 2010  Free Software Foundation, Inc.
4    Written by Ian Lance Taylor <ian@cygnus.com>.
5
6    This file is part of GNU Binutils.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21    02110-1301, USA.  */
22
23 /* This file contains code which parses stabs debugging information.
24    The organization of this code is based on the gdb stabs reading
25    code.  The job it does is somewhat different, because it is not
26    trying to identify the correct address for anything.  */
27
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "libiberty.h"
31 #include "safe-ctype.h"
32 #include "demangle.h"
33 #include "debug.h"
34 #include "budbg.h"
35 #include "filenames.h"
36 #include "aout/aout64.h"
37 #include "aout/stab_gnu.h"
38
39 /* The number of predefined XCOFF types.  */
40
41 #define XCOFF_TYPE_COUNT 34
42
43 /* This structure is used as a handle so that the stab parsing doesn't
44    need to use any static variables.  */
45
46 struct stab_handle
47 {
48   /* The BFD.  */
49   bfd *abfd;
50   /* TRUE if this is stabs in sections.  */
51   bfd_boolean sections;
52   /* The symbol table.  */
53   asymbol **syms;
54   /* The number of symbols.  */
55   long symcount;
56   /* The accumulated file name string.  */
57   char *so_string;
58   /* The value of the last N_SO symbol.  */
59   bfd_vma so_value;
60   /* The value of the start of the file, so that we can handle file
61      relative N_LBRAC and N_RBRAC symbols.  */
62   bfd_vma file_start_offset;
63   /* The offset of the start of the function, so that we can handle
64      function relative N_LBRAC and N_RBRAC symbols.  */
65   bfd_vma function_start_offset;
66   /* The version number of gcc which compiled the current compilation
67      unit, 0 if not compiled by gcc.  */
68   int gcc_compiled;
69   /* Whether an N_OPT symbol was seen that was not generated by gcc,
70      so that we can detect the SunPRO compiler.  */
71   bfd_boolean n_opt_found;
72   /* The main file name.  */
73   char *main_filename;
74   /* A stack of unfinished N_BINCL files.  */
75   struct bincl_file *bincl_stack;
76   /* A list of finished N_BINCL files.  */
77   struct bincl_file *bincl_list;
78   /* Whether we are inside a function or not.  */
79   bfd_boolean within_function;
80   /* The address of the end of the function, used if we have seen an
81      N_FUN symbol while in a function.  This is -1 if we have not seen
82      an N_FUN (the normal case).  */
83   bfd_vma function_end;
84   /* The depth of block nesting.  */
85   int block_depth;
86   /* List of pending variable definitions.  */
87   struct stab_pending_var *pending;
88   /* Number of files for which we have types.  */
89   unsigned int files;
90   /* Lists of types per file.  */
91   struct stab_types **file_types;
92   /* Predefined XCOFF types.  */
93   debug_type xcoff_types[XCOFF_TYPE_COUNT];
94   /* Undefined tags.  */
95   struct stab_tag *tags;
96   /* Set by parse_stab_type if it sees a structure defined as a cross
97      reference to itself.  Reset by parse_stab_type otherwise.  */
98   bfd_boolean self_crossref;
99 };
100
101 /* A list of these structures is used to hold pending variable
102    definitions seen before the N_LBRAC of a block.  */
103
104 struct stab_pending_var
105 {
106   /* Next pending variable definition.  */
107   struct stab_pending_var *next;
108   /* Name.  */
109   const char *name;
110   /* Type.  */
111   debug_type type;
112   /* Kind.  */
113   enum debug_var_kind kind;
114   /* Value.  */
115   bfd_vma val;
116 };
117
118 /* A list of these structures is used to hold the types for a single
119    file.  */
120
121 struct stab_types
122 {
123   /* Next set of slots for this file.  */
124   struct stab_types *next;
125   /* Types indexed by type number.  */
126 #define STAB_TYPES_SLOTS (16)
127   debug_type types[STAB_TYPES_SLOTS];
128 };
129
130 /* We keep a list of undefined tags that we encounter, so that we can
131    fill them in if the tag is later defined.  */
132
133 struct stab_tag
134 {
135   /* Next undefined tag.  */
136   struct stab_tag *next;
137   /* Tag name.  */
138   const char *name;
139   /* Type kind.  */
140   enum debug_type_kind kind;
141   /* Slot to hold real type when we discover it.  If we don't, we fill
142      in an undefined tag type.  */
143   debug_type slot;
144   /* Indirect type we have created to point at slot.  */
145   debug_type type;
146 };
147
148 static char *savestring (const char *, int);
149 static bfd_vma parse_number (const char **, bfd_boolean *);
150 static void bad_stab (const char *);
151 static void warn_stab (const char *, const char *);
152 static bfd_boolean parse_stab_string
153   (void *, struct stab_handle *, int, int, bfd_vma, const char *);
154 static debug_type parse_stab_type
155   (void *, struct stab_handle *, const char *, const char **, debug_type **);
156 static bfd_boolean parse_stab_type_number (const char **, int *);
157 static debug_type parse_stab_range_type
158   (void *, struct stab_handle *, const char *, const char **, const int *);
159 static debug_type parse_stab_sun_builtin_type (void *, const char **);
160 static debug_type parse_stab_sun_floating_type (void *, const char **);
161 static debug_type parse_stab_enum_type (void *, const char **);
162 static debug_type parse_stab_struct_type
163   (void *, struct stab_handle *, const char *, const char **,
164    bfd_boolean, const int *);
165 static bfd_boolean parse_stab_baseclasses
166   (void *, struct stab_handle *, const char **, debug_baseclass **);
167 static bfd_boolean parse_stab_struct_fields
168   (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *);
169 static bfd_boolean parse_stab_cpp_abbrev
170   (void *, struct stab_handle *, const char **, debug_field *);
171 static bfd_boolean parse_stab_one_struct_field
172   (void *, struct stab_handle *, const char **, const char *,
173    debug_field *, bfd_boolean *);
174 static bfd_boolean parse_stab_members
175   (void *, struct stab_handle *, const char *, const char **, const int *,
176    debug_method **);
177 static debug_type parse_stab_argtypes
178   (void *, struct stab_handle *, debug_type, const char *, const char *,
179    debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
180 static bfd_boolean parse_stab_tilde_field
181   (void *, struct stab_handle *, const char **, const int *, debug_type *,
182    bfd_boolean *);
183 static debug_type parse_stab_array_type
184   (void *, struct stab_handle *, const char **, bfd_boolean);
185 static void push_bincl (struct stab_handle *, const char *, bfd_vma);
186 static const char *pop_bincl (struct stab_handle *);
187 static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
188 static bfd_boolean stab_record_variable
189   (void *, struct stab_handle *, const char *, debug_type,
190    enum debug_var_kind, bfd_vma);
191 static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
192 static debug_type *stab_find_slot (struct stab_handle *, const int *);
193 static debug_type stab_find_type (void *, struct stab_handle *, const int *);
194 static bfd_boolean stab_record_type
195   (void *, struct stab_handle *, const int *, debug_type);
196 static debug_type stab_xcoff_builtin_type
197   (void *, struct stab_handle *, int);
198 static debug_type stab_find_tagged_type
199   (void *, struct stab_handle *, const char *, int, enum debug_type_kind);
200 static debug_type *stab_demangle_argtypes
201   (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
202 static debug_type *stab_demangle_v3_argtypes
203   (void *, struct stab_handle *, const char *, bfd_boolean *);
204 static debug_type *stab_demangle_v3_arglist
205   (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *);
206 static debug_type stab_demangle_v3_arg
207   (void *, struct stab_handle *, struct demangle_component *, debug_type,
208    bfd_boolean *);
209
210 /* Save a string in memory.  */
211
212 static char *
213 savestring (const char *start, int len)
214 {
215   char *ret;
216
217   ret = (char *) xmalloc (len + 1);
218   memcpy (ret, start, len);
219   ret[len] = '\0';
220   return ret;
221 }
222
223 /* Read a number from a string.  */
224
225 static bfd_vma
226 parse_number (const char **pp, bfd_boolean *poverflow)
227 {
228   unsigned long ul;
229   const char *orig;
230
231   if (poverflow != NULL)
232     *poverflow = FALSE;
233
234   orig = *pp;
235
236   errno = 0;
237   ul = strtoul (*pp, (char **) pp, 0);
238   if (ul + 1 != 0 || errno == 0)
239     {
240       /* If bfd_vma is larger than unsigned long, and the number is
241          meant to be negative, we have to make sure that we sign
242          extend properly.  */
243       if (*orig == '-')
244         return (bfd_vma) (bfd_signed_vma) (long) ul;
245       return (bfd_vma) ul;
246     }
247
248   /* Note that even though strtoul overflowed, it should have set *pp
249      to the end of the number, which is where we want it.  */
250   if (sizeof (bfd_vma) > sizeof (unsigned long))
251     {
252       const char *p;
253       bfd_boolean neg;
254       int base;
255       bfd_vma over, lastdig;
256       bfd_boolean overflow;
257       bfd_vma v;
258
259       /* Our own version of strtoul, for a bfd_vma.  */
260       p = orig;
261
262       neg = FALSE;
263       if (*p == '+')
264         ++p;
265       else if (*p == '-')
266         {
267           neg = TRUE;
268           ++p;
269         }
270
271       base = 10;
272       if (*p == '0')
273         {
274           if (p[1] == 'x' || p[1] == 'X')
275             {
276               base = 16;
277               p += 2;
278             }
279           else
280             {
281               base = 8;
282               ++p;
283             }
284         }
285
286       over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
287       lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
288
289       overflow = FALSE;
290       v = 0;
291       while (1)
292         {
293           int d;
294
295           d = *p++;
296           if (ISDIGIT (d))
297             d -= '0';
298           else if (ISUPPER (d))
299             d -= 'A';
300           else if (ISLOWER (d))
301             d -= 'a';
302           else
303             break;
304
305           if (d >= base)
306             break;
307
308           if (v > over || (v == over && (bfd_vma) d > lastdig))
309             {
310               overflow = TRUE;
311               break;
312             }
313         }
314
315       if (! overflow)
316         {
317           if (neg)
318             v = - v;
319           return v;
320         }
321     }
322
323   /* If we get here, the number is too large to represent in a
324      bfd_vma.  */
325   if (poverflow != NULL)
326     *poverflow = TRUE;
327   else
328     warn_stab (orig, _("numeric overflow"));
329
330   return 0;
331 }
332
333 /* Give an error for a bad stab string.  */
334
335 static void
336 bad_stab (const char *p)
337 {
338   fprintf (stderr, _("Bad stab: %s\n"), p);
339 }
340
341 /* Warn about something in a stab string.  */
342
343 static void
344 warn_stab (const char *p, const char *err)
345 {
346   fprintf (stderr, _("Warning: %s: %s\n"), err, p);
347 }
348
349 /* Create a handle to parse stabs symbols with.  */
350
351 void *
352 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
353             asymbol **syms, long symcount)
354 {
355   struct stab_handle *ret;
356
357   ret = (struct stab_handle *) xmalloc (sizeof *ret);
358   memset (ret, 0, sizeof *ret);
359   ret->abfd = abfd;
360   ret->sections = sections;
361   ret->syms = syms;
362   ret->symcount = symcount;
363   ret->files = 1;
364   ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types);
365   ret->file_types[0] = NULL;
366   ret->function_end = (bfd_vma) -1;
367   return (void *) ret;
368 }
369
370 /* When we have processed all the stabs information, we need to go
371    through and fill in all the undefined tags.  */
372
373 bfd_boolean
374 finish_stab (void *dhandle, void *handle)
375 {
376   struct stab_handle *info = (struct stab_handle *) handle;
377   struct stab_tag *st;
378
379   if (info->within_function)
380     {
381       if (! stab_emit_pending_vars (dhandle, info)
382           || ! debug_end_function (dhandle, info->function_end))
383         return FALSE;
384       info->within_function = FALSE;
385       info->function_end = (bfd_vma) -1;
386     }
387
388   for (st = info->tags; st != NULL; st = st->next)
389     {
390       enum debug_type_kind kind;
391
392       kind = st->kind;
393       if (kind == DEBUG_KIND_ILLEGAL)
394         kind = DEBUG_KIND_STRUCT;
395       st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
396       if (st->slot == DEBUG_TYPE_NULL)
397         return FALSE;
398     }
399
400   return TRUE;
401 }
402
403 /* Handle a single stabs symbol.  */
404
405 bfd_boolean
406 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
407             const char *string)
408 {
409   struct stab_handle *info = (struct stab_handle *) handle;
410
411   /* gcc will emit two N_SO strings per compilation unit, one for the
412      directory name and one for the file name.  We just collect N_SO
413      strings as we see them, and start the new compilation unit when
414      we see a non N_SO symbol.  */
415   if (info->so_string != NULL
416       && (type != N_SO || *string == '\0' || value != info->so_value))
417     {
418       if (! debug_set_filename (dhandle, info->so_string))
419         return FALSE;
420       info->main_filename = info->so_string;
421
422       info->gcc_compiled = 0;
423       info->n_opt_found = FALSE;
424
425       /* Generally, for stabs in the symbol table, the N_LBRAC and
426          N_RBRAC symbols are relative to the N_SO symbol value.  */
427       if (! info->sections)
428         info->file_start_offset = info->so_value;
429
430       /* We need to reset the mapping from type numbers to types.  We
431          can't free the old mapping, because of the use of
432          debug_make_indirect_type.  */
433       info->files = 1;
434       info->file_types = ((struct stab_types **)
435                           xmalloc (sizeof *info->file_types));
436       info->file_types[0] = NULL;
437
438       info->so_string = NULL;
439
440       /* Now process whatever type we just got.  */
441     }
442
443   switch (type)
444     {
445     case N_FN:
446     case N_FN_SEQ:
447       break;
448
449     case N_LBRAC:
450       /* Ignore extra outermost context from SunPRO cc and acc.  */
451       if (info->n_opt_found && desc == 1)
452         break;
453
454       if (! info->within_function)
455         {
456           fprintf (stderr, _("N_LBRAC not within function\n"));
457           return FALSE;
458         }
459
460       /* Start an inner lexical block.  */
461       if (! debug_start_block (dhandle,
462                                (value
463                                 + info->file_start_offset
464                                 + info->function_start_offset)))
465         return FALSE;
466
467       /* Emit any pending variable definitions.  */
468       if (! stab_emit_pending_vars (dhandle, info))
469         return FALSE;
470
471       ++info->block_depth;
472       break;
473
474     case N_RBRAC:
475       /* Ignore extra outermost context from SunPRO cc and acc.  */
476       if (info->n_opt_found && desc == 1)
477         break;
478
479       /* We shouldn't have any pending variable definitions here, but,
480          if we do, we probably need to emit them before closing the
481          block.  */
482       if (! stab_emit_pending_vars (dhandle, info))
483         return FALSE;
484
485       /* End an inner lexical block.  */
486       if (! debug_end_block (dhandle,
487                              (value
488                               + info->file_start_offset
489                               + info->function_start_offset)))
490         return FALSE;
491
492       --info->block_depth;
493       if (info->block_depth < 0)
494         {
495           fprintf (stderr, _("Too many N_RBRACs\n"));
496           return FALSE;
497         }
498       break;
499
500     case N_SO:
501       /* This always ends a function.  */
502       if (info->within_function)
503         {
504           bfd_vma endval;
505
506           endval = value;
507           if (*string != '\0'
508               && info->function_end != (bfd_vma) -1
509               && info->function_end < endval)
510             endval = info->function_end;
511           if (! stab_emit_pending_vars (dhandle, info)
512               || ! debug_end_function (dhandle, endval))
513             return FALSE;
514           info->within_function = FALSE;
515           info->function_end = (bfd_vma) -1;
516         }
517
518       /* An empty string is emitted by gcc at the end of a compilation
519          unit.  */
520       if (*string == '\0')
521         return TRUE;
522
523       /* Just accumulate strings until we see a non N_SO symbol.  If
524          the string starts with a directory separator or some other
525          form of absolute path specification, we discard the previously
526          accumulated strings.  */
527       if (info->so_string == NULL)
528         info->so_string = xstrdup (string);
529       else
530         {
531           char *f;
532
533           f = info->so_string;
534
535           if (IS_ABSOLUTE_PATH (string))
536             info->so_string = xstrdup (string);
537           else
538             info->so_string = concat (info->so_string, string,
539                                       (const char *) NULL);
540           free (f);
541         }
542
543       info->so_value = value;
544
545       break;
546
547     case N_SOL:
548       /* Start an include file.  */
549       if (! debug_start_source (dhandle, string))
550         return FALSE;
551       break;
552
553     case N_BINCL:
554       /* Start an include file which may be replaced.  */
555       push_bincl (info, string, value);
556       if (! debug_start_source (dhandle, string))
557         return FALSE;
558       break;
559
560     case N_EINCL:
561       /* End an N_BINCL include.  */
562       if (! debug_start_source (dhandle, pop_bincl (info)))
563         return FALSE;
564       break;
565
566     case N_EXCL:
567       /* This is a duplicate of a header file named by N_BINCL which
568          was eliminated by the linker.  */
569       if (! find_excl (info, string, value))
570         return FALSE;
571       break;
572
573     case N_SLINE:
574       if (! debug_record_line (dhandle, desc,
575                                value + (info->within_function
576                                         ? info->function_start_offset : 0)))
577         return FALSE;
578       break;
579
580     case N_BCOMM:
581       if (! debug_start_common_block (dhandle, string))
582         return FALSE;
583       break;
584
585     case N_ECOMM:
586       if (! debug_end_common_block (dhandle, string))
587         return FALSE;
588       break;
589
590     case N_FUN:
591       if (*string == '\0')
592         {
593           if (info->within_function)
594             {
595               /* This always marks the end of a function; we don't
596                  need to worry about info->function_end.  */
597               if (info->sections)
598                 value += info->function_start_offset;
599               if (! stab_emit_pending_vars (dhandle, info)
600                   || ! debug_end_function (dhandle, value))
601                 return FALSE;
602               info->within_function = FALSE;
603               info->function_end = (bfd_vma) -1;
604             }
605           break;
606         }
607
608       /* A const static symbol in the .text section will have an N_FUN
609          entry.  We need to use these to mark the end of the function,
610          in case we are looking at gcc output before it was changed to
611          always emit an empty N_FUN.  We can't call debug_end_function
612          here, because it might be a local static symbol.  */
613       if (info->within_function
614           && (info->function_end == (bfd_vma) -1
615               || value < info->function_end))
616         info->function_end = value;
617
618       /* Fall through.  */
619       /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
620          symbols, and if it does not start with :S, gdb relocates the
621          value to the start of the section.  gcc always seems to use
622          :S, so we don't worry about this.  */
623       /* Fall through.  */
624     default:
625       {
626         const char *colon;
627
628         colon = strchr (string, ':');
629         if (colon != NULL
630             && (colon[1] == 'f' || colon[1] == 'F'))
631           {
632             if (info->within_function)
633               {
634                 bfd_vma endval;
635
636                 endval = value;
637                 if (info->function_end != (bfd_vma) -1
638                     && info->function_end < endval)
639                   endval = info->function_end;
640                 if (! stab_emit_pending_vars (dhandle, info)
641                     || ! debug_end_function (dhandle, endval))
642                   return FALSE;
643                 info->function_end = (bfd_vma) -1;
644               }
645             /* For stabs in sections, line numbers and block addresses
646                are offsets from the start of the function.  */
647             if (info->sections)
648               info->function_start_offset = value;
649             info->within_function = TRUE;
650           }
651
652         if (! parse_stab_string (dhandle, info, type, desc, value, string))
653           return FALSE;
654       }
655       break;
656
657     case N_OPT:
658       if (string != NULL && strcmp (string, "gcc2_compiled.") == 0)
659         info->gcc_compiled = 2;
660       else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
661         info->gcc_compiled = 1;
662       else
663         info->n_opt_found = TRUE;
664       break;
665
666     case N_OBJ:
667     case N_ENDM:
668     case N_MAIN:
669     case N_WARNING:
670       break;
671     }
672
673   return TRUE;
674 }
675
676 /* Parse the stabs string.  */
677
678 static bfd_boolean
679 parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
680                    int desc ATTRIBUTE_UNUSED, bfd_vma value, const char *string)
681 {
682   const char *p;
683   char *name;
684   int type;
685   debug_type dtype;
686   bfd_boolean synonym;
687   bfd_boolean self_crossref;
688   debug_type *slot;
689
690   p = strchr (string, ':');
691   if (p == NULL)
692     return TRUE;
693
694   while (p[1] == ':')
695     {
696       p += 2;
697       p = strchr (p, ':');
698       if (p == NULL)
699         {
700           bad_stab (string);
701           return FALSE;
702         }
703     }
704
705   /* FIXME: Sometimes the special C++ names start with '.'.  */
706   name = NULL;
707   if (string[0] == '$')
708     {
709       switch (string[1])
710         {
711         case 't':
712           name = "this";
713           break;
714         case 'v':
715           /* Was: name = "vptr"; */
716           break;
717         case 'e':
718           name = "eh_throw";
719           break;
720         case '_':
721           /* This was an anonymous type that was never fixed up.  */
722           break;
723         case 'X':
724           /* SunPRO (3.0 at least) static variable encoding.  */
725           break;
726         default:
727           warn_stab (string, _("unknown C++ encoded name"));
728           break;
729         }
730     }
731
732   if (name == NULL)
733     {
734       if (p == string || (string[0] == ' ' && p == string + 1))
735         name = NULL;
736       else
737         name = savestring (string, p - string);
738     }
739
740   ++p;
741   if (ISDIGIT (*p) || *p == '(' || *p == '-')
742     type = 'l';
743   else
744     type = *p++;
745
746   switch (type)
747     {
748     case 'c':
749       /* c is a special case, not followed by a type-number.
750          SYMBOL:c=iVALUE for an integer constant symbol.
751          SYMBOL:c=rVALUE for a floating constant symbol.
752          SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
753          e.g. "b:c=e6,0" for "const b = blob1"
754          (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
755       if (*p != '=')
756         {
757           bad_stab (string);
758           return FALSE;
759         }
760       ++p;
761       switch (*p++)
762         {
763         case 'r':
764           /* Floating point constant.  */
765           if (! debug_record_float_const (dhandle, name, atof (p)))
766             return FALSE;
767           break;
768         case 'i':
769           /* Integer constant.  */
770           /* Defining integer constants this way is kind of silly,
771              since 'e' constants allows the compiler to give not only
772              the value, but the type as well.  C has at least int,
773              long, unsigned int, and long long as constant types;
774              other languages probably should have at least unsigned as
775              well as signed constants.  */
776           if (! debug_record_int_const (dhandle, name, atoi (p)))
777             return FALSE;
778           break;
779         case 'e':
780           /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
781              can be represented as integral.
782              e.g. "b:c=e6,0" for "const b = blob1"
783              (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;").  */
784           dtype = parse_stab_type (dhandle, info, (const char *) NULL,
785                                    &p, (debug_type **) NULL);
786           if (dtype == DEBUG_TYPE_NULL)
787             return FALSE;
788           if (*p != ',')
789             {
790               bad_stab (string);
791               return FALSE;
792             }
793           if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
794             return FALSE;
795           break;
796         default:
797           bad_stab (string);
798           return FALSE;
799         }
800
801       break;
802
803     case 'C':
804       /* The name of a caught exception.  */
805       dtype = parse_stab_type (dhandle, info, (const char *) NULL,
806                                &p, (debug_type **) NULL);
807       if (dtype == DEBUG_TYPE_NULL)
808         return FALSE;
809       if (! debug_record_label (dhandle, name, dtype, value))
810         return FALSE;
811       break;
812
813     case 'f':
814     case 'F':
815       /* A function definition.  */
816       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
817                                (debug_type **) NULL);
818       if (dtype == DEBUG_TYPE_NULL)
819         return FALSE;
820       if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
821         return FALSE;
822
823       /* Sun acc puts declared types of arguments here.  We don't care
824          about their actual types (FIXME -- we should remember the whole
825          function prototype), but the list may define some new types
826          that we have to remember, so we must scan it now.  */
827       while (*p == ';')
828         {
829           ++p;
830           if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
831                                (debug_type **) NULL)
832               == DEBUG_TYPE_NULL)
833             return FALSE;
834         }
835
836       break;
837
838     case 'G':
839       {
840         char leading;
841         long c;
842         asymbol **ps;
843
844         /* A global symbol.  The value must be extracted from the
845            symbol table.  */
846         dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
847                                  (debug_type **) NULL);
848         if (dtype == DEBUG_TYPE_NULL)
849           return FALSE;
850         leading = bfd_get_symbol_leading_char (info->abfd);
851         for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps)
852           {
853             const char *n;
854
855             n = bfd_asymbol_name (*ps);
856             if (leading != '\0' && *n == leading)
857               ++n;
858             if (*n == *name && strcmp (n, name) == 0)
859               break;
860           }
861         if (c > 0)
862           value = bfd_asymbol_value (*ps);
863         if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
864                                     value))
865           return FALSE;
866       }
867       break;
868
869       /* This case is faked by a conditional above, when there is no
870          code letter in the dbx data.  Dbx data never actually
871          contains 'l'.  */
872     case 'l':
873     case 's':
874       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
875                                (debug_type **) NULL);
876       if (dtype == DEBUG_TYPE_NULL)
877         return FALSE;
878       if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
879                                   value))
880         return FALSE;
881       break;
882
883     case 'p':
884       /* A function parameter.  */
885       if (*p != 'F')
886         dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
887                                  (debug_type **) NULL);
888       else
889         {
890         /* pF is a two-letter code that means a function parameter in
891            Fortran.  The type-number specifies the type of the return
892            value.  Translate it into a pointer-to-function type.  */
893           ++p;
894           dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
895                                    (debug_type **) NULL);
896           if (dtype != DEBUG_TYPE_NULL)
897             {
898               debug_type ftype;
899
900               ftype = debug_make_function_type (dhandle, dtype,
901                                                 (debug_type *) NULL, FALSE);
902               dtype = debug_make_pointer_type (dhandle, ftype);
903             }
904         }
905       if (dtype == DEBUG_TYPE_NULL)
906         return FALSE;
907       if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
908                                     value))
909         return FALSE;
910
911       /* FIXME: At this point gdb considers rearranging the parameter
912          address on a big endian machine if it is smaller than an int.
913          We have no way to do that, since we don't really know much
914          about the target.  */
915       break;
916
917     case 'P':
918       if (stabtype == N_FUN)
919         {
920           /* Prototype of a function referenced by this file.  */
921           while (*p == ';')
922             {
923               ++p;
924               if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
925                                    (debug_type **) NULL)
926                   == DEBUG_TYPE_NULL)
927                 return FALSE;
928             }
929           break;
930         }
931       /* Fall through.  */
932     case 'R':
933       /* Parameter which is in a register.  */
934       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
935                                (debug_type **) NULL);
936       if (dtype == DEBUG_TYPE_NULL)
937         return FALSE;
938       if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
939                                     value))
940         return FALSE;
941       break;
942
943     case 'r':
944       /* Register variable (either global or local).  */
945       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
946                                (debug_type **) NULL);
947       if (dtype == DEBUG_TYPE_NULL)
948         return FALSE;
949       if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
950                                   value))
951         return FALSE;
952
953       /* FIXME: At this point gdb checks to combine pairs of 'p' and
954          'r' stabs into a single 'P' stab.  */
955       break;
956
957     case 'S':
958       /* Static symbol at top level of file.  */
959       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
960                                (debug_type **) NULL);
961       if (dtype == DEBUG_TYPE_NULL)
962         return FALSE;
963       if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
964                                   value))
965         return FALSE;
966       break;
967
968     case 't':
969       /* A typedef.  */
970       dtype = parse_stab_type (dhandle, info, name, &p, &slot);
971       if (dtype == DEBUG_TYPE_NULL)
972         return FALSE;
973       if (name == NULL)
974         {
975           /* A nameless type.  Nothing to do.  */
976           return TRUE;
977         }
978
979       dtype = debug_name_type (dhandle, name, dtype);
980       if (dtype == DEBUG_TYPE_NULL)
981         return FALSE;
982
983       if (slot != NULL)
984         *slot = dtype;
985
986       break;
987
988     case 'T':
989       /* Struct, union, or enum tag.  For GNU C++, this can be be followed
990          by 't' which means we are typedef'ing it as well.  */
991       if (*p != 't')
992         {
993           synonym = FALSE;
994           /* FIXME: gdb sets synonym to TRUE if the current language
995              is C++.  */
996         }
997       else
998         {
999           synonym = TRUE;
1000           ++p;
1001         }
1002
1003       dtype = parse_stab_type (dhandle, info, name, &p, &slot);
1004       if (dtype == DEBUG_TYPE_NULL)
1005         return FALSE;
1006       if (name == NULL)
1007         return TRUE;
1008
1009       /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1010          a cross reference to itself.  These are generated by some
1011          versions of g++.  */
1012       self_crossref = info->self_crossref;
1013
1014       dtype = debug_tag_type (dhandle, name, dtype);
1015       if (dtype == DEBUG_TYPE_NULL)
1016         return FALSE;
1017       if (slot != NULL)
1018         *slot = dtype;
1019
1020       /* See if we have a cross reference to this tag which we can now
1021          fill in.  Avoid filling in a cross reference to ourselves,
1022          because that would lead to circular debugging information.  */
1023       if (! self_crossref)
1024         {
1025           register struct stab_tag **pst;
1026
1027           for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next)
1028             {
1029               if ((*pst)->name[0] == name[0]
1030                   && strcmp ((*pst)->name, name) == 0)
1031                 {
1032                   (*pst)->slot = dtype;
1033                   *pst = (*pst)->next;
1034                   break;
1035                 }
1036             }
1037         }
1038
1039       if (synonym)
1040         {
1041           dtype = debug_name_type (dhandle, name, dtype);
1042           if (dtype == DEBUG_TYPE_NULL)
1043             return FALSE;
1044
1045           if (slot != NULL)
1046             *slot = dtype;
1047         }
1048
1049       break;
1050
1051     case 'V':
1052       /* Static symbol of local scope */
1053       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1054                                (debug_type **) NULL);
1055       if (dtype == DEBUG_TYPE_NULL)
1056         return FALSE;
1057       /* FIXME: gdb checks os9k_stabs here.  */
1058       if (! stab_record_variable (dhandle, info, name, dtype,
1059                                   DEBUG_LOCAL_STATIC, value))
1060         return FALSE;
1061       break;
1062
1063     case 'v':
1064       /* Reference parameter.  */
1065       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1066                                (debug_type **) NULL);
1067       if (dtype == DEBUG_TYPE_NULL)
1068         return FALSE;
1069       if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
1070                                     value))
1071         return FALSE;
1072       break;
1073
1074     case 'a':
1075       /* Reference parameter which is in a register.  */
1076       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1077                                (debug_type **) NULL);
1078       if (dtype == DEBUG_TYPE_NULL)
1079         return FALSE;
1080       if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
1081                                     value))
1082         return FALSE;
1083       break;
1084
1085     case 'X':
1086       /* This is used by Sun FORTRAN for "function result value".
1087          Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1088          that Pascal uses it too, but when I tried it Pascal used
1089          "x:3" (local symbol) instead.  */
1090       dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
1091                                (debug_type **) NULL);
1092       if (dtype == DEBUG_TYPE_NULL)
1093         return FALSE;
1094       if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
1095                                   value))
1096         return FALSE;
1097       break;
1098
1099     case 'Y':
1100       /* SUNPro C++ Namespace =Yn0.  */
1101       /* Skip the namespace mapping, as it is not used now.  */
1102       if (*(++p) == 'n' && *(++p) == '0')
1103         {
1104           /* =Yn0name; */
1105           while (*p != ';')
1106             ++p;
1107           ++p;
1108           return TRUE;
1109         }
1110       /* TODO SUNPro C++ support:
1111          Support default arguments after F,P parameters
1112          Ya = Anonymous unions
1113          YM,YD = Pointers to class members
1114          YT,YI = Templates
1115          YR = Run-time type information (RTTI)  */
1116
1117       /* Fall through.  */
1118
1119     default:
1120       bad_stab (string);
1121       return FALSE;
1122     }
1123
1124   /* FIXME: gdb converts structure values to structure pointers in a
1125      couple of cases, depending upon the target.  */
1126
1127   return TRUE;
1128 }
1129
1130 /* Parse a stabs type.  The typename argument is non-NULL if this is a
1131    typedef or a tag definition.  The pp argument points to the stab
1132    string, and is updated.  The slotp argument points to a place to
1133    store the slot used if the type is being defined.  */
1134
1135 static debug_type
1136 parse_stab_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, debug_type **slotp)
1137 {
1138   const char *orig;
1139   int typenums[2];
1140   int size;
1141   bfd_boolean stringp;
1142   int descriptor;
1143   debug_type dtype;
1144
1145   if (slotp != NULL)
1146     *slotp = NULL;
1147
1148   orig = *pp;
1149
1150   size = -1;
1151   stringp = FALSE;
1152
1153   info->self_crossref = FALSE;
1154
1155   /* Read type number if present.  The type number may be omitted.
1156      for instance in a two-dimensional array declared with type
1157      "ar1;1;10;ar1;1;10;4".  */
1158   if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-')
1159     {
1160       /* 'typenums=' not present, type is anonymous.  Read and return
1161          the definition, but don't put it in the type vector.  */
1162       typenums[0] = typenums[1] = -1;
1163     }
1164   else
1165     {
1166       if (! parse_stab_type_number (pp, typenums))
1167         return DEBUG_TYPE_NULL;
1168
1169       if (**pp != '=')
1170         /* Type is not being defined here.  Either it already
1171            exists, or this is a forward reference to it.  */
1172         return stab_find_type (dhandle, info, typenums);
1173
1174       /* Only set the slot if the type is being defined.  This means
1175          that the mapping from type numbers to types will only record
1176          the name of the typedef which defines a type.  If we don't do
1177          this, then something like
1178              typedef int foo;
1179              int i;
1180          will record that i is of type foo.  Unfortunately, stabs
1181          information is ambiguous about variable types.  For this code,
1182              typedef int foo;
1183              int i;
1184              foo j;
1185          the stabs information records both i and j as having the same
1186          type.  This could be fixed by patching the compiler.  */
1187       if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0)
1188         *slotp = stab_find_slot (info, typenums);
1189
1190       /* Type is being defined here.  */
1191       /* Skip the '='.  */
1192       ++*pp;
1193
1194       while (**pp == '@')
1195         {
1196           const char *p = *pp + 1;
1197           const char *attr;
1198
1199           if (ISDIGIT (*p) || *p == '(' || *p == '-')
1200             /* Member type.  */
1201             break;
1202
1203           /* Type attributes.  */
1204           attr = p;
1205
1206           for (; *p != ';'; ++p)
1207             {
1208               if (*p == '\0')
1209                 {
1210                   bad_stab (orig);
1211                   return DEBUG_TYPE_NULL;
1212                 }
1213             }
1214           *pp = p + 1;
1215
1216           switch (*attr)
1217             {
1218             case 's':
1219               size = atoi (attr + 1);
1220               size /= 8;  /* Size is in bits.  We store it in bytes.  */
1221               if (size <= 0)
1222                 size = -1;
1223               break;
1224
1225             case 'S':
1226               stringp = TRUE;
1227               break;
1228
1229             default:
1230               /* Ignore unrecognized type attributes, so future
1231                  compilers can invent new ones.  */
1232               break;
1233             }
1234         }
1235     }
1236
1237   descriptor = **pp;
1238   ++*pp;
1239
1240   switch (descriptor)
1241     {
1242     case 'x':
1243       {
1244         enum debug_type_kind code;
1245         const char *q1, *q2, *p;
1246
1247         /* A cross reference to another type.  */
1248         switch (**pp)
1249           {
1250           case 's':
1251             code = DEBUG_KIND_STRUCT;
1252             break;
1253           case 'u':
1254             code = DEBUG_KIND_UNION;
1255             break;
1256           case 'e':
1257             code = DEBUG_KIND_ENUM;
1258             break;
1259           default:
1260             /* Complain and keep going, so compilers can invent new
1261                cross-reference types.  */
1262             warn_stab (orig, _("unrecognized cross reference type"));
1263             code = DEBUG_KIND_STRUCT;
1264             break;
1265           }
1266         ++*pp;
1267
1268         q1 = strchr (*pp, '<');
1269         p = strchr (*pp, ':');
1270         if (p == NULL)
1271           {
1272             bad_stab (orig);
1273             return DEBUG_TYPE_NULL;
1274           }
1275         if (q1 != NULL && p > q1 && p[1] == ':')
1276           {
1277             int nest = 0;
1278
1279             for (q2 = q1; *q2 != '\0'; ++q2)
1280               {
1281                 if (*q2 == '<')
1282                   ++nest;
1283                 else if (*q2 == '>')
1284                   --nest;
1285                 else if (*q2 == ':' && nest == 0)
1286                   break;
1287               }
1288             p = q2;
1289             if (*p != ':')
1290               {
1291                 bad_stab (orig);
1292                 return DEBUG_TYPE_NULL;
1293               }
1294           }
1295
1296         /* Some versions of g++ can emit stabs like
1297                fleep:T20=xsfleep:
1298            which define structures in terms of themselves.  We need to
1299            tell the caller to avoid building a circular structure.  */
1300         if (type_name != NULL
1301             && strncmp (type_name, *pp, p - *pp) == 0
1302             && type_name[p - *pp] == '\0')
1303           info->self_crossref = TRUE;
1304
1305         dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
1306
1307         *pp = p + 1;
1308       }
1309       break;
1310
1311     case '-':
1312     case '0':
1313     case '1':
1314     case '2':
1315     case '3':
1316     case '4':
1317     case '5':
1318     case '6':
1319     case '7':
1320     case '8':
1321     case '9':
1322     case '(':
1323       {
1324         const char *hold;
1325         int xtypenums[2];
1326
1327         /* This type is defined as another type.  */
1328         (*pp)--;
1329         hold = *pp;
1330
1331         /* Peek ahead at the number to detect void.  */
1332         if (! parse_stab_type_number (pp, xtypenums))
1333           return DEBUG_TYPE_NULL;
1334
1335         if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1])
1336           {
1337             /* This type is being defined as itself, which means that
1338                it is void.  */
1339             dtype = debug_make_void_type (dhandle);
1340           }
1341         else
1342           {
1343             *pp = hold;
1344
1345             /* Go back to the number and have parse_stab_type get it.
1346                This means that we can deal with something like
1347                t(1,2)=(3,4)=... which the Lucid compiler uses.  */
1348             dtype = parse_stab_type (dhandle, info, (const char *) NULL,
1349                                      pp, (debug_type **) NULL);
1350             if (dtype == DEBUG_TYPE_NULL)
1351               return DEBUG_TYPE_NULL;
1352           }
1353
1354         if (typenums[0] != -1)
1355           {
1356             if (! stab_record_type (dhandle, info, typenums, dtype))
1357               return DEBUG_TYPE_NULL;
1358           }
1359
1360         break;
1361       }
1362
1363     case '*':
1364       dtype = debug_make_pointer_type (dhandle,
1365                                        parse_stab_type (dhandle, info,
1366                                                         (const char *) NULL,
1367                                                         pp,
1368                                                         (debug_type **) NULL));
1369       break;
1370
1371     case '&':
1372       /* Reference to another type.  */
1373       dtype = (debug_make_reference_type
1374                (dhandle,
1375                 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1376                                  (debug_type **) NULL)));
1377       break;
1378
1379     case 'f':
1380       /* Function returning another type.  */
1381       /* FIXME: gdb checks os9k_stabs here.  */
1382       dtype = (debug_make_function_type
1383                (dhandle,
1384                 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1385                                  (debug_type **) NULL),
1386                 (debug_type *) NULL, FALSE));
1387       break;
1388
1389     case 'k':
1390       /* Const qualifier on some type (Sun).  */
1391       /* FIXME: gdb accepts 'c' here if os9k_stabs.  */
1392       dtype = debug_make_const_type (dhandle,
1393                                      parse_stab_type (dhandle, info,
1394                                                       (const char *) NULL,
1395                                                       pp,
1396                                                       (debug_type **) NULL));
1397       break;
1398
1399     case 'B':
1400       /* Volatile qual on some type (Sun).  */
1401       /* FIXME: gdb accepts 'i' here if os9k_stabs.  */
1402       dtype = (debug_make_volatile_type
1403                (dhandle,
1404                 parse_stab_type (dhandle, info, (const char *) NULL, pp,
1405                                  (debug_type **) NULL)));
1406       break;
1407
1408     case '@':
1409       /* Offset (class & variable) type.  This is used for a pointer
1410          relative to an object.  */
1411       {
1412         debug_type domain;
1413         debug_type memtype;
1414
1415         /* Member type.  */
1416
1417         domain = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1418                                   (debug_type **) NULL);
1419         if (domain == DEBUG_TYPE_NULL)
1420           return DEBUG_TYPE_NULL;
1421
1422         if (**pp != ',')
1423           {
1424             bad_stab (orig);
1425             return DEBUG_TYPE_NULL;
1426           }
1427         ++*pp;
1428
1429         memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
1430                                    (debug_type **) NULL);
1431         if (memtype == DEBUG_TYPE_NULL)
1432           return DEBUG_TYPE_NULL;
1433
1434         dtype = debug_make_offset_type (dhandle, domain, memtype);
1435       }
1436       break;
1437
1438     case '#':
1439       /* Method (class & fn) type.  */
1440       if (**pp == '#')
1441         {
1442           debug_type return_type;
1443
1444           ++*pp;
1445           return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1446                                          pp, (debug_type **) NULL);
1447           if (return_type == DEBUG_TYPE_NULL)
1448             return DEBUG_TYPE_NULL;
1449           if (**pp != ';')
1450             {
1451               bad_stab (orig);
1452               return DEBUG_TYPE_NULL;
1453             }
1454           ++*pp;
1455           dtype = debug_make_method_type (dhandle, return_type,
1456                                           DEBUG_TYPE_NULL,
1457                                           (debug_type *) NULL, FALSE);
1458         }
1459       else
1460         {
1461           debug_type domain;
1462           debug_type return_type;
1463           debug_type *args;
1464           unsigned int n;
1465           unsigned int alloc;
1466           bfd_boolean varargs;
1467
1468           domain = parse_stab_type (dhandle, info, (const char *) NULL,
1469                                     pp, (debug_type **) NULL);
1470           if (domain == DEBUG_TYPE_NULL)
1471             return DEBUG_TYPE_NULL;
1472
1473           if (**pp != ',')
1474             {
1475               bad_stab (orig);
1476               return DEBUG_TYPE_NULL;
1477             }
1478           ++*pp;
1479
1480           return_type = parse_stab_type (dhandle, info, (const char *) NULL,
1481                                          pp, (debug_type **) NULL);
1482           if (return_type == DEBUG_TYPE_NULL)
1483             return DEBUG_TYPE_NULL;
1484
1485           alloc = 10;
1486           args = (debug_type *) xmalloc (alloc * sizeof *args);
1487           n = 0;
1488           while (**pp != ';')
1489             {
1490               if (**pp != ',')
1491                 {
1492                   bad_stab (orig);
1493                   return DEBUG_TYPE_NULL;
1494                 }
1495               ++*pp;
1496
1497               if (n + 1 >= alloc)
1498                 {
1499                   alloc += 10;
1500                   args = ((debug_type *)
1501                           xrealloc (args, alloc * sizeof *args));
1502                 }
1503
1504               args[n] = parse_stab_type (dhandle, info, (const char *) NULL,
1505                                          pp, (debug_type **) NULL);
1506               if (args[n] == DEBUG_TYPE_NULL)
1507                 return DEBUG_TYPE_NULL;
1508               ++n;
1509             }
1510           ++*pp;
1511
1512           /* If the last type is not void, then this function takes a
1513              variable number of arguments.  Otherwise, we must strip
1514              the void type.  */
1515           if (n == 0
1516               || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
1517             varargs = TRUE;
1518           else
1519             {
1520               --n;
1521               varargs = FALSE;
1522             }
1523
1524           args[n] = DEBUG_TYPE_NULL;
1525
1526           dtype = debug_make_method_type (dhandle, return_type, domain, args,
1527                                           varargs);
1528         }
1529       break;
1530
1531     case 'r':
1532       /* Range type.  */
1533       dtype = parse_stab_range_type (dhandle, info, type_name, pp, typenums);
1534       break;
1535
1536     case 'b':
1537       /* FIXME: gdb checks os9k_stabs here.  */
1538       /* Sun ACC builtin int type.  */
1539       dtype = parse_stab_sun_builtin_type (dhandle, pp);
1540       break;
1541
1542     case 'R':
1543       /* Sun ACC builtin float type.  */
1544       dtype = parse_stab_sun_floating_type (dhandle, pp);
1545       break;
1546
1547     case 'e':
1548       /* Enumeration type.  */
1549       dtype = parse_stab_enum_type (dhandle, pp);
1550       break;
1551
1552     case 's':
1553     case 'u':
1554       /* Struct or union type.  */
1555       dtype = parse_stab_struct_type (dhandle, info, type_name, pp,
1556                                       descriptor == 's', typenums);
1557       break;
1558
1559     case 'a':
1560       /* Array type.  */
1561       if (**pp != 'r')
1562         {
1563           bad_stab (orig);
1564           return DEBUG_TYPE_NULL;
1565         }
1566       ++*pp;
1567
1568       dtype = parse_stab_array_type (dhandle, info, pp, stringp);
1569       break;
1570
1571     case 'S':
1572       dtype = debug_make_set_type (dhandle,
1573                                    parse_stab_type (dhandle, info,
1574                                                     (const char *) NULL,
1575                                                     pp,
1576                                                     (debug_type **) NULL),
1577                                    stringp);
1578       break;
1579
1580     default:
1581       bad_stab (orig);
1582       return DEBUG_TYPE_NULL;
1583     }
1584
1585   if (dtype == DEBUG_TYPE_NULL)
1586     return DEBUG_TYPE_NULL;
1587
1588   if (typenums[0] != -1)
1589     {
1590       if (! stab_record_type (dhandle, info, typenums, dtype))
1591         return DEBUG_TYPE_NULL;
1592     }
1593
1594   if (size != -1)
1595     {
1596       if (! debug_record_type_size (dhandle, dtype, (unsigned int) size))
1597         return DEBUG_TYPE_NULL;
1598     }
1599
1600   return dtype;
1601 }
1602
1603 /* Read a number by which a type is referred to in dbx data, or
1604    perhaps read a pair (FILENUM, TYPENUM) in parentheses.  Just a
1605    single number N is equivalent to (0,N).  Return the two numbers by
1606    storing them in the vector TYPENUMS.  */
1607
1608 static bfd_boolean
1609 parse_stab_type_number (const char **pp, int *typenums)
1610 {
1611   const char *orig;
1612
1613   orig = *pp;
1614
1615   if (**pp != '(')
1616     {
1617       typenums[0] = 0;
1618       typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1619     }
1620   else
1621     {
1622       ++*pp;
1623       typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL);
1624       if (**pp != ',')
1625         {
1626           bad_stab (orig);
1627           return FALSE;
1628         }
1629       ++*pp;
1630       typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL);
1631       if (**pp != ')')
1632         {
1633           bad_stab (orig);
1634           return FALSE;
1635         }
1636       ++*pp;
1637     }
1638
1639   return TRUE;
1640 }
1641
1642 /* Parse a range type.  */
1643
1644 static debug_type
1645 parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *type_name, const char **pp, const int *typenums)
1646 {
1647   const char *orig;
1648   int rangenums[2];
1649   bfd_boolean self_subrange;
1650   debug_type index_type;
1651   const char *s2, *s3;
1652   bfd_signed_vma n2, n3;
1653   bfd_boolean ov2, ov3;
1654
1655   orig = *pp;
1656
1657   index_type = DEBUG_TYPE_NULL;
1658
1659   /* First comes a type we are a subrange of.
1660      In C it is usually 0, 1 or the type being defined.  */
1661   if (! parse_stab_type_number (pp, rangenums))
1662     return DEBUG_TYPE_NULL;
1663
1664   self_subrange = (rangenums[0] == typenums[0]
1665                    && rangenums[1] == typenums[1]);
1666
1667   if (**pp == '=')
1668     {
1669       *pp = orig;
1670       index_type = parse_stab_type (dhandle, info, (const char *) NULL,
1671                                     pp, (debug_type **) NULL);
1672       if (index_type == DEBUG_TYPE_NULL)
1673         return DEBUG_TYPE_NULL;
1674     }
1675
1676   if (**pp == ';')
1677     ++*pp;
1678
1679   /* The remaining two operands are usually lower and upper bounds of
1680      the range.  But in some special cases they mean something else.  */
1681   s2 = *pp;
1682   n2 = parse_number (pp, &ov2);
1683   if (**pp != ';')
1684     {
1685       bad_stab (orig);
1686       return DEBUG_TYPE_NULL;
1687     }
1688   ++*pp;
1689
1690   s3 = *pp;
1691   n3 = parse_number (pp, &ov3);
1692   if (**pp != ';')
1693     {
1694       bad_stab (orig);
1695       return DEBUG_TYPE_NULL;
1696     }
1697   ++*pp;
1698
1699   if (ov2 || ov3)
1700     {
1701       /* gcc will emit range stabs for long long types.  Handle this
1702          as a special case.  FIXME: This needs to be more general.  */
1703 #define LLLOW   "01000000000000000000000;"
1704 #define LLHIGH   "0777777777777777777777;"
1705 #define ULLHIGH "01777777777777777777777;"
1706       if (index_type == DEBUG_TYPE_NULL)
1707         {
1708           if (CONST_STRNEQ (s2, LLLOW)
1709               && CONST_STRNEQ (s3, LLHIGH))
1710             return debug_make_int_type (dhandle, 8, FALSE);
1711           if (! ov2
1712               && n2 == 0
1713               && CONST_STRNEQ (s3, ULLHIGH))
1714             return debug_make_int_type (dhandle, 8, TRUE);
1715         }
1716
1717       warn_stab (orig, _("numeric overflow"));
1718     }
1719
1720   if (index_type == DEBUG_TYPE_NULL)
1721     {
1722       /* A type defined as a subrange of itself, with both bounds 0,
1723          is void.  */
1724       if (self_subrange && n2 == 0 && n3 == 0)
1725         return debug_make_void_type (dhandle);
1726
1727       /* A type defined as a subrange of itself, with n2 positive and
1728          n3 zero, is a complex type, and n2 is the number of bytes.  */
1729       if (self_subrange && n3 == 0 && n2 > 0)
1730         return debug_make_complex_type (dhandle, n2);
1731
1732       /* If n3 is zero and n2 is positive, this is a floating point
1733          type, and n2 is the number of bytes.  */
1734       if (n3 == 0 && n2 > 0)
1735         return debug_make_float_type (dhandle, n2);
1736
1737       /* If the upper bound is -1, this is an unsigned int.  */
1738       if (n2 == 0 && n3 == -1)
1739         {
1740           /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1741                  long long int:t6=r1;0;-1;
1742                  long long unsigned int:t7=r1;0;-1;
1743              We hack here to handle this reasonably.  */
1744           if (type_name != NULL)
1745             {
1746               if (strcmp (type_name, "long long int") == 0)
1747                 return debug_make_int_type (dhandle, 8, FALSE);
1748               else if (strcmp (type_name, "long long unsigned int") == 0)
1749                 return debug_make_int_type (dhandle, 8, TRUE);
1750             }
1751           /* FIXME: The size here really depends upon the target.  */
1752           return debug_make_int_type (dhandle, 4, TRUE);
1753         }
1754
1755       /* A range of 0 to 127 is char.  */
1756       if (self_subrange && n2 == 0 && n3 == 127)
1757         return debug_make_int_type (dhandle, 1, FALSE);
1758
1759       /* FIXME: gdb checks for the language CHILL here.  */
1760
1761       if (n2 == 0)
1762         {
1763           if (n3 < 0)
1764             return debug_make_int_type (dhandle, - n3, TRUE);
1765           else if (n3 == 0xff)
1766             return debug_make_int_type (dhandle, 1, TRUE);
1767           else if (n3 == 0xffff)
1768             return debug_make_int_type (dhandle, 2, TRUE);
1769           else if (n3 == (bfd_signed_vma) 0xffffffff)
1770             return debug_make_int_type (dhandle, 4, TRUE);
1771 #ifdef BFD64
1772           else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff))
1773             return debug_make_int_type (dhandle, 8, TRUE);
1774 #endif
1775         }
1776       else if (n3 == 0
1777                && n2 < 0
1778                && (self_subrange || n2 == -8))
1779         return debug_make_int_type (dhandle, - n2, TRUE);
1780       else if (n2 == - n3 - 1 || n2 == n3 + 1)
1781         {
1782           if (n3 == 0x7f)
1783             return debug_make_int_type (dhandle, 1, FALSE);
1784           else if (n3 == 0x7fff)
1785             return debug_make_int_type (dhandle, 2, FALSE);
1786           else if (n3 == 0x7fffffff)
1787             return debug_make_int_type (dhandle, 4, FALSE);
1788 #ifdef BFD64
1789           else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
1790             return debug_make_int_type (dhandle, 8, FALSE);
1791 #endif
1792         }
1793     }
1794
1795   /* At this point I don't have the faintest idea how to deal with a
1796      self_subrange type; I'm going to assume that this is used as an
1797      idiom, and that all of them are special cases.  So . . .  */
1798   if (self_subrange)
1799     {
1800       bad_stab (orig);
1801       return DEBUG_TYPE_NULL;
1802     }
1803
1804   index_type = stab_find_type (dhandle, info, rangenums);
1805   if (index_type == DEBUG_TYPE_NULL)
1806     {
1807       /* Does this actually ever happen?  Is that why we are worrying
1808          about dealing with it rather than just calling error_type?  */
1809       warn_stab (orig, _("missing index type"));
1810       index_type = debug_make_int_type (dhandle, 4, FALSE);
1811     }
1812
1813   return debug_make_range_type (dhandle, index_type, n2, n3);
1814 }
1815
1816 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1817    typedefs in every file (for int, long, etc):
1818
1819         type = b <signed> <width>; <offset>; <nbits>
1820         signed = u or s.  Possible c in addition to u or s (for char?).
1821         offset = offset from high order bit to start bit of type.
1822         width is # bytes in object of this type, nbits is # bits in type.
1823
1824    The width/offset stuff appears to be for small objects stored in
1825    larger ones (e.g. `shorts' in `int' registers).  We ignore it for now,
1826    FIXME.  */
1827
1828 static debug_type
1829 parse_stab_sun_builtin_type (void *dhandle, const char **pp)
1830 {
1831   const char *orig;
1832   bfd_boolean unsignedp;
1833   bfd_vma bits;
1834
1835   orig = *pp;
1836
1837   switch (**pp)
1838     {
1839     case 's':
1840       unsignedp = FALSE;
1841       break;
1842     case 'u':
1843       unsignedp = TRUE;
1844       break;
1845     default:
1846       bad_stab (orig);
1847       return DEBUG_TYPE_NULL;
1848     }
1849   ++*pp;
1850
1851   /* OpenSolaris source code indicates that one of "cbv" characters
1852      can come next and specify the intrinsic 'iformat' encoding.
1853      'c' is character encoding, 'b' is boolean encoding, and 'v' is
1854      varargs encoding.  This field can be safely ignored because
1855      the type of the field is determined from the bitwidth extracted
1856      below.  */
1857   if (**pp == 'c' || **pp == 'b' || **pp == 'v')
1858     ++*pp;
1859
1860   /* The first number appears to be the number of bytes occupied
1861      by this type, except that unsigned short is 4 instead of 2.
1862      Since this information is redundant with the third number,
1863      we will ignore it.  */
1864   (void) parse_number (pp, (bfd_boolean *) NULL);
1865   if (**pp != ';')
1866     {
1867       bad_stab (orig);
1868       return DEBUG_TYPE_NULL;
1869     }
1870   ++*pp;
1871
1872   /* The second number is always 0, so ignore it too.  */
1873   (void) parse_number (pp, (bfd_boolean *) NULL);
1874   if (**pp != ';')
1875     {
1876       bad_stab (orig);
1877       return DEBUG_TYPE_NULL;
1878     }
1879   ++*pp;
1880
1881   /* The third number is the number of bits for this type.  */
1882   bits = parse_number (pp, (bfd_boolean *) NULL);
1883
1884   /* The type *should* end with a semicolon.  If it are embedded
1885      in a larger type the semicolon may be the only way to know where
1886      the type ends.  If this type is at the end of the stabstring we
1887      can deal with the omitted semicolon (but we don't have to like
1888      it).  Don't bother to complain(), Sun's compiler omits the semicolon
1889      for "void".  */
1890   if (**pp == ';')
1891     ++*pp;
1892
1893   if (bits == 0)
1894     return debug_make_void_type (dhandle);
1895
1896   return debug_make_int_type (dhandle, bits / 8, unsignedp);
1897 }
1898
1899 /* Parse a builtin floating type generated by the Sun compiler.  */
1900
1901 static debug_type
1902 parse_stab_sun_floating_type (void *dhandle, const char **pp)
1903 {
1904   const char *orig;
1905   bfd_vma details;
1906   bfd_vma bytes;
1907
1908   orig = *pp;
1909
1910   /* The first number has more details about the type, for example
1911      FN_COMPLEX.  */
1912   details = parse_number (pp, (bfd_boolean *) NULL);
1913   if (**pp != ';')
1914     {
1915       bad_stab (orig);
1916       return DEBUG_TYPE_NULL;
1917     }
1918
1919   /* The second number is the number of bytes occupied by this type */
1920   bytes = parse_number (pp, (bfd_boolean *) NULL);
1921   if (**pp != ';')
1922     {
1923       bad_stab (orig);
1924       return DEBUG_TYPE_NULL;
1925     }
1926
1927   if (details == NF_COMPLEX
1928       || details == NF_COMPLEX16
1929       || details == NF_COMPLEX32)
1930     return debug_make_complex_type (dhandle, bytes);
1931
1932   return debug_make_float_type (dhandle, bytes);
1933 }
1934
1935 /* Handle an enum type.  */
1936
1937 static debug_type
1938 parse_stab_enum_type (void *dhandle, const char **pp)
1939 {
1940   const char *orig;
1941   const char **names;
1942   bfd_signed_vma *values;
1943   unsigned int n;
1944   unsigned int alloc;
1945
1946   orig = *pp;
1947
1948   /* FIXME: gdb checks os9k_stabs here.  */
1949
1950   /* The aix4 compiler emits an extra field before the enum members;
1951      my guess is it's a type of some sort.  Just ignore it.  */
1952   if (**pp == '-')
1953     {
1954       while (**pp != ':')
1955         ++*pp;
1956       ++*pp;
1957     }
1958
1959   /* Read the value-names and their values.
1960      The input syntax is NAME:VALUE,NAME:VALUE, and so on.
1961      A semicolon or comma instead of a NAME means the end.  */
1962   alloc = 10;
1963   names = (const char **) xmalloc (alloc * sizeof *names);
1964   values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values);
1965   n = 0;
1966   while (**pp != '\0' && **pp != ';' && **pp != ',')
1967     {
1968       const char *p;
1969       char *name;
1970       bfd_signed_vma val;
1971
1972       p = *pp;
1973       while (*p != ':')
1974         ++p;
1975
1976       name = savestring (*pp, p - *pp);
1977
1978       *pp = p + 1;
1979       val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
1980       if (**pp != ',')
1981         {
1982           bad_stab (orig);
1983           return DEBUG_TYPE_NULL;
1984         }
1985       ++*pp;
1986
1987       if (n + 1 >= alloc)
1988         {
1989           alloc += 10;
1990           names = ((const char **)
1991                    xrealloc (names, alloc * sizeof *names));
1992           values = ((bfd_signed_vma *)
1993                     xrealloc (values, alloc * sizeof *values));
1994         }
1995
1996       names[n] = name;
1997       values[n] = val;
1998       ++n;
1999     }
2000
2001   names[n] = NULL;
2002   values[n] = 0;
2003
2004   if (**pp == ';')
2005     ++*pp;
2006
2007   return debug_make_enum_type (dhandle, names, values);
2008 }
2009
2010 /* Read the description of a structure (or union type) and return an object
2011    describing the type.
2012
2013    PP points to a character pointer that points to the next unconsumed token
2014    in the stabs string.  For example, given stabs "A:T4=s4a:1,0,32;;",
2015    *PP will point to "4a:1,0,32;;".  */
2016
2017 static debug_type
2018 parse_stab_struct_type (void *dhandle, struct stab_handle *info,
2019                         const char *tagname, const char **pp,
2020                         bfd_boolean structp, const int *typenums)
2021 {
2022   bfd_vma size;
2023   debug_baseclass *baseclasses;
2024   debug_field *fields;
2025   bfd_boolean statics;
2026   debug_method *methods;
2027   debug_type vptrbase;
2028   bfd_boolean ownvptr;
2029
2030   /* Get the size.  */
2031   size = parse_number (pp, (bfd_boolean *) NULL);
2032
2033   /* Get the other information.  */
2034   if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses)
2035       || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics)
2036       || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods)
2037       || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase,
2038                                    &ownvptr))
2039     return DEBUG_TYPE_NULL;
2040
2041   if (! statics
2042       && baseclasses == NULL
2043       && methods == NULL
2044       && vptrbase == DEBUG_TYPE_NULL
2045       && ! ownvptr)
2046     return debug_make_struct_type (dhandle, structp, size, fields);
2047
2048   return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2049                                  methods, vptrbase, ownvptr);
2050 }
2051
2052 /* The stabs for C++ derived classes contain baseclass information which
2053    is marked by a '!' character after the total size.  This function is
2054    called when we encounter the baseclass marker, and slurps up all the
2055    baseclass information.
2056
2057    Immediately following the '!' marker is the number of base classes that
2058    the class is derived from, followed by information for each base class.
2059    For each base class, there are two visibility specifiers, a bit offset
2060    to the base class information within the derived class, a reference to
2061    the type for the base class, and a terminating semicolon.
2062
2063    A typical example, with two base classes, would be "!2,020,19;0264,21;".
2064                                                        ^^ ^ ^ ^  ^ ^  ^
2065         Baseclass information marker __________________|| | | |  | |  |
2066         Number of baseclasses __________________________| | | |  | |  |
2067         Visibility specifiers (2) ________________________| | |  | |  |
2068         Offset in bits from start of class _________________| |  | |  |
2069         Type number for base class ___________________________|  | |  |
2070         Visibility specifiers (2) _______________________________| |  |
2071         Offset in bits from start of class ________________________|  |
2072         Type number of base class ____________________________________|
2073
2074   Return TRUE for success, FALSE for failure.  */
2075
2076 static bfd_boolean
2077 parse_stab_baseclasses (void *dhandle, struct stab_handle *info,
2078                         const char **pp, debug_baseclass **retp)
2079 {
2080   const char *orig;
2081   unsigned int c, i;
2082   debug_baseclass *classes;
2083
2084   *retp = NULL;
2085
2086   orig = *pp;
2087
2088   if (**pp != '!')
2089     {
2090       /* No base classes.  */
2091       return TRUE;
2092     }
2093   ++*pp;
2094
2095   c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL);
2096
2097   if (**pp != ',')
2098     {
2099       bad_stab (orig);
2100       return FALSE;
2101     }
2102   ++*pp;
2103
2104   classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2105
2106   for (i = 0; i < c; i++)
2107     {
2108       bfd_boolean is_virtual;
2109       enum debug_visibility visibility;
2110       bfd_vma bitpos;
2111       debug_type type;
2112
2113       switch (**pp)
2114         {
2115         case '0':
2116           is_virtual = FALSE;
2117           break;
2118         case '1':
2119           is_virtual = TRUE;
2120           break;
2121         default:
2122           warn_stab (orig, _("unknown virtual character for baseclass"));
2123           is_virtual = FALSE;
2124           break;
2125         }
2126       ++*pp;
2127
2128       switch (**pp)
2129         {
2130         case '0':
2131           visibility = DEBUG_VISIBILITY_PRIVATE;
2132           break;
2133         case '1':
2134           visibility = DEBUG_VISIBILITY_PROTECTED;
2135           break;
2136         case '2':
2137           visibility = DEBUG_VISIBILITY_PUBLIC;
2138           break;
2139         default:
2140           warn_stab (orig, _("unknown visibility character for baseclass"));
2141           visibility = DEBUG_VISIBILITY_PUBLIC;
2142           break;
2143         }
2144       ++*pp;
2145
2146       /* The remaining value is the bit offset of the portion of the
2147          object corresponding to this baseclass.  Always zero in the
2148          absence of multiple inheritance.  */
2149       bitpos = parse_number (pp, (bfd_boolean *) NULL);
2150       if (**pp != ',')
2151         {
2152           bad_stab (orig);
2153           return FALSE;
2154         }
2155       ++*pp;
2156
2157       type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2158                               (debug_type **) NULL);
2159       if (type == DEBUG_TYPE_NULL)
2160         return FALSE;
2161
2162       classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
2163                                          visibility);
2164       if (classes[i] == DEBUG_BASECLASS_NULL)
2165         return FALSE;
2166
2167       if (**pp != ';')
2168         return FALSE;
2169       ++*pp;
2170     }
2171
2172   classes[i] = DEBUG_BASECLASS_NULL;
2173
2174   *retp = classes;
2175
2176   return TRUE;
2177 }
2178
2179 /* Read struct or class data fields.  They have the form:
2180
2181         NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2182
2183    At the end, we see a semicolon instead of a field.
2184
2185    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2186    a static field.
2187
2188    The optional VISIBILITY is one of:
2189
2190         '/0'    (VISIBILITY_PRIVATE)
2191         '/1'    (VISIBILITY_PROTECTED)
2192         '/2'    (VISIBILITY_PUBLIC)
2193         '/9'    (VISIBILITY_IGNORE)
2194
2195    or nothing, for C style fields with public visibility.
2196
2197    Returns 1 for success, 0 for failure.  */
2198
2199 static bfd_boolean
2200 parse_stab_struct_fields (void *dhandle, struct stab_handle *info,
2201                           const char **pp, debug_field **retp,
2202                           bfd_boolean *staticsp)
2203 {
2204   const char *orig;
2205   const char *p;
2206   debug_field *fields;
2207   unsigned int c;
2208   unsigned int alloc;
2209
2210   *retp = NULL;
2211   *staticsp = FALSE;
2212
2213   orig = *pp;
2214
2215   c = 0;
2216   alloc = 10;
2217   fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2218   while (**pp != ';')
2219     {
2220       /* FIXME: gdb checks os9k_stabs here.  */
2221
2222       p = *pp;
2223
2224       /* Add 1 to c to leave room for NULL pointer at end.  */
2225       if (c + 1 >= alloc)
2226         {
2227           alloc += 10;
2228           fields = ((debug_field *)
2229                     xrealloc (fields, alloc * sizeof *fields));
2230         }
2231
2232       /* If it starts with CPLUS_MARKER it is a special abbreviation,
2233          unless the CPLUS_MARKER is followed by an underscore, in
2234          which case it is just the name of an anonymous type, which we
2235          should handle like any other type name.  We accept either '$'
2236          or '.', because a field name can never contain one of these
2237          characters except as a CPLUS_MARKER.  */
2238
2239       if ((*p == '$' || *p == '.') && p[1] != '_')
2240         {
2241           ++*pp;
2242           if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c))
2243             return FALSE;
2244           ++c;
2245           continue;
2246         }
2247
2248       /* Look for the ':' that separates the field name from the field
2249          values.  Data members are delimited by a single ':', while member
2250          functions are delimited by a pair of ':'s.  When we hit the member
2251          functions (if any), terminate scan loop and return.  */
2252
2253       p = strchr (p, ':');
2254       if (p == NULL)
2255         {
2256           bad_stab (orig);
2257           return FALSE;
2258         }
2259
2260       if (p[1] == ':')
2261         break;
2262
2263       if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2264                                          staticsp))
2265         return FALSE;
2266
2267       ++c;
2268     }
2269
2270   fields[c] = DEBUG_FIELD_NULL;
2271
2272   *retp = fields;
2273
2274   return TRUE;
2275 }
2276
2277 /* Special GNU C++ name.  */
2278
2279 static bfd_boolean
2280 parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info,
2281                        const char **pp, debug_field *retp)
2282 {
2283   const char *orig;
2284   int cpp_abbrev;
2285   debug_type context;
2286   const char *name;
2287   const char *type_name;
2288   debug_type type;
2289   bfd_vma bitpos;
2290
2291   *retp = DEBUG_FIELD_NULL;
2292
2293   orig = *pp;
2294
2295   if (**pp != 'v')
2296     {
2297       bad_stab (*pp);
2298       return FALSE;
2299     }
2300   ++*pp;
2301
2302   cpp_abbrev = **pp;
2303   ++*pp;
2304
2305   /* At this point, *pp points to something like "22:23=*22...", where
2306      the type number before the ':' is the "context" and everything
2307      after is a regular type definition.  Lookup the type, find it's
2308      name, and construct the field name.  */
2309
2310   context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2311                              (debug_type **) NULL);
2312   if (context == DEBUG_TYPE_NULL)
2313     return FALSE;
2314
2315   switch (cpp_abbrev)
2316     {
2317     case 'f':
2318       /* $vf -- a virtual function table pointer.  */
2319       name = "_vptr$";
2320       break;
2321     case 'b':
2322       /* $vb -- a virtual bsomethingorother */
2323       type_name = debug_get_type_name (dhandle, context);
2324       if (type_name == NULL)
2325         {
2326           warn_stab (orig, _("unnamed $vb type"));
2327           type_name = "FOO";
2328         }
2329       name = concat ("_vb$", type_name, (const char *) NULL);
2330       break;
2331     default:
2332       warn_stab (orig, _("unrecognized C++ abbreviation"));
2333       name = "INVALID_CPLUSPLUS_ABBREV";
2334       break;
2335     }
2336
2337   if (**pp != ':')
2338     {
2339       bad_stab (orig);
2340       return FALSE;
2341     }
2342   ++*pp;
2343
2344   type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2345                           (debug_type **) NULL);
2346   if (**pp != ',')
2347     {
2348       bad_stab (orig);
2349       return FALSE;
2350     }
2351   ++*pp;
2352
2353   bitpos = parse_number (pp, (bfd_boolean *) NULL);
2354   if (**pp != ';')
2355     {
2356       bad_stab (orig);
2357       return FALSE;
2358     }
2359   ++*pp;
2360
2361   *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2362                             DEBUG_VISIBILITY_PRIVATE);
2363   if (*retp == DEBUG_FIELD_NULL)
2364     return FALSE;
2365
2366   return TRUE;
2367 }
2368
2369 /* Parse a single field in a struct or union.  */
2370
2371 static bfd_boolean
2372 parse_stab_one_struct_field (void *dhandle, struct stab_handle *info,
2373                              const char **pp, const char *p,
2374                              debug_field *retp, bfd_boolean *staticsp)
2375 {
2376   const char *orig;
2377   char *name;
2378   enum debug_visibility visibility;
2379   debug_type type;
2380   bfd_vma bitpos;
2381   bfd_vma bitsize;
2382
2383   orig = *pp;
2384
2385   /* FIXME: gdb checks ARM_DEMANGLING here.  */
2386
2387   name = savestring (*pp, p - *pp);
2388
2389   *pp = p + 1;
2390
2391   if (**pp != '/')
2392     visibility = DEBUG_VISIBILITY_PUBLIC;
2393   else
2394     {
2395       ++*pp;
2396       switch (**pp)
2397         {
2398         case '0':
2399           visibility = DEBUG_VISIBILITY_PRIVATE;
2400           break;
2401         case '1':
2402           visibility = DEBUG_VISIBILITY_PROTECTED;
2403           break;
2404         case '2':
2405           visibility = DEBUG_VISIBILITY_PUBLIC;
2406           break;
2407         default:
2408           warn_stab (orig, _("unknown visibility character for field"));
2409           visibility = DEBUG_VISIBILITY_PUBLIC;
2410           break;
2411         }
2412       ++*pp;
2413     }
2414
2415   type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2416                           (debug_type **) NULL);
2417   if (type == DEBUG_TYPE_NULL)
2418     return FALSE;
2419
2420   if (**pp == ':')
2421     {
2422       char *varname;
2423
2424       /* This is a static class member.  */
2425       ++*pp;
2426       p = strchr (*pp, ';');
2427       if (p == NULL)
2428         {
2429           bad_stab (orig);
2430           return FALSE;
2431         }
2432
2433       varname = savestring (*pp, p - *pp);
2434
2435       *pp = p + 1;
2436
2437       *retp = debug_make_static_member (dhandle, name, type, varname,
2438                                         visibility);
2439       *staticsp = TRUE;
2440
2441       return TRUE;
2442     }
2443
2444   if (**pp != ',')
2445     {
2446       bad_stab (orig);
2447       return FALSE;
2448     }
2449   ++*pp;
2450
2451   bitpos = parse_number (pp, (bfd_boolean *) NULL);
2452   if (**pp != ',')
2453     {
2454       bad_stab (orig);
2455       return FALSE;
2456     }
2457   ++*pp;
2458
2459   bitsize = parse_number (pp, (bfd_boolean *) NULL);
2460   if (**pp != ';')
2461     {
2462       bad_stab (orig);
2463       return FALSE;
2464     }
2465   ++*pp;
2466
2467   if (bitpos == 0 && bitsize == 0)
2468     {
2469       /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2470          so, it is a field which has been optimized out.  The correct
2471          stab for this case is to use VISIBILITY_IGNORE, but that is a
2472          recent invention.  (2) It is a 0-size array.  For example
2473          union { int num; char str[0]; } foo.  Printing "<no value>"
2474          for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2475          will continue to work, and a 0-size array as a whole doesn't
2476          have any contents to print.
2477
2478          I suspect this probably could also happen with gcc -gstabs
2479          (not -gstabs+) for static fields, and perhaps other C++
2480          extensions.  Hopefully few people use -gstabs with gdb, since
2481          it is intended for dbx compatibility.  */
2482       visibility = DEBUG_VISIBILITY_IGNORE;
2483     }
2484
2485   /* FIXME: gdb does some stuff here to mark fields as unpacked.  */
2486
2487   *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2488
2489   return TRUE;
2490 }
2491
2492 /* Read member function stabs info for C++ classes.  The form of each member
2493    function data is:
2494
2495         NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2496
2497    An example with two member functions is:
2498
2499         afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2500
2501    For the case of overloaded operators, the format is op$::*.funcs, where
2502    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2503    name (such as `+=') and `.' marks the end of the operator name.  */
2504
2505 static bfd_boolean
2506 parse_stab_members (void *dhandle, struct stab_handle *info,
2507                     const char *tagname, const char **pp,
2508                     const int *typenums, debug_method **retp)
2509 {
2510   const char *orig;
2511   debug_method *methods;
2512   unsigned int c;
2513   unsigned int alloc;
2514
2515   *retp = NULL;
2516
2517   orig = *pp;
2518
2519   alloc = 0;
2520   methods = NULL;
2521   c = 0;
2522
2523   while (**pp != ';')
2524     {
2525       const char *p;
2526       char *name;
2527       debug_method_variant *variants;
2528       unsigned int cvars;
2529       unsigned int allocvars;
2530       debug_type look_ahead_type;
2531
2532       p = strchr (*pp, ':');
2533       if (p == NULL || p[1] != ':')
2534         break;
2535
2536       /* FIXME: Some systems use something other than '$' here.  */
2537       if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2538         {
2539           name = savestring (*pp, p - *pp);
2540           *pp = p + 2;
2541         }
2542       else
2543         {
2544           /* This is a completely weird case.  In order to stuff in the
2545              names that might contain colons (the usual name delimiter),
2546              Mike Tiemann defined a different name format which is
2547              signalled if the identifier is "op$".  In that case, the
2548              format is "op$::XXXX." where XXXX is the name.  This is
2549              used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2550           *pp = p + 2;
2551           for (p = *pp; *p != '.' && *p != '\0'; p++)
2552             ;
2553           if (*p != '.')
2554             {
2555               bad_stab (orig);
2556               return FALSE;
2557             }
2558           name = savestring (*pp, p - *pp);
2559           *pp = p + 1;
2560         }
2561
2562       allocvars = 10;
2563       variants = ((debug_method_variant *)
2564                   xmalloc (allocvars * sizeof *variants));
2565       cvars = 0;
2566
2567       look_ahead_type = DEBUG_TYPE_NULL;
2568
2569       do
2570         {
2571           debug_type type;
2572           bfd_boolean stub;
2573           char *argtypes;
2574           enum debug_visibility visibility;
2575           bfd_boolean constp, volatilep, staticp;
2576           bfd_vma voffset;
2577           debug_type context;
2578           const char *physname;
2579           bfd_boolean varargs;
2580
2581           if (look_ahead_type != DEBUG_TYPE_NULL)
2582             {
2583               /* g++ version 1 kludge */
2584               type = look_ahead_type;
2585               look_ahead_type = DEBUG_TYPE_NULL;
2586             }
2587           else
2588             {
2589               type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2590                                       (debug_type **) NULL);
2591               if (type == DEBUG_TYPE_NULL)
2592                 return FALSE;
2593               if (**pp != ':')
2594                 {
2595                   bad_stab (orig);
2596                   return FALSE;
2597                 }
2598             }
2599
2600           ++*pp;
2601           p = strchr (*pp, ';');
2602           if (p == NULL)
2603             {
2604               bad_stab (orig);
2605               return FALSE;
2606             }
2607
2608           stub = FALSE;
2609           if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2610               && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2611             stub = TRUE;
2612
2613           argtypes = savestring (*pp, p - *pp);
2614           *pp = p + 1;
2615
2616           switch (**pp)
2617             {
2618             case '0':
2619               visibility = DEBUG_VISIBILITY_PRIVATE;
2620               break;
2621             case '1':
2622               visibility = DEBUG_VISIBILITY_PROTECTED;
2623               break;
2624             default:
2625               visibility = DEBUG_VISIBILITY_PUBLIC;
2626               break;
2627             }
2628           ++*pp;
2629
2630           constp = FALSE;
2631           volatilep = FALSE;
2632           switch (**pp)
2633             {
2634             case 'A':
2635               /* Normal function.  */
2636               ++*pp;
2637               break;
2638             case 'B':
2639               /* const member function.  */
2640               constp = TRUE;
2641               ++*pp;
2642               break;
2643             case 'C':
2644               /* volatile member function.  */
2645               volatilep = TRUE;
2646               ++*pp;
2647               break;
2648             case 'D':
2649               /* const volatile member function.  */
2650               constp = TRUE;
2651               volatilep = TRUE;
2652               ++*pp;
2653               break;
2654             case '*':
2655             case '?':
2656             case '.':
2657               /* File compiled with g++ version 1; no information.  */
2658               break;
2659             default:
2660               warn_stab (orig, _("const/volatile indicator missing"));
2661               break;
2662             }
2663
2664           staticp = FALSE;
2665           switch (**pp)
2666             {
2667             case '*':
2668               /* virtual member function, followed by index.  The sign
2669                  bit is supposedly set to distinguish
2670                  pointers-to-methods from virtual function indicies.  */
2671               ++*pp;
2672               voffset = parse_number (pp, (bfd_boolean *) NULL);
2673               if (**pp != ';')
2674                 {
2675                   bad_stab (orig);
2676                   return FALSE;
2677                 }
2678               ++*pp;
2679               voffset &= 0x7fffffff;
2680
2681               if (**pp == ';' || *pp == '\0')
2682                 {
2683                   /* Must be g++ version 1.  */
2684                   context = DEBUG_TYPE_NULL;
2685                 }
2686               else
2687                 {
2688                   /* Figure out from whence this virtual function
2689                      came.  It may belong to virtual function table of
2690                      one of its baseclasses.  */
2691                   look_ahead_type = parse_stab_type (dhandle, info,
2692                                                      (const char *) NULL,
2693                                                      pp,
2694                                                      (debug_type **) NULL);
2695                   if (**pp == ':')
2696                     {
2697                       /* g++ version 1 overloaded methods.  */
2698                       context = DEBUG_TYPE_NULL;
2699                     }
2700                   else
2701                     {
2702                       context = look_ahead_type;
2703                       look_ahead_type = DEBUG_TYPE_NULL;
2704                       if (**pp != ';')
2705                         {
2706                           bad_stab (orig);
2707                           return FALSE;
2708                         }
2709                       ++*pp;
2710                     }
2711                 }
2712               break;
2713
2714             case '?':
2715               /* static member function.  */
2716               ++*pp;
2717               staticp = TRUE;
2718               voffset = 0;
2719               context = DEBUG_TYPE_NULL;
2720               if (strncmp (argtypes, name, strlen (name)) != 0)
2721                 stub = TRUE;
2722               break;
2723
2724             default:
2725               warn_stab (orig, "member function type missing");
2726               voffset = 0;
2727               context = DEBUG_TYPE_NULL;
2728               break;
2729
2730             case '.':
2731               ++*pp;
2732               voffset = 0;
2733               context = DEBUG_TYPE_NULL;
2734               break;
2735             }
2736
2737           /* If the type is not a stub, then the argtypes string is
2738              the physical name of the function.  Otherwise the
2739              argtypes string is the mangled form of the argument
2740              types, and the full type and the physical name must be
2741              extracted from them.  */
2742           if (! stub)
2743             physname = argtypes;
2744           else
2745             {
2746               debug_type class_type, return_type;
2747
2748               class_type = stab_find_type (dhandle, info, typenums);
2749               if (class_type == DEBUG_TYPE_NULL)
2750                 return FALSE;
2751               return_type = debug_get_return_type (dhandle, type);
2752               if (return_type == DEBUG_TYPE_NULL)
2753                 {
2754                   bad_stab (orig);
2755                   return FALSE;
2756                 }
2757               type = parse_stab_argtypes (dhandle, info, class_type, name,
2758                                           tagname, return_type, argtypes,
2759                                           constp, volatilep, &physname);
2760               if (type == DEBUG_TYPE_NULL)
2761                 return FALSE;
2762             }
2763
2764           if (cvars + 1 >= allocvars)
2765             {
2766               allocvars += 10;
2767               variants = ((debug_method_variant *)
2768                           xrealloc (variants,
2769                                     allocvars * sizeof *variants));
2770             }
2771
2772           if (! staticp)
2773             variants[cvars] = debug_make_method_variant (dhandle, physname,
2774                                                          type, visibility,
2775                                                          constp, volatilep,
2776                                                          voffset, context);
2777           else
2778             variants[cvars] = debug_make_static_method_variant (dhandle,
2779                                                                 physname,
2780                                                                 type,
2781                                                                 visibility,
2782                                                                 constp,
2783                                                                 volatilep);
2784           if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2785             return FALSE;
2786
2787           ++cvars;
2788         }
2789       while (**pp != ';' && **pp != '\0');
2790
2791       variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2792
2793       if (**pp != '\0')
2794         ++*pp;
2795
2796       if (c + 1 >= alloc)
2797         {
2798           alloc += 10;
2799           methods = ((debug_method *)
2800                      xrealloc (methods, alloc * sizeof *methods));
2801         }
2802
2803       methods[c] = debug_make_method (dhandle, name, variants);
2804
2805       ++c;
2806     }
2807
2808   if (methods != NULL)
2809     methods[c] = DEBUG_METHOD_NULL;
2810
2811   *retp = methods;
2812
2813   return TRUE;
2814 }
2815
2816 /* Parse a string representing argument types for a method.  Stabs
2817    tries to save space by packing argument types into a mangled
2818    string.  This string should give us enough information to extract
2819    both argument types and the physical name of the function, given
2820    the tag name.  */
2821
2822 static debug_type
2823 parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2824                      debug_type class_type, const char *fieldname,
2825                      const char *tagname, debug_type return_type,
2826                      const char *argtypes, bfd_boolean constp,
2827                      bfd_boolean volatilep, const char **pphysname)
2828 {
2829   bfd_boolean is_full_physname_constructor;
2830   bfd_boolean is_constructor;
2831   bfd_boolean is_destructor;
2832   bfd_boolean is_v3;
2833   debug_type *args;
2834   bfd_boolean varargs;
2835   unsigned int physname_len = 0;
2836
2837   /* Constructors are sometimes handled specially.  */
2838   is_full_physname_constructor = ((argtypes[0] == '_'
2839                                    && argtypes[1] == '_'
2840                                    && (ISDIGIT (argtypes[2])
2841                                        || argtypes[2] == 'Q'
2842                                        || argtypes[2] == 't'))
2843                                   || CONST_STRNEQ (argtypes, "__ct"));
2844
2845   is_constructor = (is_full_physname_constructor
2846                     || (tagname != NULL
2847                         && strcmp (fieldname, tagname) == 0));
2848   is_destructor = ((argtypes[0] == '_'
2849                     && (argtypes[1] == '$' || argtypes[1] == '.')
2850                     && argtypes[2] == '_')
2851                    || CONST_STRNEQ (argtypes, "__dt"));
2852   is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
2853
2854   if (is_destructor || is_full_physname_constructor || is_v3)
2855     *pphysname = argtypes;
2856   else
2857     {
2858       unsigned int len;
2859       const char *const_prefix;
2860       const char *volatile_prefix;
2861       char buf[20];
2862       unsigned int mangled_name_len;
2863       char *physname;
2864
2865       len = tagname == NULL ? 0 : strlen (tagname);
2866       const_prefix = constp ? "C" : "";
2867       volatile_prefix = volatilep ? "V" : "";
2868
2869       if (len == 0)
2870         sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2871       else if (tagname != NULL && strchr (tagname, '<') != NULL)
2872         {
2873           /* Template methods are fully mangled.  */
2874           sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
2875           tagname = NULL;
2876           len = 0;
2877         }
2878       else
2879         sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
2880
2881       mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
2882                           + strlen (buf)
2883                           + len
2884                           + strlen (argtypes)
2885                           + 1);
2886
2887       if (fieldname[0] == 'o'
2888           && fieldname[1] == 'p'
2889           && (fieldname[2] == '$' || fieldname[2] == '.'))
2890         {
2891           const char *opname;
2892
2893           opname = cplus_mangle_opname (fieldname + 3, 0);
2894           if (opname == NULL)
2895             {
2896               fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname);
2897               return DEBUG_TYPE_NULL;
2898             }
2899           mangled_name_len += strlen (opname);
2900           physname = (char *) xmalloc (mangled_name_len);
2901           strncpy (physname, fieldname, 3);
2902           strcpy (physname + 3, opname);
2903         }
2904       else
2905         {
2906           physname = (char *) xmalloc (mangled_name_len);
2907           if (is_constructor)
2908             physname[0] = '\0';
2909           else
2910             strcpy (physname, fieldname);
2911         }
2912
2913       physname_len = strlen (physname);
2914       strcat (physname, buf);
2915       if (tagname != NULL)
2916         strcat (physname, tagname);
2917       strcat (physname, argtypes);
2918
2919       *pphysname = physname;
2920     }
2921
2922   if (*argtypes == '\0' || is_destructor)
2923     {
2924       args = (debug_type *) xmalloc (sizeof *args);
2925       *args = NULL;
2926       return debug_make_method_type (dhandle, return_type, class_type, args,
2927                                      FALSE);
2928     }
2929
2930   args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
2931   if (args == NULL)
2932     return DEBUG_TYPE_NULL;
2933
2934   return debug_make_method_type (dhandle, return_type, class_type, args,
2935                                  varargs);
2936 }
2937
2938 /* The tail end of stabs for C++ classes that contain a virtual function
2939    pointer contains a tilde, a %, and a type number.
2940    The type number refers to the base class (possibly this class itself) which
2941    contains the vtable pointer for the current class.
2942
2943    This function is called when we have parsed all the method declarations,
2944    so we can look for the vptr base class info.  */
2945
2946 static bfd_boolean
2947 parse_stab_tilde_field (void *dhandle, struct stab_handle *info,
2948                         const char **pp, const int *typenums,
2949                         debug_type *retvptrbase, bfd_boolean *retownvptr)
2950 {
2951   const char *orig;
2952   const char *hold;
2953   int vtypenums[2];
2954
2955   *retvptrbase = DEBUG_TYPE_NULL;
2956   *retownvptr = FALSE;
2957
2958   orig = *pp;
2959
2960   /* If we are positioned at a ';', then skip it.  */
2961   if (**pp == ';')
2962     ++*pp;
2963
2964   if (**pp != '~')
2965     return TRUE;
2966
2967   ++*pp;
2968
2969   if (**pp == '=' || **pp == '+' || **pp == '-')
2970     {
2971       /* Obsolete flags that used to indicate the presence of
2972          constructors and/or destructors.  */
2973       ++*pp;
2974     }
2975
2976   if (**pp != '%')
2977     return TRUE;
2978
2979   ++*pp;
2980
2981   hold = *pp;
2982
2983   /* The next number is the type number of the base class (possibly
2984      our own class) which supplies the vtable for this class.  */
2985   if (! parse_stab_type_number (pp, vtypenums))
2986     return FALSE;
2987
2988   if (vtypenums[0] == typenums[0]
2989       && vtypenums[1] == typenums[1])
2990     *retownvptr = TRUE;
2991   else
2992     {
2993       debug_type vtype;
2994       const char *p;
2995
2996       *pp = hold;
2997
2998       vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2999                                (debug_type **) NULL);
3000       for (p = *pp; *p != ';' && *p != '\0'; p++)
3001         ;
3002       if (*p != ';')
3003         {
3004           bad_stab (orig);
3005           return FALSE;
3006         }
3007
3008       *retvptrbase = vtype;
3009
3010       *pp = p + 1;
3011     }
3012
3013   return TRUE;
3014 }
3015
3016 /* Read a definition of an array type.  */
3017
3018 static debug_type
3019 parse_stab_array_type (void *dhandle, struct stab_handle *info,
3020                        const char **pp, bfd_boolean stringp)
3021 {
3022   const char *orig;
3023   const char *p;
3024   int typenums[2];
3025   debug_type index_type;
3026   bfd_boolean adjustable;
3027   bfd_signed_vma lower, upper;
3028   debug_type element_type;
3029
3030   /* Format of an array type:
3031      "ar<index type>;lower;upper;<array_contents_type>".
3032      OS9000: "arlower,upper;<array_contents_type>".
3033
3034      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3035      for these, produce a type like float[][].  */
3036
3037   orig = *pp;
3038
3039   /* FIXME: gdb checks os9k_stabs here.  */
3040
3041   /* If the index type is type 0, we take it as int.  */
3042   p = *pp;
3043   if (! parse_stab_type_number (&p, typenums))
3044     return DEBUG_TYPE_NULL;
3045   if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3046     {
3047       index_type = debug_find_named_type (dhandle, "int");
3048       if (index_type == DEBUG_TYPE_NULL)
3049         {
3050           index_type = debug_make_int_type (dhandle, 4, FALSE);
3051           if (index_type == DEBUG_TYPE_NULL)
3052             return DEBUG_TYPE_NULL;
3053         }
3054       *pp = p;
3055     }
3056   else
3057     {
3058       index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3059                                     (debug_type **) NULL);
3060     }
3061
3062   if (**pp != ';')
3063     {
3064       bad_stab (orig);
3065       return DEBUG_TYPE_NULL;
3066     }
3067   ++*pp;
3068
3069   adjustable = FALSE;
3070
3071   if (! ISDIGIT (**pp) && **pp != '-')
3072     {
3073       ++*pp;
3074       adjustable = TRUE;
3075     }
3076
3077   lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3078   if (**pp != ';')
3079     {
3080       bad_stab (orig);
3081       return DEBUG_TYPE_NULL;
3082     }
3083   ++*pp;
3084
3085   if (! ISDIGIT (**pp) && **pp != '-')
3086     {
3087       ++*pp;
3088       adjustable = TRUE;
3089     }
3090
3091   upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL);
3092   if (**pp != ';')
3093     {
3094       bad_stab (orig);
3095       return DEBUG_TYPE_NULL;
3096     }
3097   ++*pp;
3098
3099   element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3100                                   (debug_type **) NULL);
3101   if (element_type == DEBUG_TYPE_NULL)
3102     return DEBUG_TYPE_NULL;
3103
3104   if (adjustable)
3105     {
3106       lower = 0;
3107       upper = -1;
3108     }
3109
3110   return debug_make_array_type (dhandle, element_type, index_type, lower,
3111                                 upper, stringp);
3112 }
3113
3114 /* This struct holds information about files we have seen using
3115    N_BINCL.  */
3116
3117 struct bincl_file
3118 {
3119   /* The next N_BINCL file.  */
3120   struct bincl_file *next;
3121   /* The next N_BINCL on the stack.  */
3122   struct bincl_file *next_stack;
3123   /* The file name.  */
3124   const char *name;
3125   /* The hash value.  */
3126   bfd_vma hash;
3127   /* The file index.  */
3128   unsigned int file;
3129   /* The list of types defined in this file.  */
3130   struct stab_types *file_types;
3131 };
3132
3133 /* Start a new N_BINCL file, pushing it onto the stack.  */
3134
3135 static void
3136 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3137 {
3138   struct bincl_file *n;
3139
3140   n = (struct bincl_file *) xmalloc (sizeof *n);
3141   n->next = info->bincl_list;
3142   n->next_stack = info->bincl_stack;
3143   n->name = name;
3144   n->hash = hash;
3145   n->file = info->files;
3146   n->file_types = NULL;
3147   info->bincl_list = n;
3148   info->bincl_stack = n;
3149
3150   ++info->files;
3151   info->file_types = ((struct stab_types **)
3152                       xrealloc (info->file_types,
3153                                 (info->files
3154                                  * sizeof *info->file_types)));
3155   info->file_types[n->file] = NULL;
3156 }
3157
3158 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3159    stack.  */
3160
3161 static const char *
3162 pop_bincl (struct stab_handle *info)
3163 {
3164   struct bincl_file *o;
3165
3166   o = info->bincl_stack;
3167   if (o == NULL)
3168     return info->main_filename;
3169   info->bincl_stack = o->next_stack;
3170
3171   o->file_types = info->file_types[o->file];
3172
3173   if (info->bincl_stack == NULL)
3174     return info->main_filename;
3175   return info->bincl_stack->name;
3176 }
3177
3178 /* Handle an N_EXCL: get the types from the corresponding N_BINCL.  */
3179
3180 static bfd_boolean
3181 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3182 {
3183   struct bincl_file *l;
3184
3185   ++info->files;
3186   info->file_types = ((struct stab_types **)
3187                       xrealloc (info->file_types,
3188                                 (info->files
3189                                  * sizeof *info->file_types)));
3190
3191   for (l = info->bincl_list; l != NULL; l = l->next)
3192     if (l->hash == hash && strcmp (l->name, name) == 0)
3193       break;
3194   if (l == NULL)
3195     {
3196       warn_stab (name, _("Undefined N_EXCL"));
3197       info->file_types[info->files - 1] = NULL;
3198       return TRUE;
3199     }
3200
3201   info->file_types[info->files - 1] = l->file_types;
3202
3203   return TRUE;
3204 }
3205
3206 /* Handle a variable definition.  gcc emits variable definitions for a
3207    block before the N_LBRAC, so we must hold onto them until we see
3208    it.  The SunPRO compiler emits variable definitions after the
3209    N_LBRAC, so we can call debug_record_variable immediately.  */
3210
3211 static bfd_boolean
3212 stab_record_variable (void *dhandle, struct stab_handle *info,
3213                       const char *name, debug_type type,
3214                       enum debug_var_kind kind, bfd_vma val)
3215 {
3216   struct stab_pending_var *v;
3217
3218   if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3219       || ! info->within_function
3220       || (info->gcc_compiled == 0 && info->n_opt_found))
3221     return debug_record_variable (dhandle, name, type, kind, val);
3222
3223   v = (struct stab_pending_var *) xmalloc (sizeof *v);
3224   memset (v, 0, sizeof *v);
3225
3226   v->next = info->pending;
3227   v->name = name;
3228   v->type = type;
3229   v->kind = kind;
3230   v->val = val;
3231   info->pending = v;
3232
3233   return TRUE;
3234 }
3235
3236 /* Emit pending variable definitions.  This is called after we see the
3237    N_LBRAC that starts the block.  */
3238
3239 static bfd_boolean
3240 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3241 {
3242   struct stab_pending_var *v;
3243
3244   v = info->pending;
3245   while (v != NULL)
3246     {
3247       struct stab_pending_var *next;
3248
3249       if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3250         return FALSE;
3251
3252       next = v->next;
3253       free (v);
3254       v = next;
3255     }
3256
3257   info->pending = NULL;
3258
3259   return TRUE;
3260 }
3261
3262 /* Find the slot for a type in the database.  */
3263
3264 static debug_type *
3265 stab_find_slot (struct stab_handle *info, const int *typenums)
3266 {
3267   int filenum;
3268   int tindex;
3269   struct stab_types **ps;
3270
3271   filenum = typenums[0];
3272   tindex = typenums[1];
3273
3274   if (filenum < 0 || (unsigned int) filenum >= info->files)
3275     {
3276       fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3277       return NULL;
3278     }
3279   if (tindex < 0)
3280     {
3281       fprintf (stderr, _("Type index number %d out of range\n"), tindex);
3282       return NULL;
3283     }
3284
3285   ps = info->file_types + filenum;
3286
3287   while (tindex >= STAB_TYPES_SLOTS)
3288     {
3289       if (*ps == NULL)
3290         {
3291           *ps = (struct stab_types *) xmalloc (sizeof **ps);
3292           memset (*ps, 0, sizeof **ps);
3293         }
3294       ps = &(*ps)->next;
3295       tindex -= STAB_TYPES_SLOTS;
3296     }
3297   if (*ps == NULL)
3298     {
3299       *ps = (struct stab_types *) xmalloc (sizeof **ps);
3300       memset (*ps, 0, sizeof **ps);
3301     }
3302
3303   return (*ps)->types + tindex;
3304 }
3305
3306 /* Find a type given a type number.  If the type has not been
3307    allocated yet, create an indirect type.  */
3308
3309 static debug_type
3310 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3311 {
3312   debug_type *slot;
3313
3314   if (typenums[0] == 0 && typenums[1] < 0)
3315     {
3316       /* A negative type number indicates an XCOFF builtin type.  */
3317       return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3318     }
3319
3320   slot = stab_find_slot (info, typenums);
3321   if (slot == NULL)
3322     return DEBUG_TYPE_NULL;
3323
3324   if (*slot == DEBUG_TYPE_NULL)
3325     return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3326
3327   return *slot;
3328 }
3329
3330 /* Record that a given type number refers to a given type.  */
3331
3332 static bfd_boolean
3333 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3334                   const int *typenums, debug_type type)
3335 {
3336   debug_type *slot;
3337
3338   slot = stab_find_slot (info, typenums);
3339   if (slot == NULL)
3340     return FALSE;
3341
3342   /* gdb appears to ignore type redefinitions, so we do as well.  */
3343
3344   *slot = type;
3345
3346   return TRUE;
3347 }
3348
3349 /* Return an XCOFF builtin type.  */
3350
3351 static debug_type
3352 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3353                          int typenum)
3354 {
3355   debug_type rettype;
3356   const char *name;
3357
3358   if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT)
3359     {
3360       fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum);
3361       return DEBUG_TYPE_NULL;
3362     }
3363   if (info->xcoff_types[-typenum] != NULL)
3364     return info->xcoff_types[-typenum];
3365
3366   switch (-typenum)
3367     {
3368     case 1:
3369       /* The size of this and all the other types are fixed, defined
3370          by the debugging format.  */
3371       name = "int";
3372       rettype = debug_make_int_type (dhandle, 4, FALSE);
3373       break;
3374     case 2:
3375       name = "char";
3376       rettype = debug_make_int_type (dhandle, 1, FALSE);
3377       break;
3378     case 3:
3379       name = "short";
3380       rettype = debug_make_int_type (dhandle, 2, FALSE);
3381       break;
3382     case 4:
3383       name = "long";
3384       rettype = debug_make_int_type (dhandle, 4, FALSE);
3385       break;
3386     case 5:
3387       name = "unsigned char";
3388       rettype = debug_make_int_type (dhandle, 1, TRUE);
3389       break;
3390     case 6:
3391       name = "signed char";
3392       rettype = debug_make_int_type (dhandle, 1, FALSE);
3393       break;
3394     case 7:
3395       name = "unsigned short";
3396       rettype = debug_make_int_type (dhandle, 2, TRUE);
3397       break;
3398     case 8:
3399       name = "unsigned int";
3400       rettype = debug_make_int_type (dhandle, 4, TRUE);
3401       break;
3402     case 9:
3403       name = "unsigned";
3404       rettype = debug_make_int_type (dhandle, 4, TRUE);
3405     case 10:
3406       name = "unsigned long";
3407       rettype = debug_make_int_type (dhandle, 4, TRUE);
3408       break;
3409     case 11:
3410       name = "void";
3411       rettype = debug_make_void_type (dhandle);
3412       break;
3413     case 12:
3414       /* IEEE single precision (32 bit).  */
3415       name = "float";
3416       rettype = debug_make_float_type (dhandle, 4);
3417       break;
3418     case 13:
3419       /* IEEE double precision (64 bit).  */
3420       name = "double";
3421       rettype = debug_make_float_type (dhandle, 8);
3422       break;
3423     case 14:
3424       /* This is an IEEE double on the RS/6000, and different machines
3425          with different sizes for "long double" should use different
3426          negative type numbers.  See stabs.texinfo.  */
3427       name = "long double";
3428       rettype = debug_make_float_type (dhandle, 8);
3429       break;
3430     case 15:
3431       name = "integer";
3432       rettype = debug_make_int_type (dhandle, 4, FALSE);
3433       break;
3434     case 16:
3435       name = "boolean";
3436       rettype = debug_make_bool_type (dhandle, 4);
3437       break;
3438     case 17:
3439       name = "short real";
3440       rettype = debug_make_float_type (dhandle, 4);
3441       break;
3442     case 18:
3443       name = "real";
3444       rettype = debug_make_float_type (dhandle, 8);
3445       break;
3446     case 19:
3447       /* FIXME */
3448       name = "stringptr";
3449       rettype = NULL;
3450       break;
3451     case 20:
3452       /* FIXME */
3453       name = "character";
3454       rettype = debug_make_int_type (dhandle, 1, TRUE);
3455       break;
3456     case 21:
3457       name = "logical*1";
3458       rettype = debug_make_bool_type (dhandle, 1);
3459       break;
3460     case 22:
3461       name = "logical*2";
3462       rettype = debug_make_bool_type (dhandle, 2);
3463       break;
3464     case 23:
3465       name = "logical*4";
3466       rettype = debug_make_bool_type (dhandle, 4);
3467       break;
3468     case 24:
3469       name = "logical";
3470       rettype = debug_make_bool_type (dhandle, 4);
3471       break;
3472     case 25:
3473       /* Complex type consisting of two IEEE single precision values.  */
3474       name = "complex";
3475       rettype = debug_make_complex_type (dhandle, 8);
3476       break;
3477     case 26:
3478       /* Complex type consisting of two IEEE double precision values.  */
3479       name = "double complex";
3480       rettype = debug_make_complex_type (dhandle, 16);
3481       break;
3482     case 27:
3483       name = "integer*1";
3484       rettype = debug_make_int_type (dhandle, 1, FALSE);
3485       break;
3486     case 28:
3487       name = "integer*2";
3488       rettype = debug_make_int_type (dhandle, 2, FALSE);
3489       break;
3490     case 29:
3491       name = "integer*4";
3492       rettype = debug_make_int_type (dhandle, 4, FALSE);
3493       break;
3494     case 30:
3495       /* FIXME */
3496       name = "wchar";
3497       rettype = debug_make_int_type (dhandle, 2, FALSE);
3498       break;
3499     case 31:
3500       name = "long long";
3501       rettype = debug_make_int_type (dhandle, 8, FALSE);
3502       break;
3503     case 32:
3504       name = "unsigned long long";
3505       rettype = debug_make_int_type (dhandle, 8, TRUE);
3506       break;
3507     case 33:
3508       name = "logical*8";
3509       rettype = debug_make_bool_type (dhandle, 8);
3510       break;
3511     case 34:
3512       name = "integer*8";
3513       rettype = debug_make_int_type (dhandle, 8, FALSE);
3514       break;
3515     default:
3516       abort ();
3517     }
3518
3519   rettype = debug_name_type (dhandle, name, rettype);
3520
3521   info->xcoff_types[-typenum] = rettype;
3522
3523   return rettype;
3524 }
3525
3526 /* Find or create a tagged type.  */
3527
3528 static debug_type
3529 stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3530                        const char *p, int len, enum debug_type_kind kind)
3531 {
3532   char *name;
3533   debug_type dtype;
3534   struct stab_tag *st;
3535
3536   name = savestring (p, len);
3537
3538   /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3539      namespace.  This is right for C, and I don't know how to handle
3540      other languages.  FIXME.  */
3541   dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3542   if (dtype != DEBUG_TYPE_NULL)
3543     {
3544       free (name);
3545       return dtype;
3546     }
3547
3548   /* We need to allocate an entry on the undefined tag list.  */
3549   for (st = info->tags; st != NULL; st = st->next)
3550     {
3551       if (st->name[0] == name[0]
3552           && strcmp (st->name, name) == 0)
3553         {
3554           if (st->kind == DEBUG_KIND_ILLEGAL)
3555             st->kind = kind;
3556           free (name);
3557           break;
3558         }
3559     }
3560   if (st == NULL)
3561     {
3562       st = (struct stab_tag *) xmalloc (sizeof *st);
3563       memset (st, 0, sizeof *st);
3564
3565       st->next = info->tags;
3566       st->name = name;
3567       st->kind = kind;
3568       st->slot = DEBUG_TYPE_NULL;
3569       st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3570       info->tags = st;
3571     }
3572
3573   return st->type;
3574 }
3575 \f
3576 /* In order to get the correct argument types for a stubbed method, we
3577    need to extract the argument types from a C++ mangled string.
3578    Since the argument types can refer back to the return type, this
3579    means that we must demangle the entire physical name.  In gdb this
3580    is done by calling cplus_demangle and running the results back
3581    through the C++ expression parser.  Since we have no expression
3582    parser, we must duplicate much of the work of cplus_demangle here.
3583
3584    We assume that GNU style demangling is used, since this is only
3585    done for method stubs, and only g++ should output that form of
3586    debugging information.  */
3587
3588 /* This structure is used to hold a pointer to type information which
3589    demangling a string.  */
3590
3591 struct stab_demangle_typestring
3592 {
3593   /* The start of the type.  This is not null terminated.  */
3594   const char *typestring;
3595   /* The length of the type.  */
3596   unsigned int len;
3597 };
3598
3599 /* This structure is used to hold information while demangling a
3600    string.  */
3601
3602 struct stab_demangle_info
3603 {
3604   /* The debugging information handle.  */
3605   void *dhandle;
3606   /* The stab information handle.  */
3607   struct stab_handle *info;
3608   /* The array of arguments we are building.  */
3609   debug_type *args;
3610   /* Whether the method takes a variable number of arguments.  */
3611   bfd_boolean varargs;
3612   /* The array of types we have remembered.  */
3613   struct stab_demangle_typestring *typestrings;
3614   /* The number of typestrings.  */
3615   unsigned int typestring_count;
3616   /* The number of typestring slots we have allocated.  */
3617   unsigned int typestring_alloc;
3618 };
3619
3620 static void stab_bad_demangle (const char *);
3621 static unsigned int stab_demangle_count (const char **);
3622 static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
3623 static bfd_boolean stab_demangle_prefix
3624   (struct stab_demangle_info *, const char **, unsigned int);
3625 static bfd_boolean stab_demangle_function_name
3626   (struct stab_demangle_info *, const char **, const char *);
3627 static bfd_boolean stab_demangle_signature
3628   (struct stab_demangle_info *, const char **);
3629 static bfd_boolean stab_demangle_qualified
3630   (struct stab_demangle_info *, const char **, debug_type *);
3631 static bfd_boolean stab_demangle_template
3632   (struct stab_demangle_info *, const char **, char **);
3633 static bfd_boolean stab_demangle_class
3634   (struct stab_demangle_info *, const char **, const char **);
3635 static bfd_boolean stab_demangle_args
3636   (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
3637 static bfd_boolean stab_demangle_arg
3638   (struct stab_demangle_info *, const char **, debug_type **,
3639    unsigned int *, unsigned int *);
3640 static bfd_boolean stab_demangle_type
3641   (struct stab_demangle_info *, const char **, debug_type *);
3642 static bfd_boolean stab_demangle_fund_type
3643   (struct stab_demangle_info *, const char **, debug_type *);
3644 static bfd_boolean stab_demangle_remember_type
3645   (struct stab_demangle_info *, const char *, int);
3646
3647 /* Warn about a bad demangling.  */
3648
3649 static void
3650 stab_bad_demangle (const char *s)
3651 {
3652   fprintf (stderr, _("bad mangled name `%s'\n"), s);
3653 }
3654
3655 /* Get a count from a stab string.  */
3656
3657 static unsigned int
3658 stab_demangle_count (const char **pp)
3659 {
3660   unsigned int count;
3661
3662   count = 0;
3663   while (ISDIGIT (**pp))
3664     {
3665       count *= 10;
3666       count += **pp - '0';
3667       ++*pp;
3668     }
3669   return count;
3670 }
3671
3672 /* Require a count in a string.  The count may be multiple digits, in
3673    which case it must end in an underscore.  */
3674
3675 static bfd_boolean
3676 stab_demangle_get_count (const char **pp, unsigned int *pi)
3677 {
3678   if (! ISDIGIT (**pp))
3679     return FALSE;
3680
3681   *pi = **pp - '0';
3682   ++*pp;
3683   if (ISDIGIT (**pp))
3684     {
3685       unsigned int count;
3686       const char *p;
3687
3688       count = *pi;
3689       p = *pp;
3690       do
3691         {
3692           count *= 10;
3693           count += *p - '0';
3694           ++p;
3695         }
3696       while (ISDIGIT (*p));
3697       if (*p == '_')
3698         {
3699           *pp = p + 1;
3700           *pi = count;
3701         }
3702     }
3703
3704   return TRUE;
3705 }
3706
3707 /* This function demangles a physical name, returning a NULL
3708    terminated array of argument types.  */
3709
3710 static debug_type *
3711 stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3712                         const char *physname, bfd_boolean *pvarargs,
3713                         unsigned int physname_len)
3714 {
3715   struct stab_demangle_info minfo;
3716
3717   /* Check for the g++ V3 ABI.  */
3718   if (physname[0] == '_' && physname[1] == 'Z')
3719     return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3720
3721   minfo.dhandle = dhandle;
3722   minfo.info = info;
3723   minfo.args = NULL;
3724   minfo.varargs = FALSE;
3725   minfo.typestring_alloc = 10;
3726   minfo.typestrings = ((struct stab_demangle_typestring *)
3727                        xmalloc (minfo.typestring_alloc
3728                                 * sizeof *minfo.typestrings));
3729   minfo.typestring_count = 0;
3730
3731   /* cplus_demangle checks for special GNU mangled forms, but we can't
3732      see any of them in mangled method argument types.  */
3733
3734   if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3735     goto error_return;
3736
3737   if (*physname != '\0')
3738     {
3739       if (! stab_demangle_signature (&minfo, &physname))
3740         goto error_return;
3741     }
3742
3743   free (minfo.typestrings);
3744   minfo.typestrings = NULL;
3745
3746   if (minfo.args == NULL)
3747     fprintf (stderr, _("no argument types in mangled string\n"));
3748
3749   *pvarargs = minfo.varargs;
3750   return minfo.args;
3751
3752  error_return:
3753   if (minfo.typestrings != NULL)
3754     free (minfo.typestrings);
3755   return NULL;
3756 }
3757
3758 /* Demangle the prefix of the mangled name.  */
3759
3760 static bfd_boolean
3761 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3762                       unsigned int physname_len)
3763 {
3764   const char *scan;
3765   unsigned int i;
3766
3767   /* cplus_demangle checks for global constructors and destructors,
3768      but we can't see them in mangled argument types.  */
3769
3770   if (physname_len)
3771     scan = *pp + physname_len;
3772   else
3773     {
3774       /* Look for `__'.  */
3775       scan = *pp;
3776       do
3777         scan = strchr (scan, '_');
3778       while (scan != NULL && *++scan != '_');
3779
3780       if (scan == NULL)
3781         {
3782           stab_bad_demangle (*pp);
3783           return FALSE;
3784         }
3785
3786       --scan;
3787
3788       /* We found `__'; move ahead to the last contiguous `__' pair.  */
3789       i = strspn (scan, "_");
3790       if (i > 2)
3791         scan += i - 2;
3792     }
3793
3794   if (scan == *pp
3795       && (ISDIGIT (scan[2])
3796           || scan[2] == 'Q'
3797           || scan[2] == 't'))
3798     {
3799       /* This is a GNU style constructor name.  */
3800       *pp = scan + 2;
3801       return TRUE;
3802     }
3803   else if (scan == *pp
3804            && ! ISDIGIT (scan[2])
3805            && scan[2] != 't')
3806     {
3807       /* Look for the `__' that separates the prefix from the
3808          signature.  */
3809       while (*scan == '_')
3810         ++scan;
3811       scan = strstr (scan, "__");
3812       if (scan == NULL || scan[2] == '\0')
3813         {
3814           stab_bad_demangle (*pp);
3815           return FALSE;
3816         }
3817
3818       return stab_demangle_function_name (minfo, pp, scan);
3819     }
3820   else if (scan[2] != '\0')
3821     {
3822       /* The name doesn't start with `__', but it does contain `__'.  */
3823       return stab_demangle_function_name (minfo, pp, scan);
3824     }
3825   else
3826     {
3827       stab_bad_demangle (*pp);
3828       return FALSE;
3829     }
3830   /*NOTREACHED*/
3831 }
3832
3833 /* Demangle a function name prefix.  The scan argument points to the
3834    double underscore which separates the function name from the
3835    signature.  */
3836
3837 static bfd_boolean
3838 stab_demangle_function_name (struct stab_demangle_info *minfo,
3839                              const char **pp, const char *scan)
3840 {
3841   const char *name;
3842
3843   /* The string from *pp to scan is the name of the function.  We
3844      don't care about the name, since we just looking for argument
3845      types.  However, for conversion operators, the name may include a
3846      type which we must remember in order to handle backreferences.  */
3847
3848   name = *pp;
3849   *pp = scan + 2;
3850
3851   if (*pp - name >= 5
3852            && CONST_STRNEQ (name, "type")
3853            && (name[4] == '$' || name[4] == '.'))
3854     {
3855       const char *tem;
3856
3857       /* This is a type conversion operator.  */
3858       tem = name + 5;
3859       if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3860         return FALSE;
3861     }
3862   else if (name[0] == '_'
3863            && name[1] == '_'
3864            && name[2] == 'o'
3865            && name[3] == 'p')
3866     {
3867       const char *tem;
3868
3869       /* This is a type conversion operator.  */
3870       tem = name + 4;
3871       if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
3872         return FALSE;
3873     }
3874
3875   return TRUE;
3876 }
3877
3878 /* Demangle the signature.  This is where the argument types are
3879    found.  */
3880
3881 static bfd_boolean
3882 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
3883 {
3884   const char *orig;
3885   bfd_boolean expect_func, func_done;
3886   const char *hold;
3887
3888   orig = *pp;
3889
3890   expect_func = FALSE;
3891   func_done = FALSE;
3892   hold = NULL;
3893
3894   while (**pp != '\0')
3895     {
3896       switch (**pp)
3897         {
3898         case 'Q':
3899           hold = *pp;
3900           if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
3901               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3902             return FALSE;
3903           expect_func = TRUE;
3904           hold = NULL;
3905           break;
3906
3907         case 'S':
3908           /* Static member function.  FIXME: Can this happen?  */
3909           if (hold == NULL)
3910             hold = *pp;
3911           ++*pp;
3912           break;
3913
3914         case 'C':
3915           /* Const member function.  */
3916           if (hold == NULL)
3917             hold = *pp;
3918           ++*pp;
3919           break;
3920
3921         case '0': case '1': case '2': case '3': case '4':
3922         case '5': case '6': case '7': case '8': case '9':
3923           if (hold == NULL)
3924             hold = *pp;
3925           if (! stab_demangle_class (minfo, pp, (const char **) NULL)
3926               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3927             return FALSE;
3928           expect_func = TRUE;
3929           hold = NULL;
3930           break;
3931
3932         case 'F':
3933           /* Function.  I don't know if this actually happens with g++
3934              output.  */
3935           hold = NULL;
3936           func_done = TRUE;
3937           ++*pp;
3938           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3939             return FALSE;
3940           break;
3941
3942         case 't':
3943           /* Template.  */
3944           if (hold == NULL)
3945             hold = *pp;
3946           if (! stab_demangle_template (minfo, pp, (char **) NULL)
3947               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
3948             return FALSE;
3949           hold = NULL;
3950           expect_func = TRUE;
3951           break;
3952
3953         case '_':
3954           /* At the outermost level, we cannot have a return type
3955              specified, so if we run into another '_' at this point we
3956              are dealing with a mangled name that is either bogus, or
3957              has been mangled by some algorithm we don't know how to
3958              deal with.  So just reject the entire demangling.  */
3959           stab_bad_demangle (orig);
3960           return FALSE;
3961
3962         default:
3963           /* Assume we have stumbled onto the first outermost function
3964              argument token, and start processing args.  */
3965           func_done = TRUE;
3966           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3967             return FALSE;
3968           break;
3969         }
3970
3971       if (expect_func)
3972         {
3973           func_done = TRUE;
3974           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3975             return FALSE;
3976         }
3977     }
3978
3979   if (! func_done)
3980     {
3981       /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
3982          bar__3fooi is 'foo::bar(int)'.  We get here when we find the
3983          first case, and need to ensure that the '(void)' gets added
3984          to the current declp.  */
3985       if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
3986         return FALSE;
3987     }
3988
3989   return TRUE;
3990 }
3991
3992 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
3993    mangled form of "Outer::Inner".  */
3994
3995 static bfd_boolean
3996 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
3997                          debug_type *ptype)
3998 {
3999   const char *orig;
4000   const char *p;
4001   unsigned int qualifiers;
4002   debug_type context;
4003
4004   orig = *pp;
4005
4006   switch ((*pp)[1])
4007     {
4008     case '_':
4009       /* GNU mangled name with more than 9 classes.  The count is
4010          preceded by an underscore (to distinguish it from the <= 9
4011          case) and followed by an underscore.  */
4012       p = *pp + 2;
4013       if (! ISDIGIT (*p) || *p == '0')
4014         {
4015           stab_bad_demangle (orig);
4016           return FALSE;
4017         }
4018       qualifiers = atoi (p);
4019       while (ISDIGIT (*p))
4020         ++p;
4021       if (*p != '_')
4022         {
4023           stab_bad_demangle (orig);
4024           return FALSE;
4025         }
4026       *pp = p + 1;
4027       break;
4028
4029     case '1': case '2': case '3': case '4': case '5':
4030     case '6': case '7': case '8': case '9':
4031       qualifiers = (*pp)[1] - '0';
4032       /* Skip an optional underscore after the count.  */
4033       if ((*pp)[2] == '_')
4034         ++*pp;
4035       *pp += 2;
4036       break;
4037
4038     case '0':
4039     default:
4040       stab_bad_demangle (orig);
4041       return FALSE;
4042     }
4043
4044   context = DEBUG_TYPE_NULL;
4045
4046   /* Pick off the names.  */
4047   while (qualifiers-- > 0)
4048     {
4049       if (**pp == '_')
4050         ++*pp;
4051       if (**pp == 't')
4052         {
4053           char *name;
4054
4055           if (! stab_demangle_template (minfo, pp,
4056                                         ptype != NULL ? &name : NULL))
4057             return FALSE;
4058
4059           if (ptype != NULL)
4060             {
4061               context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4062                                                name, strlen (name),
4063                                                DEBUG_KIND_CLASS);
4064               free (name);
4065               if (context == DEBUG_TYPE_NULL)
4066                 return FALSE;
4067             }
4068         }
4069       else
4070         {
4071           unsigned int len;
4072
4073           len = stab_demangle_count (pp);
4074           if (strlen (*pp) < len)
4075             {
4076               stab_bad_demangle (orig);
4077               return FALSE;
4078             }
4079
4080           if (ptype != NULL)
4081             {
4082               const debug_field *fields;
4083
4084               fields = NULL;
4085               if (context != DEBUG_TYPE_NULL)
4086                 fields = debug_get_fields (minfo->dhandle, context);
4087
4088               context = DEBUG_TYPE_NULL;
4089
4090               if (fields != NULL)
4091                 {
4092                   char *name;
4093
4094                   /* Try to find the type by looking through the
4095                      fields of context until we find a field with the
4096                      same type.  This ought to work for a class
4097                      defined within a class, but it won't work for,
4098                      e.g., an enum defined within a class.  stabs does
4099                      not give us enough information to figure out the
4100                      latter case.  */
4101
4102                   name = savestring (*pp, len);
4103
4104                   for (; *fields != DEBUG_FIELD_NULL; fields++)
4105                     {
4106                       debug_type ft;
4107                       const char *dn;
4108
4109                       ft = debug_get_field_type (minfo->dhandle, *fields);
4110                       if (ft == NULL)
4111                         return FALSE;
4112                       dn = debug_get_type_name (minfo->dhandle, ft);
4113                       if (dn != NULL && strcmp (dn, name) == 0)
4114                         {
4115                           context = ft;
4116                           break;
4117                         }
4118                     }
4119
4120                   free (name);
4121                 }
4122
4123               if (context == DEBUG_TYPE_NULL)
4124                 {
4125                   /* We have to fall back on finding the type by name.
4126                      If there are more types to come, then this must
4127                      be a class.  Otherwise, it could be anything.  */
4128
4129                   if (qualifiers == 0)
4130                     {
4131                       char *name;
4132
4133                       name = savestring (*pp, len);
4134                       context = debug_find_named_type (minfo->dhandle,
4135                                                        name);
4136                       free (name);
4137                     }
4138
4139                   if (context == DEBUG_TYPE_NULL)
4140                     {
4141                       context = stab_find_tagged_type (minfo->dhandle,
4142                                                        minfo->info,
4143                                                        *pp, len,
4144                                                        (qualifiers == 0
4145                                                         ? DEBUG_KIND_ILLEGAL
4146                                                         : DEBUG_KIND_CLASS));
4147                       if (context == DEBUG_TYPE_NULL)
4148                         return FALSE;
4149