binutils/stabs.c

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