sdcc/support/sdbinutils/binutils/stabs.c

   1 /* stabs.c -- Parse stabs debugging information
   2    Copyright (C) 1995-2022 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   bool 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   bool 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   bool 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   bool 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 bool 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 bool 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    bool, const int *, const char *);
 171 static bool parse_stab_baseclasses
 172   (void *, struct stab_handle *, const char **, debug_baseclass **,
 173    const char *);
 174 static bool parse_stab_struct_fields
 175   (void *, struct stab_handle *, const char **, debug_field **,
 176    bool *, const char *);
 177 static bool parse_stab_cpp_abbrev
 178   (void *, struct stab_handle *, const char **, debug_field *, const char *);
 179 static bool parse_stab_one_struct_field
 180   (void *, struct stab_handle *, const char **, const char *,
 181    debug_field *, bool *, const char *);
 182 static bool 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 *, bool, bool, const char **);
 188 static bool parse_stab_tilde_field
 189   (void *, struct stab_handle *, const char **, const int *, debug_type *,
 190    bool *, const char *);
 191 static debug_type parse_stab_array_type
 192   (void *, struct stab_handle *, const char **, bool, 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 bool find_excl (struct stab_handle *, const char *, bfd_vma);
 196 static bool stab_record_variable
 197   (void *, struct stab_handle *, const char *, debug_type,
 198    enum debug_var_kind, bfd_vma);
 199 static bool 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 bool 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 *, unsigned 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 *, bool *, unsigned int);
 210 static debug_type *stab_demangle_v3_argtypes
 211   (void *, struct stab_handle *, const char *, bool *);
 212 static debug_type *stab_demangle_v3_arglist
 213   (void *, struct stab_handle *, struct demangle_component *, bool *);
 214 static debug_type stab_demangle_v3_arg
 215   (void *, struct stab_handle *, struct demangle_component *, debug_type,
 216    bool *);
 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, bool *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       bool neg;
 270       int base;
 271       bfd_vma over, lastdig;
 272       bool 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, bool 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 bool
 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 bool
 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 bool
 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   bool synonym;
 706   bool 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   bool 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           bool 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 bool
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, (bool *) NULL, p_end);
1667       return true;
1668     }
1669
1670   ++*pp;
1671   typenums[0] = (int) parse_number (pp, (bool *) 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, (bool *) 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   bool self_subrange;
1703   debug_type index_type;
1704   const char *s2, *s3;
1705   bfd_signed_vma n2, n3;
1706   bool 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 (startswith (s2, LLLOW)
1764               && startswith (s3, LLHIGH))
1765             return debug_make_int_type (dhandle, 8, false);
1766           if (! ov2
1767               && n2 == 0
1768               && startswith (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   bool 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, (bool *) 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, (bool *) 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, (bool *) 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, (bool *) 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, (bool *) 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, (bool *) 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                         bool 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   bool statics;
2108   debug_method *methods;
2109   debug_type vptrbase;
2110   bool ownvptr;
2111
2112   /* Get the size.  */
2113   size = parse_number (pp, (bool *) 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       free (fields);
2123       return DEBUG_TYPE_NULL;
2124     }
2125
2126   if (! statics
2127       && baseclasses == NULL
2128       && methods == NULL
2129       && vptrbase == DEBUG_TYPE_NULL
2130       && ! ownvptr)
2131     return debug_make_struct_type (dhandle, structp, size, fields);
2132
2133   return debug_make_object_type (dhandle, structp, size, fields, baseclasses,
2134                                  methods, vptrbase, ownvptr);
2135 }
2136
2137 /* The stabs for C++ derived classes contain baseclass information which
2138    is marked by a '!' character after the total size.  This function is
2139    called when we encounter the baseclass marker, and slurps up all the
2140    baseclass information.
2141
2142    Immediately following the '!' marker is the number of base classes that
2143    the class is derived from, followed by information for each base class.
2144    For each base class, there are two visibility specifiers, a bit offset
2145    to the base class information within the derived class, a reference to
2146    the type for the base class, and a terminating semicolon.
2147
2148    A typical example, with two base classes, would be "!2,020,19;0264,21;".
2149                                                        ^^ ^ ^ ^  ^ ^  ^
2150         Baseclass information marker __________________|| | | |  | |  |
2151         Number of baseclasses __________________________| | | |  | |  |
2152         Visibility specifiers (2) ________________________| | |  | |  |
2153         Offset in bits from start of class _________________| |  | |  |
2154         Type number for base class ___________________________|  | |  |
2155         Visibility specifiers (2) _______________________________| |  |
2156         Offset in bits from start of class ________________________|  |
2157         Type number of base class ____________________________________|
2158
2159   Return TRUE for success, FALSE for failure.  */
2160
2161 static bool
2162 parse_stab_baseclasses (void *                dhandle,
2163                         struct stab_handle *  info,
2164                         const char **         pp,
2165                         debug_baseclass **    retp,
2166                         const char *          p_end)
2167 {
2168   const char *orig;
2169   unsigned int c, i;
2170   debug_baseclass *classes;
2171
2172   *retp = NULL;
2173
2174   orig = *pp;
2175   if (orig >= p_end)
2176     return false;
2177
2178   if (**pp != '!')
2179     {
2180       /* No base classes.  */
2181       return true;
2182     }
2183   ++*pp;
2184
2185   c = (unsigned int) parse_number (pp, (bool *) NULL, p_end);
2186
2187   if (**pp != ',')
2188     {
2189       bad_stab (orig);
2190       return false;
2191     }
2192   ++*pp;
2193
2194   classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp));
2195
2196   for (i = 0; i < c; i++)
2197     {
2198       bool is_virtual;
2199       enum debug_visibility visibility;
2200       bfd_vma bitpos;
2201       debug_type type;
2202
2203       switch (**pp)
2204         {
2205         case '0':
2206           is_virtual = false;
2207           break;
2208         case '1':
2209           is_virtual = true;
2210           break;
2211         case 0:
2212           bad_stab (orig);
2213           return false;
2214         default:
2215           warn_stab (orig, _("unknown virtual character for baseclass"));
2216           is_virtual = false;
2217           break;
2218         }
2219       ++*pp;
2220
2221       switch (**pp)
2222         {
2223         case '0':
2224           visibility = DEBUG_VISIBILITY_PRIVATE;
2225           break;
2226         case '1':
2227           visibility = DEBUG_VISIBILITY_PROTECTED;
2228           break;
2229         case '2':
2230           visibility = DEBUG_VISIBILITY_PUBLIC;
2231           break;
2232         case 0:
2233           bad_stab (orig);
2234           return false;
2235         default:
2236           warn_stab (orig, _("unknown visibility character for baseclass"));
2237           visibility = DEBUG_VISIBILITY_PUBLIC;
2238           break;
2239         }
2240       ++*pp;
2241
2242       /* The remaining value is the bit offset of the portion of the
2243          object corresponding to this baseclass.  Always zero in the
2244          absence of multiple inheritance.  */
2245       bitpos = parse_number (pp, (bool *) NULL, p_end);
2246       if (**pp != ',')
2247         {
2248           bad_stab (orig);
2249           return false;
2250         }
2251       ++*pp;
2252
2253       type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2254                               (debug_type **) NULL, p_end);
2255       if (type == DEBUG_TYPE_NULL)
2256         return false;
2257
2258       classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
2259                                          visibility);
2260       if (classes[i] == DEBUG_BASECLASS_NULL)
2261         return false;
2262
2263       if (**pp != ';')
2264         return false;
2265       ++*pp;
2266     }
2267
2268   classes[i] = DEBUG_BASECLASS_NULL;
2269
2270   *retp = classes;
2271
2272   return true;
2273 }
2274
2275 /* Read struct or class data fields.  They have the form:
2276
2277         NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2278
2279    At the end, we see a semicolon instead of a field.
2280
2281    In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2282    a static field.
2283
2284    The optional VISIBILITY is one of:
2285
2286         '/0'    (VISIBILITY_PRIVATE)
2287         '/1'    (VISIBILITY_PROTECTED)
2288         '/2'    (VISIBILITY_PUBLIC)
2289         '/9'    (VISIBILITY_IGNORE)
2290
2291    or nothing, for C style fields with public visibility.
2292
2293    Returns 1 for success, 0 for failure.  */
2294
2295 static bool
2296 parse_stab_struct_fields (void *dhandle,
2297                           struct stab_handle *info,
2298                           const char **pp,
2299                           debug_field **retp,
2300                           bool *staticsp,
2301                           const char * p_end)
2302 {
2303   const char *orig;
2304   const char *p;
2305   debug_field *fields;
2306   unsigned int c;
2307   unsigned int alloc;
2308
2309   *retp = NULL;
2310   *staticsp = false;
2311
2312   orig = *pp;
2313   if (orig >= p_end)
2314     return false;
2315
2316   c = 0;
2317   alloc = 10;
2318   fields = (debug_field *) xmalloc (alloc * sizeof *fields);
2319   while (**pp != ';')
2320     {
2321       /* FIXME: gdb checks os9k_stabs here.  */
2322
2323       p = *pp;
2324
2325       /* Add 1 to c to leave room for NULL pointer at end.  */
2326       if (c + 1 >= alloc)
2327         {
2328           alloc += 10;
2329           fields = ((debug_field *)
2330                     xrealloc (fields, alloc * sizeof *fields));
2331         }
2332
2333       /* If it starts with CPLUS_MARKER it is a special abbreviation,
2334          unless the CPLUS_MARKER is followed by an underscore, in
2335          which case it is just the name of an anonymous type, which we
2336          should handle like any other type name.  We accept either '$'
2337          or '.', because a field name can never contain one of these
2338          characters except as a CPLUS_MARKER.  */
2339
2340       if ((*p == '$' || *p == '.') && p[1] != '_')
2341         {
2342           ++*pp;
2343           if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c, p_end))
2344             {
2345               free (fields);
2346               return false;
2347             }
2348           ++c;
2349           continue;
2350         }
2351
2352       /* Look for the ':' that separates the field name from the field
2353          values.  Data members are delimited by a single ':', while member
2354          functions are delimited by a pair of ':'s.  When we hit the member
2355          functions (if any), terminate scan loop and return.  */
2356
2357       p = strchr (p, ':');
2358       if (p == NULL)
2359         {
2360           bad_stab (orig);
2361           free (fields);
2362           return false;
2363         }
2364
2365       if (p[1] == ':')
2366         break;
2367
2368       if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
2369                                          staticsp, p_end))
2370         return false;
2371
2372       ++c;
2373     }
2374
2375   fields[c] = DEBUG_FIELD_NULL;
2376
2377   *retp = fields;
2378
2379   return true;
2380 }
2381
2382 /* Special GNU C++ name.  */
2383
2384 static bool
2385 parse_stab_cpp_abbrev (void *                dhandle,
2386                        struct stab_handle *  info,
2387                        const char **         pp,
2388                        debug_field *         retp,
2389                        const char *          p_end)
2390 {
2391   const char *orig;
2392   int cpp_abbrev;
2393   debug_type context;
2394   const char *name;
2395   const char *type_name;
2396   debug_type type;
2397   bfd_vma bitpos;
2398
2399   *retp = DEBUG_FIELD_NULL;
2400
2401   orig = *pp;
2402   if (orig >= p_end)
2403     return false;
2404
2405   if (**pp != 'v')
2406     {
2407       bad_stab (*pp);
2408       return false;
2409     }
2410   ++*pp;
2411
2412   cpp_abbrev = **pp;
2413   if (cpp_abbrev == 0)
2414     {
2415       bad_stab (orig);
2416       return false;
2417     }
2418   ++*pp;
2419
2420   /* At this point, *pp points to something like "22:23=*22...", where
2421      the type number before the ':' is the "context" and everything
2422      after is a regular type definition.  Lookup the type, find it's
2423      name, and construct the field name.  */
2424
2425   context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2426                              (debug_type **) NULL, p_end);
2427   if (context == DEBUG_TYPE_NULL)
2428     return false;
2429
2430   switch (cpp_abbrev)
2431     {
2432     case 'f':
2433       /* $vf -- a virtual function table pointer.  */
2434       name = "_vptr$";
2435       break;
2436     case 'b':
2437       /* $vb -- a virtual bsomethingorother */
2438       type_name = debug_get_type_name (dhandle, context);
2439       if (type_name == NULL)
2440         {
2441           warn_stab (orig, _("unnamed $vb type"));
2442           type_name = "FOO";
2443         }
2444       name = concat ("_vb$", type_name, (const char *) NULL);
2445       break;
2446     default:
2447       warn_stab (orig, _("unrecognized C++ abbreviation"));
2448       name = "INVALID_CPLUSPLUS_ABBREV";
2449       break;
2450     }
2451
2452   if (**pp != ':')
2453     {
2454       bad_stab (orig);
2455       return false;
2456     }
2457   ++*pp;
2458
2459   type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2460                           (debug_type **) NULL, p_end);
2461   if (**pp != ',')
2462     {
2463       bad_stab (orig);
2464       return false;
2465     }
2466   ++*pp;
2467
2468   bitpos = parse_number (pp, (bool *) NULL, p_end);
2469   if (**pp != ';')
2470     {
2471       bad_stab (orig);
2472       return false;
2473     }
2474   ++*pp;
2475
2476   *retp = debug_make_field (dhandle, name, type, bitpos, 0,
2477                             DEBUG_VISIBILITY_PRIVATE);
2478   if (*retp == DEBUG_FIELD_NULL)
2479     return false;
2480
2481   return true;
2482 }
2483
2484 /* Parse a single field in a struct or union.  */
2485
2486 static bool
2487 parse_stab_one_struct_field (void *dhandle,
2488                              struct stab_handle *info,
2489                              const char **pp,
2490                              const char *p,
2491                              debug_field *retp,
2492                              bool *staticsp,
2493                              const char *p_end)
2494 {
2495   const char *orig;
2496   char *name;
2497   enum debug_visibility visibility;
2498   debug_type type;
2499   bfd_vma bitpos;
2500   bfd_vma bitsize;
2501
2502   orig = *pp;
2503   if (orig >= p_end)
2504     return false;
2505
2506   /* FIXME: gdb checks ARM_DEMANGLING here.  */
2507
2508   name = savestring (*pp, p - *pp);
2509
2510   *pp = p + 1;
2511
2512   if (**pp != '/')
2513     visibility = DEBUG_VISIBILITY_PUBLIC;
2514   else
2515     {
2516       ++*pp;
2517       switch (**pp)
2518         {
2519         case '0':
2520           visibility = DEBUG_VISIBILITY_PRIVATE;
2521           break;
2522         case '1':
2523           visibility = DEBUG_VISIBILITY_PROTECTED;
2524           break;
2525         case '2':
2526           visibility = DEBUG_VISIBILITY_PUBLIC;
2527           break;
2528         case 0:
2529           bad_stab (orig);
2530           return false;
2531         default:
2532           warn_stab (orig, _("unknown visibility character for field"));
2533           visibility = DEBUG_VISIBILITY_PUBLIC;
2534           break;
2535         }
2536       ++*pp;
2537     }
2538
2539   type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2540                           (debug_type **) NULL, p_end);
2541   if (type == DEBUG_TYPE_NULL)
2542     {
2543       free (name);
2544       return false;
2545     }
2546
2547   if (**pp == ':')
2548     {
2549       char *varname;
2550
2551       /* This is a static class member.  */
2552       ++*pp;
2553       p = strchr (*pp, ';');
2554       if (p == NULL)
2555         {
2556           bad_stab (orig);
2557           free (name);
2558           return false;
2559         }
2560
2561       varname = savestring (*pp, p - *pp);
2562
2563       *pp = p + 1;
2564
2565       *retp = debug_make_static_member (dhandle, name, type, varname,
2566                                         visibility);
2567       *staticsp = true;
2568
2569       return true;
2570     }
2571
2572   if (**pp != ',')
2573     {
2574       bad_stab (orig);
2575       free (name);
2576       return false;
2577     }
2578   ++*pp;
2579
2580   bitpos = parse_number (pp, (bool *) NULL, p_end);
2581   if (**pp != ',')
2582     {
2583       bad_stab (orig);
2584       free (name);
2585       return false;
2586     }
2587   ++*pp;
2588
2589   bitsize = parse_number (pp, (bool *) NULL, p_end);
2590   if (**pp != ';')
2591     {
2592       bad_stab (orig);
2593       free (name);
2594       return false;
2595     }
2596   ++*pp;
2597
2598   if (bitpos == 0 && bitsize == 0)
2599     {
2600       /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2601          so, it is a field which has been optimized out.  The correct
2602          stab for this case is to use VISIBILITY_IGNORE, but that is a
2603          recent invention.  (2) It is a 0-size array.  For example
2604          union { int num; char str[0]; } foo.  Printing "<no value>"
2605          for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2606          will continue to work, and a 0-size array as a whole doesn't
2607          have any contents to print.
2608
2609          I suspect this probably could also happen with gcc -gstabs
2610          (not -gstabs+) for static fields, and perhaps other C++
2611          extensions.  Hopefully few people use -gstabs with gdb, since
2612          it is intended for dbx compatibility.  */
2613       visibility = DEBUG_VISIBILITY_IGNORE;
2614     }
2615
2616   /* FIXME: gdb does some stuff here to mark fields as unpacked.  */
2617
2618   *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
2619
2620   return true;
2621 }
2622
2623 /* Read member function stabs info for C++ classes.  The form of each member
2624    function data is:
2625
2626         NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2627
2628    An example with two member functions is:
2629
2630         afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2631
2632    For the case of overloaded operators, the format is op$::*.funcs, where
2633    $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2634    name (such as `+=') and `.' marks the end of the operator name.  */
2635
2636 static bool
2637 parse_stab_members (void *                dhandle,
2638                     struct stab_handle *  info,
2639                     const char *          tagname,
2640                     const char **         pp,
2641                     const int *           typenums,
2642                     debug_method **       retp,
2643                     const char *          p_end)
2644 {
2645   const char *orig;
2646   debug_method *methods;
2647   unsigned int c;
2648   unsigned int alloc;
2649   char *name = NULL;
2650   debug_method_variant *variants = NULL;
2651   char *argtypes = NULL;
2652
2653   *retp = NULL;
2654
2655   orig = *pp;
2656   if (orig >= p_end)
2657     return false;
2658
2659   alloc = 0;
2660   methods = NULL;
2661   c = 0;
2662
2663   while (**pp != ';')
2664     {
2665       const char *p;
2666       unsigned int cvars;
2667       unsigned int allocvars;
2668       debug_type look_ahead_type;
2669
2670       p = strchr (*pp, ':');
2671       if (p == NULL || p[1] != ':')
2672         break;
2673
2674       /* FIXME: Some systems use something other than '$' here.  */
2675       if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$')
2676         {
2677           name = savestring (*pp, p - *pp);
2678           *pp = p + 2;
2679         }
2680       else
2681         {
2682           /* This is a completely weird case.  In order to stuff in the
2683              names that might contain colons (the usual name delimiter),
2684              Mike Tiemann defined a different name format which is
2685              signalled if the identifier is "op$".  In that case, the
2686              format is "op$::XXXX." where XXXX is the name.  This is
2687              used for names like "+" or "=".  YUUUUUUUK!  FIXME!  */
2688           *pp = p + 2;
2689           for (p = *pp; *p != '.' && *p != '\0'; p++)
2690             ;
2691           if (*p != '.')
2692             {
2693               bad_stab (orig);
2694               goto fail;
2695             }
2696           name = savestring (*pp, p - *pp);
2697           *pp = p + 1;
2698         }
2699
2700       allocvars = 10;
2701       variants = ((debug_method_variant *)
2702                   xmalloc (allocvars * sizeof *variants));
2703       cvars = 0;
2704
2705       look_ahead_type = DEBUG_TYPE_NULL;
2706
2707       do
2708         {
2709           debug_type type;
2710           bool stub;
2711           enum debug_visibility visibility;
2712           bool constp, volatilep, staticp;
2713           bfd_vma voffset;
2714           debug_type context;
2715           const char *physname;
2716           bool varargs;
2717
2718           if (look_ahead_type != DEBUG_TYPE_NULL)
2719             {
2720               /* g++ version 1 kludge */
2721               type = look_ahead_type;
2722               look_ahead_type = DEBUG_TYPE_NULL;
2723             }
2724           else
2725             {
2726               type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
2727                                       (debug_type **) NULL, p_end);
2728               if (type == DEBUG_TYPE_NULL)
2729                 goto fail;
2730
2731               if (**pp != ':')
2732                 {
2733                   bad_stab (orig);
2734                   goto fail;
2735                 }
2736             }
2737
2738           ++*pp;
2739           p = strchr (*pp, ';');
2740           if (p == NULL)
2741             {
2742               bad_stab (orig);
2743               goto fail;
2744             }
2745
2746           stub = false;
2747           if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
2748               && debug_get_parameter_types (dhandle, type, &varargs) == NULL)
2749             stub = true;
2750
2751           argtypes = savestring (*pp, p - *pp);
2752           *pp = p + 1;
2753
2754           switch (**pp)
2755             {
2756             case '0':
2757               visibility = DEBUG_VISIBILITY_PRIVATE;
2758               break;
2759             case '1':
2760               visibility = DEBUG_VISIBILITY_PROTECTED;
2761               break;
2762             case 0:
2763               bad_stab (orig);
2764               goto fail;
2765             default:
2766               visibility = DEBUG_VISIBILITY_PUBLIC;
2767               break;
2768             }
2769           ++*pp;
2770
2771           constp = false;
2772           volatilep = false;
2773           switch (**pp)
2774             {
2775             case 'A':
2776               /* Normal function.  */
2777               ++*pp;
2778               break;
2779             case 'B':
2780               /* const member function.  */
2781               constp = true;
2782               ++*pp;
2783               break;
2784             case 'C':
2785               /* volatile member function.  */
2786               volatilep = true;
2787               ++*pp;
2788               break;
2789             case 'D':
2790               /* const volatile member function.  */
2791               constp = true;
2792               volatilep = true;
2793               ++*pp;
2794               break;
2795             case '*':
2796             case '?':
2797             case '.':
2798               /* File compiled with g++ version 1; no information.  */
2799               break;
2800             default:
2801               warn_stab (orig, _("const/volatile indicator missing"));
2802               break;
2803             }
2804
2805           staticp = false;
2806           switch (**pp)
2807             {
2808             case '*':
2809               /* virtual member function, followed by index.  The sign
2810                  bit is supposedly set to distinguish
2811                  pointers-to-methods from virtual function indices.  */
2812               ++*pp;
2813               voffset = parse_number (pp, (bool *) NULL, p_end);
2814               if (**pp != ';')
2815                 {
2816                   bad_stab (orig);
2817                   goto fail;
2818                 }
2819               ++*pp;
2820               voffset &= 0x7fffffff;
2821
2822               if (**pp == ';' || **pp == '\0')
2823                 {
2824                   /* Must be g++ version 1.  */
2825                   context = DEBUG_TYPE_NULL;
2826                 }
2827               else
2828                 {
2829                   /* Figure out from whence this virtual function
2830                      came.  It may belong to virtual function table of
2831                      one of its baseclasses.  */
2832                   look_ahead_type = parse_stab_type (dhandle, info,
2833                                                      (const char *) NULL,
2834                                                      pp,
2835                                                      (debug_type **) NULL,
2836                                                      p_end);
2837                   if (**pp == ':')
2838                     {
2839                       /* g++ version 1 overloaded methods.  */
2840                       context = DEBUG_TYPE_NULL;
2841                     }
2842                   else
2843                     {
2844                       context = look_ahead_type;
2845                       look_ahead_type = DEBUG_TYPE_NULL;
2846                       if (**pp != ';')
2847                         {
2848                           bad_stab (orig);
2849                           goto fail;
2850                         }
2851                       ++*pp;
2852                     }
2853                 }
2854               break;
2855
2856             case '?':
2857               /* static member function.  */
2858               ++*pp;
2859               staticp = true;
2860               voffset = 0;
2861               context = DEBUG_TYPE_NULL;
2862               if (strncmp (argtypes, name, strlen (name)) != 0)
2863                 stub = true;
2864               break;
2865
2866             default:
2867               warn_stab (orig, "member function type missing");
2868               voffset = 0;
2869               context = DEBUG_TYPE_NULL;
2870               break;
2871
2872             case '.':
2873               ++*pp;
2874               voffset = 0;
2875               context = DEBUG_TYPE_NULL;
2876               break;
2877             }
2878
2879           /* If the type is not a stub, then the argtypes string is
2880              the physical name of the function.  Otherwise the
2881              argtypes string is the mangled form of the argument
2882              types, and the full type and the physical name must be
2883              extracted from them.  */
2884           physname = argtypes;
2885           if (stub)
2886             {
2887               debug_type class_type, return_type;
2888
2889               class_type = stab_find_type (dhandle, info, typenums);
2890               if (class_type == DEBUG_TYPE_NULL)
2891                 goto fail;
2892               return_type = debug_get_return_type (dhandle, type);
2893               if (return_type == DEBUG_TYPE_NULL)
2894                 {
2895                   bad_stab (orig);
2896                   goto fail;
2897                 }
2898               type = parse_stab_argtypes (dhandle, info, class_type, name,
2899                                           tagname, return_type, argtypes,
2900                                           constp, volatilep, &physname);
2901               if (type == DEBUG_TYPE_NULL)
2902                 goto fail;
2903             }
2904
2905           if (cvars + 1 >= allocvars)
2906             {
2907               allocvars += 10;
2908               variants = ((debug_method_variant *)
2909                           xrealloc (variants,
2910                                     allocvars * sizeof *variants));
2911             }
2912
2913           if (! staticp)
2914             variants[cvars] = debug_make_method_variant (dhandle, physname,
2915                                                          type, visibility,
2916                                                          constp, volatilep,
2917                                                          voffset, context);
2918           else
2919             variants[cvars] = debug_make_static_method_variant (dhandle,
2920                                                                 physname,
2921                                                                 type,
2922                                                                 visibility,
2923                                                                 constp,
2924                                                                 volatilep);
2925           if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL)
2926             goto fail;
2927
2928           ++cvars;
2929         }
2930       while (**pp != ';' && **pp != '\0');
2931
2932       variants[cvars] = DEBUG_METHOD_VARIANT_NULL;
2933
2934       if (**pp != '\0')
2935         ++*pp;
2936
2937       if (c + 1 >= alloc)
2938         {
2939           alloc += 10;
2940           methods = ((debug_method *)
2941                      xrealloc (methods, alloc * sizeof *methods));
2942         }
2943
2944       methods[c] = debug_make_method (dhandle, name, variants);
2945
2946       ++c;
2947     }
2948
2949   if (methods != NULL)
2950     methods[c] = DEBUG_METHOD_NULL;
2951
2952   *retp = methods;
2953
2954   return true;
2955
2956  fail:
2957   free (name);
2958   free (variants);
2959   free (argtypes);
2960   return false;
2961 }
2962
2963 /* Parse a string representing argument types for a method.  Stabs
2964    tries to save space by packing argument types into a mangled
2965    string.  This string should give us enough information to extract
2966    both argument types and the physical name of the function, given
2967    the tag name.  */
2968
2969 static debug_type
2970 parse_stab_argtypes (void *dhandle, struct stab_handle *info,
2971                      debug_type class_type, const char *fieldname,
2972                      const char *tagname, debug_type return_type,
2973                      const char *argtypes, bool constp,
2974                      bool volatilep, const char **pphysname)
2975 {
2976   bool is_full_physname_constructor;
2977   bool is_constructor;
2978   bool is_destructor;
2979   bool is_v3;
2980   debug_type *args;
2981   bool varargs;
2982   unsigned int physname_len = 0;
2983
2984   /* Constructors are sometimes handled specially.  */
2985   is_full_physname_constructor = ((argtypes[0] == '_'
2986                                    && argtypes[1] == '_'
2987                                    && (ISDIGIT (argtypes[2])
2988                                        || argtypes[2] == 'Q'
2989                                        || argtypes[2] == 't'))
2990                                   || startswith (argtypes, "__ct"));
2991
2992   is_constructor = (is_full_physname_constructor
2993                     || (tagname != NULL
2994                         && strcmp (fieldname, tagname) == 0));
2995   is_destructor = ((argtypes[0] == '_'
2996                     && (argtypes[1] == '$' || argtypes[1] == '.')
2997                     && argtypes[2] == '_')
2998                    || startswith (argtypes, "__dt"));
2999   is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z';
3000
3001   if (!(is_destructor || is_full_physname_constructor || is_v3))
3002     {
3003       unsigned int len;
3004       const char *const_prefix;
3005       const char *volatile_prefix;
3006       char buf[20];
3007       unsigned int mangled_name_len;
3008       char *physname;
3009
3010       len = tagname == NULL ? 0 : strlen (tagname);
3011       const_prefix = constp ? "C" : "";
3012       volatile_prefix = volatilep ? "V" : "";
3013
3014       if (len == 0)
3015         sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
3016       else if (tagname != NULL && strchr (tagname, '<') != NULL)
3017         {
3018           /* Template methods are fully mangled.  */
3019           sprintf (buf, "__%s%s", const_prefix, volatile_prefix);
3020           tagname = NULL;
3021           len = 0;
3022         }
3023       else
3024         sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len);
3025
3026       mangled_name_len = ((is_constructor ? 0 : strlen (fieldname))
3027                           + strlen (buf)
3028                           + len
3029                           + strlen (argtypes)
3030                           + 1);
3031
3032       if (fieldname[0] == 'o'
3033           && fieldname[1] == 'p'
3034           && (fieldname[2] == '$' || fieldname[2] == '.'))
3035         {
3036           /* Opname selection is no longer supported by libiberty's demangler.  */
3037           return DEBUG_TYPE_NULL;
3038         }
3039
3040       physname = (char *) xmalloc (mangled_name_len);
3041       if (is_constructor)
3042         physname[0] = '\0';
3043       else
3044         strcpy (physname, fieldname);
3045
3046       physname_len = strlen (physname);
3047       strcat (physname, buf);
3048       if (tagname != NULL)
3049         strcat (physname, tagname);
3050       strcat (physname, argtypes);
3051
3052       *pphysname = physname;
3053     }
3054
3055   if (*argtypes == '\0' || is_destructor)
3056     {
3057       args = (debug_type *) xmalloc (sizeof *args);
3058       *args = NULL;
3059       return debug_make_method_type (dhandle, return_type, class_type, args,
3060                                      false);
3061     }
3062
3063   args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
3064   if (args == NULL)
3065     return DEBUG_TYPE_NULL;
3066
3067   return debug_make_method_type (dhandle, return_type, class_type, args,
3068                                  varargs);
3069 }
3070
3071 /* The tail end of stabs for C++ classes that contain a virtual function
3072    pointer contains a tilde, a %, and a type number.
3073    The type number refers to the base class (possibly this class itself) which
3074    contains the vtable pointer for the current class.
3075
3076    This function is called when we have parsed all the method declarations,
3077    so we can look for the vptr base class info.  */
3078
3079 static bool
3080 parse_stab_tilde_field (void *dhandle,
3081                         struct stab_handle *info,
3082                         const char **pp,
3083                         const int *typenums,
3084                         debug_type *retvptrbase,
3085                         bool *retownvptr,
3086                         const char *p_end)
3087 {
3088   const char *orig;
3089   const char *hold;
3090   int vtypenums[2];
3091
3092   *retvptrbase = DEBUG_TYPE_NULL;
3093   *retownvptr = false;
3094
3095   orig = *pp;
3096   if (orig >= p_end)
3097     return false;
3098
3099   /* If we are positioned at a ';', then skip it.  */
3100   if (**pp == ';')
3101     ++*pp;
3102
3103   if (**pp != '~')
3104     return true;
3105   ++*pp;
3106
3107   if (**pp == '=' || **pp == '+' || **pp == '-')
3108     {
3109       /* Obsolete flags that used to indicate the presence of
3110          constructors and/or destructors.  */
3111       ++*pp;
3112     }
3113
3114   if (**pp != '%')
3115     return true;
3116   ++*pp;
3117
3118   hold = *pp;
3119
3120   /* The next number is the type number of the base class (possibly
3121      our own class) which supplies the vtable for this class.  */
3122   if (! parse_stab_type_number (pp, vtypenums, p_end))
3123     return false;
3124
3125   if (vtypenums[0] == typenums[0]
3126       && vtypenums[1] == typenums[1])
3127     *retownvptr = true;
3128   else
3129     {
3130       debug_type vtype;
3131       const char *p;
3132
3133       *pp = hold;
3134
3135       vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3136                                (debug_type **) NULL, p_end);
3137       for (p = *pp; *p != ';' && *p != '\0'; p++)
3138         ;
3139       if (*p != ';')
3140         {
3141           bad_stab (orig);
3142           return false;
3143         }
3144
3145       *retvptrbase = vtype;
3146
3147       *pp = p + 1;
3148     }
3149
3150   return true;
3151 }
3152
3153 /* Read a definition of an array type.  */
3154
3155 static debug_type
3156 parse_stab_array_type (void *dhandle,
3157                        struct stab_handle *info,
3158                        const char **pp,
3159                        bool stringp,
3160                        const char *p_end)
3161 {
3162   const char *orig;
3163   const char *p;
3164   int typenums[2];
3165   debug_type index_type;
3166   bool adjustable;
3167   bfd_signed_vma lower, upper;
3168   debug_type element_type;
3169
3170   /* Format of an array type:
3171      "ar<index type>;lower;upper;<array_contents_type>".
3172      OS9000: "arlower,upper;<array_contents_type>".
3173
3174      Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3175      for these, produce a type like float[][].  */
3176
3177   orig = *pp;
3178   if (orig >= p_end)
3179     return DEBUG_TYPE_NULL;
3180
3181   /* FIXME: gdb checks os9k_stabs here.  */
3182
3183   /* If the index type is type 0, we take it as int.  */
3184   p = *pp;
3185   if (! parse_stab_type_number (&p, typenums, p_end))
3186     return DEBUG_TYPE_NULL;
3187
3188   if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=')
3189     {
3190       index_type = debug_find_named_type (dhandle, "int");
3191       if (index_type == DEBUG_TYPE_NULL)
3192         {
3193           index_type = debug_make_int_type (dhandle, 4, false);
3194           if (index_type == DEBUG_TYPE_NULL)
3195             return DEBUG_TYPE_NULL;
3196         }
3197       *pp = p;
3198     }
3199   else
3200     {
3201       index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3202                                     (debug_type **) NULL, p_end);
3203     }
3204
3205   if (**pp != ';')
3206     {
3207       bad_stab (orig);
3208       return DEBUG_TYPE_NULL;
3209     }
3210   ++*pp;
3211
3212   adjustable = false;
3213
3214   if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
3215     {
3216       ++*pp;
3217       adjustable = true;
3218     }
3219
3220   lower = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
3221   if (**pp != ';')
3222     {
3223       bad_stab (orig);
3224       return DEBUG_TYPE_NULL;
3225     }
3226   ++*pp;
3227
3228   if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
3229     {
3230       ++*pp;
3231       adjustable = true;
3232     }
3233
3234   upper = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
3235   if (**pp != ';')
3236     {
3237       bad_stab (orig);
3238       return DEBUG_TYPE_NULL;
3239     }
3240   ++*pp;
3241
3242   element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
3243                                   (debug_type **) NULL, p_end);
3244   if (element_type == DEBUG_TYPE_NULL)
3245     return DEBUG_TYPE_NULL;
3246
3247   if (adjustable)
3248     {
3249       lower = 0;
3250       upper = -1;
3251     }
3252
3253   return debug_make_array_type (dhandle, element_type, index_type, lower,
3254                                 upper, stringp);
3255 }
3256
3257 /* This struct holds information about files we have seen using
3258    N_BINCL.  */
3259
3260 struct bincl_file
3261 {
3262   /* The next N_BINCL file.  */
3263   struct bincl_file *next;
3264   /* The next N_BINCL on the stack.  */
3265   struct bincl_file *next_stack;
3266   /* The file name.  */
3267   const char *name;
3268   /* The hash value.  */
3269   bfd_vma hash;
3270   /* The file index.  */
3271   unsigned int file;
3272   /* The list of types defined in this file.  */
3273   struct stab_types *file_types;
3274 };
3275
3276 /* Start a new N_BINCL file, pushing it onto the stack.  */
3277
3278 static void
3279 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash)
3280 {
3281   struct bincl_file *n;
3282
3283   n = (struct bincl_file *) xmalloc (sizeof *n);
3284   n->next = info->bincl_list;
3285   n->next_stack = info->bincl_stack;
3286   n->name = name;
3287   n->hash = hash;
3288   n->file = info->files;
3289   n->file_types = NULL;
3290   info->bincl_list = n;
3291   info->bincl_stack = n;
3292
3293   ++info->files;
3294   info->file_types = ((struct stab_types **)
3295                       xrealloc (info->file_types,
3296                                 (info->files
3297                                  * sizeof *info->file_types)));
3298   info->file_types[n->file] = NULL;
3299 }
3300
3301 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3302    stack.  */
3303
3304 static const char *
3305 pop_bincl (struct stab_handle *info)
3306 {
3307   struct bincl_file *o;
3308
3309   o = info->bincl_stack;
3310   if (o == NULL)
3311     return info->main_filename;
3312   info->bincl_stack = o->next_stack;
3313
3314   if (o->file >= info->files)
3315     return info->main_filename;
3316
3317   o->file_types = info->file_types[o->file];
3318
3319   if (info->bincl_stack == NULL)
3320     return info->main_filename;
3321   return info->bincl_stack->name;
3322 }
3323
3324 /* Handle an N_EXCL: get the types from the corresponding N_BINCL.  */
3325
3326 static bool
3327 find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
3328 {
3329   struct bincl_file *l;
3330
3331   ++info->files;
3332   info->file_types = ((struct stab_types **)
3333                       xrealloc (info->file_types,
3334                                 (info->files
3335                                  * sizeof *info->file_types)));
3336
3337   for (l = info->bincl_list; l != NULL; l = l->next)
3338     if (l->hash == hash && strcmp (l->name, name) == 0)
3339       break;
3340   if (l == NULL)
3341     {
3342       warn_stab (name, _("Undefined N_EXCL"));
3343       info->file_types[info->files - 1] = NULL;
3344       return true;
3345     }
3346
3347   info->file_types[info->files - 1] = l->file_types;
3348
3349   return true;
3350 }
3351
3352 /* Handle a variable definition.  gcc emits variable definitions for a
3353    block before the N_LBRAC, so we must hold onto them until we see
3354    it.  The SunPRO compiler emits variable definitions after the
3355    N_LBRAC, so we can call debug_record_variable immediately.  */
3356
3357 static bool
3358 stab_record_variable (void *dhandle, struct stab_handle *info,
3359                       const char *name, debug_type type,
3360                       enum debug_var_kind kind, bfd_vma val)
3361 {
3362   struct stab_pending_var *v;
3363
3364   if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
3365       || ! info->within_function
3366       || (info->gcc_compiled == 0 && info->n_opt_found))
3367     return debug_record_variable (dhandle, name, type, kind, val);
3368
3369   v = (struct stab_pending_var *) xmalloc (sizeof *v);
3370   memset (v, 0, sizeof *v);
3371
3372   v->next = info->pending;
3373   v->name = name;
3374   v->type = type;
3375   v->kind = kind;
3376   v->val = val;
3377   info->pending = v;
3378
3379   return true;
3380 }
3381
3382 /* Emit pending variable definitions.  This is called after we see the
3383    N_LBRAC that starts the block.  */
3384
3385 static bool
3386 stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
3387 {
3388   struct stab_pending_var *v;
3389
3390   v = info->pending;
3391   while (v != NULL)
3392     {
3393       struct stab_pending_var *next;
3394
3395       if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
3396         return false;
3397
3398       next = v->next;
3399       free (v);
3400       v = next;
3401     }
3402
3403   info->pending = NULL;
3404
3405   return true;
3406 }
3407
3408 /* Find the slot for a type in the database.  */
3409
3410 static debug_type *
3411 stab_find_slot (struct stab_handle *info, const int *typenums)
3412 {
3413   int filenum;
3414   int tindex;
3415   struct stab_types **ps;
3416
3417   filenum = typenums[0];
3418   tindex = typenums[1];
3419
3420   if (filenum < 0 || (unsigned int) filenum >= info->files)
3421     {
3422       fprintf (stderr, _("Type file number %d out of range\n"), filenum);
3423       return NULL;
3424     }
3425   if (tindex < 0)
3426     {
3427       fprintf (stderr, _("Type index number %d out of range\n"), tindex);
3428       return NULL;
3429     }
3430
3431   ps = info->file_types + filenum;
3432
3433   while (tindex >= STAB_TYPES_SLOTS)
3434     {
3435       if (*ps == NULL)
3436         {
3437           *ps = (struct stab_types *) xmalloc (sizeof **ps);
3438           memset (*ps, 0, sizeof **ps);
3439         }
3440       ps = &(*ps)->next;
3441       tindex -= STAB_TYPES_SLOTS;
3442     }
3443   if (*ps == NULL)
3444     {
3445       *ps = (struct stab_types *) xmalloc (sizeof **ps);
3446       memset (*ps, 0, sizeof **ps);
3447     }
3448
3449   return (*ps)->types + tindex;
3450 }
3451
3452 /* Find a type given a type number.  If the type has not been
3453    allocated yet, create an indirect type.  */
3454
3455 static debug_type
3456 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums)
3457 {
3458   debug_type *slot;
3459
3460   if (typenums[0] == 0 && typenums[1] < 0)
3461     {
3462       /* A negative type number indicates an XCOFF builtin type.  */
3463       return stab_xcoff_builtin_type (dhandle, info, typenums[1]);
3464     }
3465
3466   slot = stab_find_slot (info, typenums);
3467   if (slot == NULL)
3468     return DEBUG_TYPE_NULL;
3469
3470   if (*slot == DEBUG_TYPE_NULL)
3471     return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
3472
3473   return *slot;
3474 }
3475
3476 /* Record that a given type number refers to a given type.  */
3477
3478 static bool
3479 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
3480                   const int *typenums, debug_type type)
3481 {
3482   debug_type *slot;
3483
3484   slot = stab_find_slot (info, typenums);
3485   if (slot == NULL)
3486     return false;
3487
3488   /* gdb appears to ignore type redefinitions, so we do as well.  */
3489
3490   *slot = type;
3491
3492   return true;
3493 }
3494
3495 /* Return an XCOFF builtin type.  */
3496
3497 static debug_type
3498 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info,
3499                          unsigned int typenum)
3500 {
3501   debug_type rettype;
3502   const char *name;
3503
3504   typenum = -typenum - 1;
3505   if (typenum >= XCOFF_TYPE_COUNT)
3506     {
3507       fprintf (stderr, _("Unrecognized XCOFF type %d\n"), -typenum - 1);
3508       return DEBUG_TYPE_NULL;
3509     }
3510   if (info->xcoff_types[typenum] != NULL)
3511     return info->xcoff_types[typenum];
3512
3513   switch (typenum)
3514     {
3515     case 0:
3516       /* The size of this and all the other types are fixed, defined
3517          by the debugging format.  */
3518       name = "int";
3519       rettype = debug_make_int_type (dhandle, 4, false);
3520       break;
3521     case 1:
3522       name = "char";
3523       rettype = debug_make_int_type (dhandle, 1, false);
3524       break;
3525     case 2:
3526       name = "short";
3527       rettype = debug_make_int_type (dhandle, 2, false);
3528       break;
3529     case 3:
3530       name = "long";
3531       rettype = debug_make_int_type (dhandle, 4, false);
3532       break;
3533     case 4:
3534       name = "unsigned char";
3535       rettype = debug_make_int_type (dhandle, 1, true);
3536       break;
3537     case 5:
3538       name = "signed char";
3539       rettype = debug_make_int_type (dhandle, 1, false);
3540       break;
3541     case 6:
3542       name = "unsigned short";
3543       rettype = debug_make_int_type (dhandle, 2, true);
3544       break;
3545     case 7:
3546       name = "unsigned int";
3547       rettype = debug_make_int_type (dhandle, 4, true);
3548       break;
3549     case 8:
3550       name = "unsigned";
3551       rettype = debug_make_int_type (dhandle, 4, true);
3552       break;
3553     case 9:
3554       name = "unsigned long";
3555       rettype = debug_make_int_type (dhandle, 4, true);
3556       break;
3557     case 10:
3558       name = "void";
3559       rettype = debug_make_void_type (dhandle);
3560       break;
3561     case 11:
3562       /* IEEE single precision (32 bit).  */
3563       name = "float";
3564       rettype = debug_make_float_type (dhandle, 4);
3565       break;
3566     case 12:
3567       /* IEEE double precision (64 bit).  */
3568       name = "double";
3569       rettype = debug_make_float_type (dhandle, 8);
3570       break;
3571     case 13:
3572       /* This is an IEEE double on the RS/6000, and different machines
3573          with different sizes for "long double" should use different
3574          negative type numbers.  See stabs.texinfo.  */
3575       name = "long double";
3576       rettype = debug_make_float_type (dhandle, 8);
3577       break;
3578     case 14:
3579       name = "integer";
3580       rettype = debug_make_int_type (dhandle, 4, false);
3581       break;
3582     case 15:
3583       name = "boolean";
3584       rettype = debug_make_bool_type (dhandle, 4);
3585       break;
3586     case 16:
3587       name = "short real";
3588       rettype = debug_make_float_type (dhandle, 4);
3589       break;
3590     case 17:
3591       name = "real";
3592       rettype = debug_make_float_type (dhandle, 8);
3593       break;
3594     case 18:
3595       /* FIXME */
3596       name = "stringptr";
3597       rettype = NULL;
3598       break;
3599     case 19:
3600       /* FIXME */
3601       name = "character";
3602       rettype = debug_make_int_type (dhandle, 1, true);
3603       break;
3604     case 20:
3605       name = "logical*1";
3606       rettype = debug_make_bool_type (dhandle, 1);
3607       break;
3608     case 21:
3609       name = "logical*2";
3610       rettype = debug_make_bool_type (dhandle, 2);
3611       break;
3612     case 22:
3613       name = "logical*4";
3614       rettype = debug_make_bool_type (dhandle, 4);
3615       break;
3616     case 23:
3617       name = "logical";
3618       rettype = debug_make_bool_type (dhandle, 4);
3619       break;
3620     case 24:
3621       /* Complex type consisting of two IEEE single precision values.  */
3622       name = "complex";
3623       rettype = debug_make_complex_type (dhandle, 8);
3624       break;
3625     case 25:
3626       /* Complex type consisting of two IEEE double precision values.  */
3627       name = "double complex";
3628       rettype = debug_make_complex_type (dhandle, 16);
3629       break;
3630     case 26:
3631       name = "integer*1";
3632       rettype = debug_make_int_type (dhandle, 1, false);
3633       break;
3634     case 27:
3635       name = "integer*2";
3636       rettype = debug_make_int_type (dhandle, 2, false);
3637       break;
3638     case 28:
3639       name = "integer*4";
3640       rettype = debug_make_int_type (dhandle, 4, false);
3641       break;
3642     case 29:
3643       /* FIXME */
3644       name = "wchar";
3645       rettype = debug_make_int_type (dhandle, 2, false);
3646       break;
3647     case 30:
3648       name = "long long";
3649       rettype = debug_make_int_type (dhandle, 8, false);
3650       break;
3651     case 31:
3652       name = "unsigned long long";
3653       rettype = debug_make_int_type (dhandle, 8, true);
3654       break;
3655     case 32:
3656       name = "logical*8";
3657       rettype = debug_make_bool_type (dhandle, 8);
3658       break;
3659     case 33:
3660       name = "integer*8";
3661       rettype = debug_make_int_type (dhandle, 8, false);
3662       break;
3663     default:
3664       abort ();
3665     }
3666
3667   rettype = debug_name_type (dhandle, name, rettype);
3668   info->xcoff_types[typenum] = rettype;
3669   return rettype;
3670 }
3671
3672 /* Find or create a tagged type.  */
3673
3674 static debug_type
3675 stab_find_tagged_type (void *dhandle, struct stab_handle *info,
3676                        const char *p, int len, enum debug_type_kind kind)
3677 {
3678   char *name;
3679   debug_type dtype;
3680   struct stab_tag *st;
3681
3682   name = savestring (p, len);
3683
3684   /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3685      namespace.  This is right for C, and I don't know how to handle
3686      other languages.  FIXME.  */
3687   dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL);
3688   if (dtype != DEBUG_TYPE_NULL)
3689     {
3690       free (name);
3691       return dtype;
3692     }
3693
3694   /* We need to allocate an entry on the undefined tag list.  */
3695   for (st = info->tags; st != NULL; st = st->next)
3696     {
3697       if (st->name[0] == name[0]
3698           && strcmp (st->name, name) == 0)
3699         {
3700           if (st->kind == DEBUG_KIND_ILLEGAL)
3701             st->kind = kind;
3702           free (name);
3703           break;
3704         }
3705     }
3706   if (st == NULL)
3707     {
3708       st = (struct stab_tag *) xmalloc (sizeof *st);
3709       memset (st, 0, sizeof *st);
3710
3711       st->next = info->tags;
3712       st->name = name;
3713       st->kind = kind;
3714       st->slot = DEBUG_TYPE_NULL;
3715       st->type = debug_make_indirect_type (dhandle, &st->slot, name);
3716       info->tags = st;
3717     }
3718
3719   return st->type;
3720 }
3721 \f
3722 /* In order to get the correct argument types for a stubbed method, we
3723    need to extract the argument types from a C++ mangled string.
3724    Since the argument types can refer back to the return type, this
3725    means that we must demangle the entire physical name.  In gdb this
3726    is done by calling cplus_demangle and running the results back
3727    through the C++ expression parser.  Since we have no expression
3728    parser, we must duplicate much of the work of cplus_demangle here.
3729
3730    We assume that GNU style demangling is used, since this is only
3731    done for method stubs, and only g++ should output that form of
3732    debugging information.  */
3733
3734 /* This structure is used to hold a pointer to type information which
3735    demangling a string.  */
3736
3737 struct stab_demangle_typestring
3738 {
3739   /* The start of the type.  This is not null terminated.  */
3740   const char *typestring;
3741   /* The length of the type.  */
3742   unsigned int len;
3743 };
3744
3745 /* This structure is used to hold information while demangling a
3746    string.  */
3747
3748 struct stab_demangle_info
3749 {
3750   /* The debugging information handle.  */
3751   void *dhandle;
3752   /* The stab information handle.  */
3753   struct stab_handle *info;
3754   /* The array of arguments we are building.  */
3755   debug_type *args;
3756   /* Whether the method takes a variable number of arguments.  */
3757   bool varargs;
3758   /* The array of types we have remembered.  */
3759   struct stab_demangle_typestring *typestrings;
3760   /* The number of typestrings.  */
3761   unsigned int typestring_count;
3762   /* The number of typestring slots we have allocated.  */
3763   unsigned int typestring_alloc;
3764 };
3765
3766 static void stab_bad_demangle (const char *);
3767 static unsigned int stab_demangle_count (const char **);
3768 static bool stab_demangle_get_count (const char **, unsigned int *);
3769 static bool stab_demangle_prefix
3770   (struct stab_demangle_info *, const char **, unsigned int);
3771 static bool stab_demangle_function_name
3772   (struct stab_demangle_info *, const char **, const char *);
3773 static bool stab_demangle_signature
3774   (struct stab_demangle_info *, const char **);
3775 static bool stab_demangle_qualified
3776   (struct stab_demangle_info *, const char **, debug_type *);
3777 static bool stab_demangle_template
3778   (struct stab_demangle_info *, const char **, char **);
3779 static bool stab_demangle_class
3780   (struct stab_demangle_info *, const char **, const char **);
3781 static bool stab_demangle_args
3782   (struct stab_demangle_info *, const char **, debug_type **, bool *);
3783 static bool stab_demangle_arg
3784   (struct stab_demangle_info *, const char **, debug_type **,
3785    unsigned int *, unsigned int *);
3786 static bool stab_demangle_type
3787   (struct stab_demangle_info *, const char **, debug_type *);
3788 static bool stab_demangle_fund_type
3789   (struct stab_demangle_info *, const char **, debug_type *);
3790 static bool stab_demangle_remember_type
3791   (struct stab_demangle_info *, const char *, int);
3792
3793 /* Warn about a bad demangling.  */
3794
3795 static void
3796 stab_bad_demangle (const char *s)
3797 {
3798   fprintf (stderr, _("bad mangled name `%s'\n"), s);
3799 }
3800
3801 /* Get a count from a stab string.  */
3802
3803 static unsigned int
3804 stab_demangle_count (const char **pp)
3805 {
3806   unsigned int count;
3807
3808   count = 0;
3809   while (ISDIGIT (**pp))
3810     {
3811       count *= 10;
3812       count += **pp - '0';
3813       ++*pp;
3814     }
3815   return count;
3816 }
3817
3818 /* Require a count in a string.  The count may be multiple digits, in
3819    which case it must end in an underscore.  */
3820
3821 static bool
3822 stab_demangle_get_count (const char **pp, unsigned int *pi)
3823 {
3824   if (! ISDIGIT (**pp))
3825     return false;
3826
3827   *pi = **pp - '0';
3828   ++*pp;
3829   if (ISDIGIT (**pp))
3830     {
3831       unsigned int count;
3832       const char *p;
3833
3834       count = *pi;
3835       p = *pp;
3836       do
3837         {
3838           count *= 10;
3839           count += *p - '0';
3840           ++p;
3841         }
3842       while (ISDIGIT (*p));
3843       if (*p == '_')
3844         {
3845           *pp = p + 1;
3846           *pi = count;
3847         }
3848     }
3849
3850   return true;
3851 }
3852
3853 /* This function demangles a physical name, returning a NULL
3854    terminated array of argument types.  */
3855
3856 static debug_type *
3857 stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
3858                         const char *physname, bool *pvarargs,
3859                         unsigned int physname_len)
3860 {
3861   struct stab_demangle_info minfo;
3862
3863   /* Check for the g++ V3 ABI.  */
3864   if (physname[0] == '_' && physname[1] == 'Z')
3865     return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs);
3866
3867   minfo.dhandle = dhandle;
3868   minfo.info = info;
3869   minfo.args = NULL;
3870   minfo.varargs = false;
3871   minfo.typestring_alloc = 10;
3872   minfo.typestrings = ((struct stab_demangle_typestring *)
3873                        xmalloc (minfo.typestring_alloc
3874                                 * sizeof *minfo.typestrings));
3875   minfo.typestring_count = 0;
3876
3877   /* cplus_demangle checks for special GNU mangled forms, but we can't
3878      see any of them in mangled method argument types.  */
3879
3880   if (! stab_demangle_prefix (&minfo, &physname, physname_len))
3881     goto error_return;
3882
3883   if (*physname != '\0')
3884     {
3885       if (! stab_demangle_signature (&minfo, &physname))
3886         goto error_return;
3887     }
3888
3889   free (minfo.typestrings);
3890   minfo.typestrings = NULL;
3891
3892   if (minfo.args == NULL)
3893     fprintf (stderr, _("no argument types in mangled string\n"));
3894
3895   *pvarargs = minfo.varargs;
3896   return minfo.args;
3897
3898  error_return:
3899   free (minfo.typestrings);
3900   return NULL;
3901 }
3902
3903 /* Demangle the prefix of the mangled name.  */
3904
3905 static bool
3906 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
3907                       unsigned int physname_len)
3908 {
3909   const char *scan;
3910   unsigned int i;
3911
3912   /* cplus_demangle checks for global constructors and destructors,
3913      but we can't see them in mangled argument types.  */
3914
3915   if (physname_len)
3916     scan = *pp + physname_len;
3917   else
3918     {
3919       /* Look for `__'.  */
3920       scan = *pp;
3921       do
3922         scan = strchr (scan, '_');
3923       while (scan != NULL && *++scan != '_');
3924
3925       if (scan == NULL)
3926         {
3927           stab_bad_demangle (*pp);
3928           return false;
3929         }
3930
3931       --scan;
3932
3933       /* We found `__'; move ahead to the last contiguous `__' pair.  */
3934       i = strspn (scan, "_");
3935       if (i > 2)
3936         scan += i - 2;
3937     }
3938
3939   if (scan == *pp
3940       && (ISDIGIT (scan[2])
3941           || scan[2] == 'Q'
3942           || scan[2] == 't'))
3943     {
3944       /* This is a GNU style constructor name.  */
3945       *pp = scan + 2;
3946       return true;
3947     }
3948   else if (scan == *pp
3949            && ! ISDIGIT (scan[2])
3950            && scan[2] != 't')
3951     {
3952       /* Look for the `__' that separates the prefix from the
3953          signature.  */
3954       while (*scan == '_')
3955         ++scan;
3956       scan = strstr (scan, "__");
3957       if (scan == NULL || scan[2] == '\0')
3958         {
3959           stab_bad_demangle (*pp);
3960           return false;
3961         }
3962
3963       return stab_demangle_function_name (minfo, pp, scan);
3964     }
3965   else if (scan[2] != '\0')
3966     {
3967       /* The name doesn't start with `__', but it does contain `__'.  */
3968       return stab_demangle_function_name (minfo, pp, scan);
3969     }
3970   else
3971     {
3972       stab_bad_demangle (*pp);
3973       return false;
3974     }
3975   /*NOTREACHED*/
3976 }
3977
3978 /* Demangle a function name prefix.  The scan argument points to the
3979    double underscore which separates the function name from the
3980    signature.  */
3981
3982 static bool
3983 stab_demangle_function_name (struct stab_demangle_info *minfo,
3984                              const char **pp, const char *scan)
3985 {
3986   const char *name;
3987
3988   /* The string from *pp to scan is the name of the function.  We
3989      don't care about the name, since we just looking for argument
3990      types.  However, for conversion operators, the name may include a
3991      type which we must remember in order to handle backreferences.  */
3992
3993   name = *pp;
3994   *pp = scan + 2;
3995
3996   if (*pp - name >= 5
3997            && startswith (name, "type")
3998            && (name[4] == '$' || name[4] == '.'))
3999     {
4000       const char *tem;
4001
4002       /* This is a type conversion operator.  */
4003       tem = name + 5;
4004       if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
4005         return false;
4006     }
4007   else if (name[0] == '_'
4008            && name[1] == '_'
4009            && name[2] == 'o'
4010            && name[3] == 'p')
4011     {
4012       const char *tem;
4013
4014       /* This is a type conversion operator.  */
4015       tem = name + 4;
4016       if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
4017         return false;
4018     }
4019
4020   return true;
4021 }
4022
4023 /* Demangle the signature.  This is where the argument types are
4024    found.  */
4025
4026 static bool
4027 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
4028 {
4029   const char *orig;
4030   bool expect_func, func_done;
4031   const char *hold;
4032
4033   orig = *pp;
4034
4035   expect_func = false;
4036   func_done = false;
4037   hold = NULL;
4038
4039   while (**pp != '\0')
4040     {
4041       switch (**pp)
4042         {
4043         case 'Q':
4044           hold = *pp;
4045           if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
4046               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4047             return false;
4048           expect_func = true;
4049           hold = NULL;
4050           break;
4051
4052         case 'S':
4053           /* Static member function.  FIXME: Can this happen?  */
4054           if (hold == NULL)
4055             hold = *pp;
4056           ++*pp;
4057           break;
4058
4059         case 'C':
4060           /* Const member function.  */
4061           if (hold == NULL)
4062             hold = *pp;
4063           ++*pp;
4064           break;
4065
4066         case '0': case '1': case '2': case '3': case '4':
4067         case '5': case '6': case '7': case '8': case '9':
4068           if (hold == NULL)
4069             hold = *pp;
4070           if (! stab_demangle_class (minfo, pp, (const char **) NULL)
4071               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4072             return false;
4073           expect_func = true;
4074           hold = NULL;
4075           break;
4076
4077         case 'F':
4078           /* Function.  I don't know if this actually happens with g++
4079              output.  */
4080           hold = NULL;
4081           func_done = true;
4082           ++*pp;
4083           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4084             return false;
4085           break;
4086
4087         case 't':
4088           /* Template.  */
4089           if (hold == NULL)
4090             hold = *pp;
4091           if (! stab_demangle_template (minfo, pp, (char **) NULL)
4092               || ! stab_demangle_remember_type (minfo, hold, *pp - hold))
4093             return false;
4094           hold = NULL;
4095           expect_func = true;
4096           break;
4097
4098         case '_':
4099           /* At the outermost level, we cannot have a return type
4100              specified, so if we run into another '_' at this point we
4101              are dealing with a mangled name that is either bogus, or
4102              has been mangled by some algorithm we don't know how to
4103              deal with.  So just reject the entire demangling.  */
4104           stab_bad_demangle (orig);
4105           return false;
4106
4107         default:
4108           /* Assume we have stumbled onto the first outermost function
4109              argument token, and start processing args.  */
4110           func_done = true;
4111           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4112             return false;
4113           break;
4114         }
4115
4116       if (expect_func)
4117         {
4118           func_done = true;
4119           if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4120             return false;
4121         }
4122     }
4123
4124   if (! func_done)
4125     {
4126       /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4127          bar__3fooi is 'foo::bar(int)'.  We get here when we find the
4128          first case, and need to ensure that the '(void)' gets added
4129          to the current declp.  */
4130       if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
4131         return false;
4132     }
4133
4134   return true;
4135 }
4136
4137 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4138    mangled form of "Outer::Inner".  */
4139
4140 static bool
4141 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
4142                          debug_type *ptype)
4143 {
4144   const char *orig;
4145   const char *p;
4146   unsigned int qualifiers;
4147   debug_type context;
4148
4149   orig = *pp;
4150
4151   switch ((*pp)[1])
4152     {
4153     case '_':
4154       /* GNU mangled name with more than 9 classes.  The count is
4155          preceded by an underscore (to distinguish it from the <= 9
4156          case) and followed by an underscore.  */
4157       p = *pp + 2;
4158       if (! ISDIGIT (*p) || *p == '0')
4159         {
4160           stab_bad_demangle (orig);
4161           return false;
4162         }
4163       qualifiers = atoi (p);
4164       while (ISDIGIT (*p))
4165         ++p;
4166       if (*p != '_')
4167         {
4168           stab_bad_demangle (orig);
4169           return false;
4170         }
4171       *pp = p + 1;
4172       break;
4173
4174     case '1': case '2': case '3': case '4': case '5':
4175     case '6': case '7': case '8': case '9':
4176       qualifiers = (*pp)[1] - '0';
4177       /* Skip an optional underscore after the count.  */
4178       if ((*pp)[2] == '_')
4179         ++*pp;
4180       *pp += 2;
4181       break;
4182
4183     case '0':
4184     default:
4185       stab_bad_demangle (orig);
4186       return false;
4187     }
4188
4189   context = DEBUG_TYPE_NULL;
4190
4191   /* Pick off the names.  */
4192   while (qualifiers-- > 0)
4193     {
4194       if (**pp == '_')
4195         ++*pp;
4196       if (**pp == 't')
4197         {
4198           char *name;
4199
4200           if (! stab_demangle_template (minfo, pp,
4201                                         ptype != NULL ? &name : NULL))
4202             return false;
4203
4204           if (ptype != NULL)
4205             {
4206               context = stab_find_tagged_type (minfo->dhandle, minfo->info,
4207                                                name, strlen (name),
4208                                                DEBUG_KIND_CLASS);
4209               free (name);
4210               if (context == DEBUG_TYPE_NULL)
4211                 return false;
4212             }
4213         }
4214       else
4215         {
4216           unsigned int len;
4217
4218           len = stab_demangle_count (pp);
4219           if (strlen (*pp) < len)
4220             {
4221               stab_bad_demangle (orig);
4222               return false;
4223             }
4224
4225           if (ptype != NULL)
4226             {
4227               const debug_field *fields;
4228
4229               fields = NULL;
4230               if (context != DEBUG_TYPE_NULL)
4231                 fields = debug_get_fields (minfo->dhandle, context);
4232
4233               context = DEBUG_TYPE_NULL;
4234
4235               if (fields != NULL)
4236                 {
4237                   char *name;
4238
4239                   /* Try to find the type by looking through the
4240                      fields of context until we find a field with the
4241                      same type.  This ought to work for a class
4242                      defined within a class, but it won't work for,
4243                      e.g., an enum defined within a class.  stabs does
4244                      not give us enough information to figure out the
4245                      latter case.  */
4246
4247                   name = savestring (*pp, len);
4248
4249                   for (; *fields != DEBUG_FIELD_NULL; fields++)
4250                     {
4251                       debug_type ft;
4252                       const char *dn;
4253
4254                       ft = debug_get_field_type (minfo->dhandle, *fields);
4255                       if (ft == NULL)
4256                         {
4257                           free (name);
4258                           return false;
4259                         }
4260                       dn = debug_get_type_name (minfo->dhandle, ft);
4261                       if (dn != NULL && strcmp (dn, name) == 0)
4262                         {
4263                           context = ft;
4264                           break;
4265                         }
4266                     }
4267
4268                   free (name);
4269                 }
4270
4271               if (context == DEBUG_TYPE_NULL)
4272                 {
4273                   /* We have to fall back on finding the type by name.
4274                      If there are more types to come, then this must
4275                      be a class.  Otherwise, it could be anything.  */
4276
4277                   if (qualifiers == 0)
4278                     {
4279                       char *name;
4280
4281                       name = savestring (*pp, len);
4282                       context = debug_find_named_type (minfo->dhandle,
4283                                                        name);
4284                       free (name);
4285                     }
4286
4287                   if (context == DEBUG_TYPE_NULL)
4288                     {
4289                       context = stab_find_tagged_type (minfo->dhandle,
4290                                                        minfo->info,
4291                                                        *pp, len,
4292                                                        (qualifiers == 0
4293                                                         ? DEBUG_KIND_ILLEGAL
4294                                                         : DEBUG_KIND_CLASS));
4295                       if (context == DEBUG_TYPE_NULL)
4296                         return false;
4297                     }
4298                 }
4299             }
4300
4301           *pp += len;
4302         }
4303     }
4304
4305   if (ptype != NULL)
4306     *ptype = context;
4307
4308   return true;
4309 }
4310
4311 /* Demangle a template.  If PNAME is not NULL, this sets *PNAME to a
4312    string representation of the template.  */
4313
4314 static bool
4315 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
4316                         char **pname)
4317 {
4318   const char *orig;
4319   unsigned int r, i;
4320
4321   orig = *pp;
4322
4323   ++*pp;
4324
4325   /* Skip the template name.  */
4326   r = stab_demangle_count (pp);
4327   if (r == 0 || strlen (*pp) < r)
4328     {
4329       stab_bad_demangle (orig);
4330       return false;
4331     }
4332   *pp += r;
4333
4334   /* Get the size of the parameter list.  */
4335   if (stab_demangle_get_count (pp, &r) == 0)
4336     {
4337       stab_bad_demangle (orig);
4338       return false;
4339     }
4340
4341   for (i = 0; i < r; i++)
4342     {
4343       if (**pp == 'Z')
4344         {
4345           /* This is a type parameter.  */
4346           ++*pp;
4347           if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4348             return false;
4349         }
4350       else
4351         {
4352           const char *old_p;
4353           bool pointerp, realp, integralp, charp, boolp;
4354           bool done;
4355
4356           old_p = *pp;
4357           pointerp = false;
4358           realp = false;
4359           integralp = false;
4360           charp = false;
4361           boolp = false;
4362           done = false;
4363
4364           /* This is a value parameter.  */
4365
4366           if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
4367             return false;
4368
4369           while (*old_p != '\0' && ! done)
4370             {
4371               switch (*old_p)
4372                 {
4373                 case 'P':
4374                 case 'p':
4375                 case 'R':
4376                   pointerp = true;
4377                   done = true;
4378                   break;
4379                 case 'C':       /* Const.  */
4380                 case 'S':       /* Signed.  */
4381                 case 'U':       /* Unsigned.  */
4382                 case 'V':       /* Volatile.  */
4383                 case 'F':       /* Function.  */
4384                 case 'M':       /* Member function.  */
4385                 case 'O':       /* ??? */
4386                   ++old_p;
4387                   break;
4388                 case 'Q':       /* Qualified name.  */
4389                   integralp = true;
4390                   done = true;
4391                   break;
4392                 case 'T':       /* Remembered type.  */
4393                   abort ();
4394                 case 'v':       /* Void.  */
4395                   abort ();
4396                 case 'x':       /* Long long.  */
4397                 case 'l':       /* Long.  */
4398                 case 'i':       /* Int.  */
4399                 case 's':       /* Short.  */
4400                 case 'w':       /* Wchar_t.  */
4401                   integralp = true;
4402                   done = true;
4403                   break;
4404                 case 'b':       /* Bool.  */
4405                   boolp = true;
4406                   done = true;
4407                   break;
4408                 case 'c':       /* Char.  */
4409                   charp = true;
4410                   done = true;
4411                   break;
4412                 case 'r':       /* Long double.  */
4413                 case 'd':       /* Double.  */
4414                 case 'f':       /* Float.  */
4415                   realp = true;
4416                   done = true;
4417                   break;
4418                 default:
4419                   /* Assume it's a user defined integral type.  */
4420                   integralp = true;
4421                   done = true;
4422                   break;
4423                 }
4424             }
4425
4426           if (integralp)
4427             {
4428               if (**pp == 'm')
4429                 ++*pp;
4430               while (ISDIGIT (**pp))
4431                 ++*pp;
4432             }
4433           else if (charp)
4434             {
4435               unsigned int val;
4436
4437               if (**pp == 'm')
4438                 ++*pp;
4439               val = stab_demangle_count (pp);
4440               if (val == 0)
4441                 {
4442                   stab_bad_demangle (orig);
4443                   return false;
4444                 }
4445             }
4446           else if (boolp)
4447             {
4448               unsigned int val;
4449
4450               val = stab_demangle_count (pp);
4451               if (val != 0 && val != 1)
4452                 {
4453                   stab_bad_demangle (orig);
4454                   return false;
4455                 }
4456             }
4457           else if (realp)
4458             {
4459               if (**pp == 'm')
4460                 ++*pp;
4461               while (ISDIGIT (**pp))
4462                 ++*pp;
4463               if (**pp == '.')
4464                 {
4465                   ++*pp;
4466                   while (ISDIGIT (**pp))
4467                     ++*pp;
4468                 }
4469               if (**pp == 'e')
4470                 {
4471                   ++*pp;
4472                   while (ISDIGIT (**pp))
4473                     ++*pp;
4474                 }
4475             }
4476           else if (pointerp)
4477             {
4478               unsigned int len;
4479
4480               len = stab_demangle_count (pp);
4481               if (len == 0)
4482                 {
4483                   stab_bad_demangle (orig);
4484                   return false;
4485                 }
4486               *pp += len;
4487             }
4488         }
4489     }
4490
4491   /* We can translate this to a string fairly easily by invoking the
4492      regular demangling routine.  */
4493   if (pname != NULL)
4494     {
4495       char *s1, *s2, *s3, *s4 = NULL;
4496       char *from, *to;
4497
4498       s1 = savestring (orig, *pp - orig);
4499
4500       s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL);
4501
4502       free (s1);
4503
4504       s3 = cplus_demangle (s2, demangle_flags);
4505
4506       free (s2);
4507
4508       if (s3 != NULL)
4509         s4 = strstr (s3, "::NoSuchStrinG");
4510       if (s3 == NULL || s4 == NULL)
4511         {
4512           stab_bad_demangle (orig);
4513           free (s3);
4514           return false;
4515         }
4516
4517       /* Eliminating all spaces, except those between > characters,
4518          makes it more likely that the demangled name will match the
4519          name which g++ used as the structure name.  */
4520       for (from = to = s3; from != s4; ++from)
4521         if (*from != ' '
4522             || (from[1] == '>' && from > s3 && from[-1] == '>'))
4523           *to++ = *from;
4524
4525       *pname = savestring (s3, to - s3);
4526
4527       free (s3);
4528     }
4529
4530   return true;
4531 }
4532
4533 /* Demangle a class name.  */
4534
4535 static bool
4536 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
4537                      const char **pp, const char **pstart)
4538 {
4539   const char *orig;
4540   unsigned int n;
4541
4542   orig = *pp;
4543
4544   n = stab_demangle_count (pp);
4545   if (strlen (*pp) < n)
4546     {
4547       stab_bad_demangle (orig);
4548       return false;
4549     }
4550
4551   if (pstart != NULL)
4552     *pstart = *pp;
4553
4554   *pp += n;
4555
4556   return true;
4557 }
4558
4559 /* Demangle function arguments.  If the pargs argument is not NULL, it
4560    is set to a NULL terminated array holding the arguments.  */
4561
4562 static bool
4563 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
4564                     debug_type **pargs, bool *pvarargs)
4565 {
4566   const char *orig;
4567   unsigned int alloc, count;
4568
4569   orig = *pp;
4570
4571   alloc = 10;
4572   if (pargs != NULL)
4573     {
4574       *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
4575       *pvarargs = false;
4576     }
4577   count = 0;
4578
4579   while (**pp != '_' && **pp != '\0' && **pp != 'e')
4580     {
4581       if (**pp == 'N' || **pp == 'T')
4582         {
4583           char temptype;
4584           unsigned int r, t;
4585
4586           temptype = **pp;
4587           ++*pp;
4588
4589           if (temptype == 'T')
4590             r = 1;
4591           else
4592             {
4593               if (! stab_demangle_get_count (pp, &r))
4594                 {
4595                   stab_bad_demangle (orig);
4596                   return false;
4597                 }
4598             }
4599
4600           if (! stab_demangle_get_count (pp, &t))
4601             {
4602               stab_bad_demangle (orig);
4603               return false;
4604             }
4605
4606           if (t >= minfo->typestring_count)
4607             {
4608               stab_bad_demangle (orig);
4609               return false;
4610             }
4611           while (r-- > 0)
4612             {
4613               const char *tem;
4614
4615               tem = minfo->typestrings[t].typestring;
4616               if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
4617                 return false;
4618             }
4619         }
4620       else
4621         {
4622           if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
4623             return false;
4624         }
4625     }
4626
4627   if (pargs != NULL)
4628     (*pargs)[count] = DEBUG_TYPE_NULL;
4629
4630   if (**pp == 'e')
4631     {
4632       if (pargs != NULL)
4633         *pvarargs = true;
4634       ++*pp;
4635     }
4636
4637   return true;
4638 }
4639
4640 /* Demangle a single argument.  */
4641
4642 static bool
4643 stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
4644                    debug_type **pargs, unsigned int *pcount,
4645                    unsigned int *palloc)
4646 {
4647   const char *start;
4648   debug_type type;
4649
4650   start = *pp;
4651   if (! stab_demangle_type (minfo, pp,
4652                             pargs == NULL ? (debug_type *) NULL : &type)
4653       || ! stab_demangle_remember_type (minfo, start, *pp - start))
4654     return false;
4655
4656   if (pargs != NULL)
4657     {
4658       if (type == DEBUG_TYPE_NULL)
4659         return false;
4660
4661       if (*pcount + 1 >= *palloc)
4662         {
4663           *palloc += 10;
4664           *pargs = ((debug_type *)
4665                     xrealloc (*pargs, *palloc * sizeof **pargs));
4666         }
4667       (*pargs)[*pcount] = type;
4668       ++*pcount;
4669     }
4670
4671   return true;
4672 }
4673
4674 /* Demangle a type.  If the ptype argument is not NULL, *ptype is set
4675    to the newly allocated type.  */
4676
4677 static bool
4678 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
4679                     debug_type *ptype)
4680 {
4681   const char *orig;
4682
4683   orig = *pp;
4684
4685   switch (**pp)
4686     {
4687     case 'P':
4688     case 'p':
4689       /* A pointer type.  */
4690       ++*pp;
4691       if (! stab_demangle_type (minfo, pp, ptype))
4692         return false;
4693       if (ptype != NULL)
4694         *ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
4695       break;
4696
4697     case 'R':
4698       /* A reference type.  */
4699       ++*pp;
4700       if (! stab_demangle_type (minfo, pp, ptype))
4701         return false;
4702       if (ptype != NULL)
4703         *ptype = debug_make_reference_type (minfo->dhandle, *ptype);
4704       break;
4705
4706     case 'A':
4707       /* An array.  */
4708       {
4709         unsigned long high;
4710
4711         ++*pp;
4712         high = 0;
4713         while (**pp != '\0' && **pp != '_')
4714           {
4715             if (! ISDIGIT (**pp))
4716               {
4717                 stab_bad_demangle (orig);
4718                 return false;
4719               }
4720             high *= 10;
4721             high += **pp - '0';
4722             ++*pp;
4723           }
4724         if (**pp != '_')
4725           {
4726             stab_bad_demangle (orig);
4727             return false;
4728           }
4729         ++*pp;
4730
4731         if (! stab_demangle_type (minfo, pp, ptype))
4732           return false;
4733         if (ptype != NULL)
4734           {
4735             debug_type int_type;
4736
4737             int_type = debug_find_named_type (minfo->dhandle, "int");
4738             if (int_type == NULL)
4739               int_type = debug_make_int_type (minfo->dhandle, 4, false);
4740             *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
4741                                             0, high, false);
4742           }
4743       }
4744       break;
4745
4746     case 'T':
4747       /* A back reference to a remembered type.  */
4748       {
4749         unsigned int i;
4750         const char *p;
4751
4752         ++*pp;
4753         if (! stab_demangle_get_count (pp, &i))
4754           {
4755             stab_bad_demangle (orig);
4756             return false;
4757           }
4758         if (i >= minfo->typestring_count)
4759           {
4760             stab_bad_demangle (orig);
4761             return false;
4762           }
4763         p = minfo->typestrings[i].typestring;
4764         if (! stab_demangle_type (minfo, &p, ptype))
4765           return false;
4766       }
4767       break;
4768
4769     case 'F':
4770       /* A function.  */
4771       {
4772         debug_type *args;
4773         bool varargs;
4774
4775         ++*pp;
4776         if (! stab_demangle_args (minfo, pp,
4777                                   (ptype == NULL
4778                                    ? (debug_type **) NULL
4779                                    : &args),
4780                                   (ptype == NULL
4781                                    ? (bool *) NULL
4782                                    : &varargs)))
4783           return false;
4784         if (**pp != '_')
4785           {
4786             /* cplus_demangle will accept a function without a return
4787                type, but I don't know when that will happen, or what
4788                to do if it does.  */
4789             stab_bad_demangle (orig);
4790             return false;
4791           }
4792         ++*pp;
4793         if (! stab_demangle_type (minfo, pp, ptype))
4794           return false;
4795         if (ptype != NULL)
4796           *ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
4797                                              varargs);
4798
4799       }
4800       break;
4801
4802     case 'M':
4803     case 'O':
4804       {
4805         bool memberp;
4806         debug_type class_type = DEBUG_TYPE_NULL;
4807         debug_type *args;
4808         bool varargs;
4809         unsigned int n;
4810         const char *name;
4811
4812         memberp = **pp == 'M';
4813         args = NULL;
4814         varargs = false;
4815
4816         ++*pp;
4817         if (ISDIGIT (**pp))
4818           {
4819             n = stab_demangle_count (pp);
4820             if (strlen (*pp) < n)
4821               {
4822                 stab_bad_demangle (orig);
4823                 return false;
4824               }
4825             name = *pp;
4826             *pp += n;
4827
4828             if (ptype != NULL)
4829               {
4830                 class_type = stab_find_tagged_type (minfo->dhandle,
4831                                                     minfo->info,
4832                                                     name, (int) n,
4833                                                     DEBUG_KIND_CLASS);
4834                 if (class_type == DEBUG_TYPE_NULL)
4835                   return false;
4836               }
4837           }
4838         else if (**pp == 'Q')
4839           {
4840             if (! stab_demangle_qualified (minfo, pp,
4841                                            (ptype == NULL
4842                                             ? (debug_type *) NULL
4843                                             : &class_type)))
4844               return false;
4845           }
4846         else
4847           {
4848             stab_bad_demangle (orig);
4849             return false;
4850           }
4851
4852         if (memberp)
4853           {
4854             if (**pp == 'C')
4855               {
4856                 ++*pp;
4857               }
4858             else if (**pp == 'V')
4859               {
4860                 ++*pp;
4861               }
4862             if (**pp != 'F')
4863               {
4864                 stab_bad_demangle (orig);
4865                 return false;
4866               }
4867             ++*pp;
4868             if (! stab_demangle_args (minfo, pp,
4869                                       (ptype == NULL
4870                                        ? (debug_type **) NULL
4871                                        : &args),
4872                                       (ptype == NULL
4873                                        ? (bool *) NULL
4874                                        : &varargs)))
4875               return false;
4876           }
4877
4878         if (**pp != '_')
4879           {
4880             stab_bad_demangle (orig);
4881             return false;
4882           }
4883         ++*pp;
4884
4885         if (! stab_demangle_type (minfo, pp, ptype))
4886           return false;
4887
4888         if (ptype != NULL)
4889           {
4890             if (! memberp)
4891               *ptype = debug_make_offset_type (minfo->dhandle, class_type,
4892                                                *ptype);
4893             else
4894               {
4895                 /* FIXME: We have no way to record constp or
4896                    volatilep.  */
4897                 *ptype = debug_make_method_type (minfo->dhandle, *ptype,
4898                                                  class_type, args, varargs);
4899               }
4900           }
4901       }
4902       break;
4903
4904     case 'G':
4905       ++*pp;
4906       if (! stab_demangle_type (minfo, pp, ptype))
4907         return false;
4908       break;
4909
4910     case 'C':
4911       ++*pp;
4912       if (! stab_demangle_type (minfo, pp, ptype))
4913         return false;
4914       if (ptype != NULL)
4915         *ptype = debug_make_const_type (minfo->dhandle, *ptype);
4916       break;
4917
4918     case 'Q':
4919       {
4920         if (! stab_demangle_qualified (minfo, pp, ptype))
4921           return false;
4922       }
4923       break;
4924
4925     default:
4926       if (! stab_demangle_fund_type (minfo, pp, ptype))
4927         return false;
4928       break;
4929     }
4930
4931   return true;
4932 }
4933
4934 /* Demangle a fundamental type.  If the ptype argument is not NULL,
4935    *ptype is set to the newly allocated type.  */
4936
4937 static bool
4938 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
4939                          debug_type *ptype)
4940 {
4941   const char *orig;
4942   bool constp, volatilep, unsignedp, signedp;
4943   bool done;
4944
4945   orig = *pp;
4946
4947   constp = false;
4948   volatilep = false;
4949   unsignedp = false;
4950   signedp = false;
4951
4952   done = false;
4953   while (! done)
4954     {
4955       switch (**pp)
4956         {
4957         case 'C':
4958           constp = true;
4959           ++*pp;
4960           break;
4961
4962         case 'U':
4963           unsignedp = true;
4964           ++*pp;
4965           break;
4966
4967         case 'S':
4968           signedp = true;
4969           ++*pp;
4970           break;
4971
4972         case 'V':
4973           volatilep = true;
4974           ++*pp;
4975           break;
4976
4977         default:
4978           done = true;
4979           break;
4980         }
4981     }
4982
4983   switch (**pp)
4984     {
4985     case '\0':
4986     case '_':
4987       /* cplus_demangle permits this, but I don't know what it means.  */
4988       stab_bad_demangle (orig);
4989       break;
4990
4991     case 'v': /* void */
4992       if (ptype != NULL)
4993         {
4994           *ptype = debug_find_named_type (minfo->dhandle, "void");
4995           if (*ptype == DEBUG_TYPE_NULL)
4996             *ptype = debug_make_void_type (minfo->dhandle);
4997         }
4998       ++*pp;
4999       break;
5000
5001     case 'x': /* long long */
5002       if (ptype != NULL)
5003         {
5004           *ptype = debug_find_named_type (minfo->dhandle,
5005                                           (unsignedp
5006                                            ? "long long unsigned int"
5007                                            : "long long int"));
5008           if (*ptype == DEBUG_TYPE_NULL)
5009             *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp);
5010         }
5011       ++*pp;
5012       break;
5013
5014     case 'l': /* long */
5015       if (ptype != NULL)
5016         {
5017           *ptype = debug_find_named_type (minfo->dhandle,
5018                                           (unsignedp
5019                                            ? "long unsigned int"
5020                                            : "long int"));
5021           if (*ptype == DEBUG_TYPE_NULL)
5022             *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
5023         }
5024       ++*pp;
5025       break;
5026
5027     case 'i': /* int */
5028       if (ptype != NULL)
5029         {
5030           *ptype = debug_find_named_type (minfo->dhandle,
5031                                           (unsignedp
5032                                            ? "unsigned int"
5033                                            : "int"));
5034           if (*ptype == DEBUG_TYPE_NULL)
5035             *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp);
5036         }
5037       ++*pp;
5038       break;
5039
5040     case 's': /* short */
5041       if (ptype != NULL)
5042         {
5043           *ptype = debug_find_named_type (minfo->dhandle,
5044                                           (unsignedp
5045                                            ? "short unsigned int"
5046                                            : "short int"));
5047           if (*ptype == DEBUG_TYPE_NULL)
5048             *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp);
5049         }
5050       ++*pp;
5051       break;
5052
5053     case 'b': /* bool */
5054       if (ptype != NULL)
5055         {
5056           *ptype = debug_find_named_type (minfo->dhandle, "bool");
5057           if (*ptype == DEBUG_TYPE_NULL)
5058             *ptype = debug_make_bool_type (minfo->dhandle, 4);
5059         }
5060       ++*pp;
5061       break;
5062
5063     case 'c': /* char */
5064       if (ptype != NULL)
5065         {
5066           *ptype = debug_find_named_type (minfo->dhandle,
5067                                           (unsignedp
5068                                            ? "unsigned char"
5069                                            : (signedp
5070                                               ? "signed char"
5071                                               : "char")));
5072           if (*ptype == DEBUG_TYPE_NULL)
5073             *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp);
5074         }
5075       ++*pp;
5076       break;
5077
5078     case 'w': /* wchar_t */
5079       if (ptype != NULL)
5080         {
5081           *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
5082           if (*ptype == DEBUG_TYPE_NULL)
5083             *ptype = debug_make_int_type (minfo->dhandle, 2, true);
5084         }
5085       ++*pp;
5086       break;
5087
5088     case 'r': /* long double */
5089       if (ptype != NULL)
5090         {
5091           *ptype = debug_find_named_type (minfo->dhandle, "long double");
5092           if (*ptype == DEBUG_TYPE_NULL)
5093             *ptype = debug_make_float_type (minfo->dhandle, 8);
5094         }
5095       ++*pp;
5096       break;
5097
5098     case 'd': /* double */
5099       if (ptype != NULL)
5100         {
5101           *ptype = debug_find_named_type (minfo->dhandle, "double");
5102           if (*ptype == DEBUG_TYPE_NULL)
5103             *ptype = debug_make_float_type (minfo->dhandle, 8);
5104         }
5105       ++*pp;
5106       break;
5107
5108     case 'f': /* float */
5109       if (ptype != NULL)
5110         {
5111           *ptype = debug_find_named_type (minfo->dhandle, "float");
5112           if (*ptype == DEBUG_TYPE_NULL)
5113             *ptype = debug_make_float_type (minfo->dhandle, 4);
5114         }
5115       ++*pp;
5116       break;
5117
5118     case 'G':
5119       ++*pp;
5120       if (! ISDIGIT (**pp))
5121         {
5122           stab_bad_demangle (orig);
5123           return false;
5124         }
5125       /* Fall through.  */
5126     case '0': case '1': case '2': case '3': case '4':
5127     case '5': case '6': case '7': case '8': case '9':
5128       {
5129         const char *hold;
5130
5131         if (! stab_demangle_class (minfo, pp, &hold))
5132           return false;
5133         if (ptype != NULL)
5134           {
5135             char *name;
5136
5137             name = savestring (hold, *pp - hold);
5138             *ptype = debug_find_named_type (minfo->dhandle, name);
5139             free (name);
5140             if (*ptype == DEBUG_TYPE_NULL)
5141               {
5142                 /* FIXME: It is probably incorrect to assume that
5143                    undefined types are tagged types.  */
5144                 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5145                                                 hold, *pp - hold,
5146                                                 DEBUG_KIND_ILLEGAL);
5147                 if (*ptype == DEBUG_TYPE_NULL)
5148                   return false;
5149               }
5150           }
5151       }
5152       break;
5153
5154     case 't':
5155       {
5156         char *name;
5157
5158         if (! stab_demangle_template (minfo, pp,
5159                                       ptype != NULL ? &name : NULL))
5160           return false;
5161         if (ptype != NULL)
5162           {
5163             *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
5164                                             name, strlen (name),
5165                                             DEBUG_KIND_CLASS);
5166             free (name);
5167             if (*ptype == DEBUG_TYPE_NULL)
5168               return false;
5169           }
5170       }
5171       break;
5172
5173     default:
5174       stab_bad_demangle (orig);
5175       return false;
5176     }
5177
5178   if (ptype != NULL)
5179     {
5180       if (constp)
5181         *ptype = debug_make_const_type (minfo->dhandle, *ptype);
5182       if (volatilep)
5183         *ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
5184     }
5185
5186   return true;
5187 }
5188
5189 /* Remember a type string in a demangled string.  */
5190
5191 static bool
5192 stab_demangle_remember_type (struct stab_demangle_info *minfo,
5193                              const char *p, int len)
5194 {
5195   if (minfo->typestring_count >= minfo->typestring_alloc)
5196     {
5197       minfo->typestring_alloc += 10;
5198       minfo->typestrings = ((struct stab_demangle_typestring *)
5199                             xrealloc (minfo->typestrings,
5200                                       (minfo->typestring_alloc
5201                                        * sizeof *minfo->typestrings)));
5202     }
5203
5204   minfo->typestrings[minfo->typestring_count].typestring = p;
5205   minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
5206   ++minfo->typestring_count;
5207
5208   return true;
5209 }
5210 \f
5211 /* Demangle names encoded using the g++ V3 ABI.  The newer versions of
5212    g++ which use this ABI do not encode ordinary method argument types
5213    in a mangled name; they simply output the argument types.  However,
5214    for a static method, g++ simply outputs the return type and the
5215    physical name.  So in that case we need to demangle the name here.
5216    Here PHYSNAME is the physical name of the function, and we set the
5217    variable pointed at by PVARARGS to indicate whether this function
5218    is varargs.  This returns NULL, or a NULL terminated array of
5219    argument types.  */
5220
5221 static debug_type *
5222 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
5223                            const char *physname, bool *pvarargs)
5224 {
5225   struct demangle_component *dc;
5226   void *mem;
5227   debug_type *pargs;
5228
5229   dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | demangle_flags, &mem);
5230   if (dc == NULL)
5231     {
5232       stab_bad_demangle (physname);
5233       return NULL;
5234     }
5235
5236   /* We expect to see TYPED_NAME, and the right subtree describes the
5237      function type.  */
5238   if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME
5239       || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5240     {
5241       fprintf (stderr, _("Demangled name is not a function\n"));
5242       free (mem);
5243       return NULL;
5244     }
5245
5246   pargs = stab_demangle_v3_arglist (dhandle, info,
5247                                     dc->u.s_binary.right->u.s_binary.right,
5248                                     pvarargs);
5249
5250   free (mem);
5251
5252   return pargs;
5253 }
5254
5255 /* Demangle an argument list in a struct demangle_component tree.
5256    Returns a DEBUG_TYPE_NULL terminated array of argument types, and
5257    sets *PVARARGS to indicate whether this is a varargs function.  */
5258
5259 static debug_type *
5260 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
5261                           struct demangle_component *arglist,
5262                           bool *pvarargs)
5263 {
5264   struct demangle_component *dc;
5265   unsigned int alloc, count;
5266   debug_type *pargs;
5267
5268   alloc = 10;
5269   pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
5270   *pvarargs = false;
5271
5272   count = 0;
5273
5274   for (dc = arglist;
5275        dc != NULL;
5276        dc = dc->u.s_binary.right)
5277     {
5278       debug_type arg;
5279       bool varargs;
5280
5281       if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
5282         {
5283           fprintf (stderr, _("Unexpected type in v3 arglist demangling\n"));
5284           free (pargs);
5285           return NULL;
5286         }
5287
5288       /* PR 13925: Cope if the demangler returns an empty
5289          context for a function with no arguments.  */
5290       if (dc->u.s_binary.left == NULL)
5291         break;
5292
5293       arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5294                                   NULL, &varargs);
5295       if (arg == NULL)
5296         {
5297           if (varargs)
5298             {
5299               *pvarargs = true;
5300               continue;
5301             }
5302           free (pargs);
5303           return NULL;
5304         }
5305
5306       if (count + 1 >= alloc)
5307         {
5308           alloc += 10;
5309           pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs);
5310         }
5311
5312       pargs[count] = arg;
5313       ++count;
5314     }
5315
5316   pargs[count] = DEBUG_TYPE_NULL;
5317
5318   return pargs;
5319 }
5320
5321 /* Convert a struct demangle_component tree describing an argument
5322    type into a debug_type.  */
5323
5324 static debug_type
5325 stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
5326                       struct demangle_component *dc, debug_type context,
5327                       bool *pvarargs)
5328 {
5329   debug_type dt;
5330
5331   if (pvarargs != NULL)
5332     *pvarargs = false;
5333
5334   switch (dc->type)
5335     {
5336       /* FIXME: These are demangle component types which we probably
5337          need to handle one way or another.  */
5338     case DEMANGLE_COMPONENT_LOCAL_NAME:
5339     case DEMANGLE_COMPONENT_TYPED_NAME:
5340     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
5341     case DEMANGLE_COMPONENT_CTOR:
5342     case DEMANGLE_COMPONENT_DTOR:
5343     case DEMANGLE_COMPONENT_JAVA_CLASS:
5344     case DEMANGLE_COMPONENT_RESTRICT_THIS:
5345     case DEMANGLE_COMPONENT_VOLATILE_THIS:
5346     case DEMANGLE_COMPONENT_CONST_THIS:
5347     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5348     case DEMANGLE_COMPONENT_COMPLEX:
5349     case DEMANGLE_COMPONENT_IMAGINARY:
5350     case DEMANGLE_COMPONENT_VENDOR_TYPE:
5351     case DEMANGLE_COMPONENT_ARRAY_TYPE:
5352     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5353     case DEMANGLE_COMPONENT_ARGLIST:
5354     default:
5355       fprintf (stderr, _("Unrecognized demangle component %d\n"),
5356                (int) dc->type);
5357       return NULL;
5358
5359     case DEMANGLE_COMPONENT_NAME:
5360       if (context != NULL)
5361         {
5362           const debug_field *fields;
5363
5364           fields = debug_get_fields (dhandle, context);
5365           if (fields != NULL)
5366             {
5367               /* Try to find this type by looking through the context
5368                  class.  */
5369               for (; *fields != DEBUG_FIELD_NULL; fields++)
5370                 {
5371                   debug_type ft;
5372                   const char *dn;
5373
5374                   ft = debug_get_field_type (dhandle, *fields);
5375                   if (ft == NULL)
5376                     return NULL;
5377                   dn = debug_get_type_name (dhandle, ft);
5378                   if (dn != NULL
5379                       && (int) strlen (dn) == dc->u.s_name.len
5380                       && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0)
5381                     return ft;
5382                 }
5383             }
5384         }
5385       return stab_find_tagged_type (dhandle, info, dc->u.s_name.s,
5386                                     dc->u.s_name.len, DEBUG_KIND_ILLEGAL);
5387
5388     case DEMANGLE_COMPONENT_QUAL_NAME:
5389       context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left,
5390                                       context, NULL);
5391       if (context == NULL)
5392         return NULL;
5393       return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right,
5394                                    context, NULL);
5395
5396     case DEMANGLE_COMPONENT_TEMPLATE:
5397       {
5398         char *p;
5399         size_t alc;
5400
5401         /* We print this component to get a class name which we can
5402            use.  FIXME: This probably won't work if the template uses
5403            template parameters which refer to an outer template.  */
5404         p = cplus_demangle_print (DMGL_PARAMS | demangle_flags, dc, 20, &alc);
5405         if (p == NULL)
5406           {
5407             fprintf (stderr, _("Failed to print demangled template\n"));
5408             return NULL;
5409           }
5410         dt = stab_find_tagged_type (dhandle, info, p, strlen (p),
5411                                     DEBUG_KIND_CLASS);
5412         free (p);
5413         return dt;
5414       }
5415
5416     case DEMANGLE_COMPONENT_SUB_STD:
5417       return stab_find_tagged_type (dhandle, info, dc->u.s_string.string,
5418                                     dc->u.s_string.len, DEBUG_KIND_ILLEGAL);
5419
5420     case DEMANGLE_COMPONENT_RESTRICT:
5421     case DEMANGLE_COMPONENT_VOLATILE:
5422     case DEMANGLE_COMPONENT_CONST:
5423     case DEMANGLE_COMPONENT_POINTER:
5424     case DEMANGLE_COMPONENT_REFERENCE:
5425       dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5426                                  NULL);
5427       if (dt == NULL)
5428         return NULL;
5429
5430       switch (dc->type)
5431         {
5432         default:
5433           abort ();
5434         case DEMANGLE_COMPONENT_RESTRICT:
5435           /* FIXME: We have no way to represent restrict.  */
5436           return dt;
5437         case DEMANGLE_COMPONENT_VOLATILE:
5438           return debug_make_volatile_type (dhandle, dt);
5439         case DEMANGLE_COMPONENT_CONST:
5440           return debug_make_const_type (dhandle, dt);
5441         case DEMANGLE_COMPONENT_POINTER:
5442           return debug_make_pointer_type (dhandle, dt);
5443         case DEMANGLE_COMPONENT_REFERENCE:
5444           return debug_make_reference_type (dhandle, dt);
5445         }
5446
5447     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5448       {
5449         debug_type *pargs;
5450         bool varargs;
5451
5452         if (dc->u.s_binary.left == NULL)
5453           {
5454             /* In this case the return type is actually unknown.
5455                However, I'm not sure this will ever arise in practice;
5456                normally an unknown return type would only appear at
5457                the top level, which is handled above.  */
5458             dt = debug_make_void_type (dhandle);
5459           }
5460         else
5461           dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL,
5462                                      NULL);
5463         if (dt == NULL)
5464           return NULL;
5465
5466         pargs = stab_demangle_v3_arglist (dhandle, info,
5467                                           dc->u.s_binary.right,
5468                                           &varargs);
5469         if (pargs == NULL)
5470           return NULL;
5471
5472         return debug_make_function_type (dhandle, dt, pargs, varargs);
5473       }
5474
5475     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5476       {
5477         char *p;
5478         size_t alc;
5479         debug_type ret;
5480
5481         /* We print this component in order to find out the type name.
5482            FIXME: Should we instead expose the
5483            demangle_builtin_type_info structure?  */
5484         p = cplus_demangle_print (DMGL_PARAMS | demangle_flags, dc, 20, &alc);
5485         if (p == NULL)
5486           {
5487             fprintf (stderr, _("Couldn't get demangled builtin type\n"));
5488             return NULL;
5489           }
5490
5491         /* The mangling is based on the type, but does not itself
5492            indicate what the sizes are.  So we have to guess.  */
5493         if (strcmp (p, "signed char") == 0)
5494           ret = debug_make_int_type (dhandle, 1, false);
5495         else if (strcmp (p, "bool") == 0)
5496           ret = debug_make_bool_type (dhandle, 1);
5497         else if (strcmp (p, "char") == 0)
5498           ret = debug_make_int_type (dhandle, 1, false);
5499         else if (strcmp (p, "double") == 0)
5500           ret = debug_make_float_type (dhandle, 8);
5501         else if (strcmp (p, "long double") == 0)
5502           ret = debug_make_float_type (dhandle, 8);
5503         else if (strcmp (p, "float") == 0)
5504           ret = debug_make_float_type (dhandle, 4);
5505         else if (strcmp (p, "__float128") == 0)
5506           ret = debug_make_float_type (dhandle, 16);
5507         else if (strcmp (p, "unsigned char") == 0)
5508           ret = debug_make_int_type (dhandle, 1, true);
5509         else if (strcmp (p, "int") == 0)
5510           ret = debug_make_int_type (dhandle, 4, false);
5511         else if (strcmp (p, "unsigned int") == 0)
5512           ret = debug_make_int_type (dhandle, 4, true);
5513         else if (strcmp (p, "long") == 0)
5514           ret = debug_make_int_type (dhandle, 4, false);
5515         else if (strcmp (p, "unsigned long") == 0)
5516           ret = debug_make_int_type (dhandle, 4, true);
5517         else if (strcmp (p, "__int128") == 0)
5518           ret = debug_make_int_type (dhandle, 16, false);
5519         else if (strcmp (p, "unsigned __int128") == 0)
5520           ret = debug_make_int_type (dhandle, 16, true);
5521         else if (strcmp (p, "short") == 0)
5522           ret = debug_make_int_type (dhandle, 2, false);
5523         else if (strcmp (p, "unsigned short") == 0)
5524           ret = debug_make_int_type (dhandle, 2, true);
5525         else if (strcmp (p, "void") == 0)
5526           ret = debug_make_void_type (dhandle);
5527         else if (strcmp (p, "wchar_t") == 0)
5528           ret = debug_make_int_type (dhandle, 4, true);
5529         else if (strcmp (p, "long long") == 0)
5530           ret = debug_make_int_type (dhandle, 8, false);
5531         else if (strcmp (p, "unsigned long long") == 0)
5532           ret = debug_make_int_type (dhandle, 8, true);
5533         else if (strcmp (p, "...") == 0)
5534           {
5535             if (pvarargs == NULL)
5536               fprintf (stderr, _("Unexpected demangled varargs\n"));
5537             else
5538               *pvarargs = true;
5539             ret = NULL;
5540           }
5541         else
5542           {
5543             fprintf (stderr, _("Unrecognized demangled builtin type\n"));
5544             ret = NULL;
5545           }
5546
5547         free (p);
5548
5549         return ret;
5550       }
5551     }
5552 }