binutils/stabs.c

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