binutils/stabs.c

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