binutils/stabs.c

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