binutils/stabs.c

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