contrib/binutils-2.24/binutils/stabs.c

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