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