binutils/stabs.c

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