gdb/cp-support.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2002-2017 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "cp-support.h"
  23 #include "demangle.h"
  24 #include "gdbcmd.h"
  25 #include "dictionary.h"
  26 #include "objfiles.h"
  27 #include "frame.h"
  28 #include "symtab.h"
  29 #include "block.h"
  30 #include "complaints.h"
  31 #include "gdbtypes.h"
  32 #include "expression.h"
  33 #include "value.h"
  34 #include "cp-abi.h"
  35 #include "namespace.h"
  36 #include <signal.h>
  37 #include "gdb_setjmp.h"
  38 #include "safe-ctype.h"
  39
  40 #define d_left(dc) (dc)->u.s_binary.left
  41 #define d_right(dc) (dc)->u.s_binary.right
  42
  43 /* Functions related to demangled name parsing.  */
  44
  45 static unsigned int cp_find_first_component_aux (const char *name,
  46                                                  int permissive);
  47
  48 static void demangled_name_complaint (const char *name);
  49
  50 /* Functions/variables related to overload resolution.  */
  51
  52 static int sym_return_val_size = -1;
  53 static int sym_return_val_index;
  54 static struct symbol **sym_return_val;
  55
  56 static void overload_list_add_symbol (struct symbol *sym,
  57                                       const char *oload_name);
  58
  59 static void make_symbol_overload_list_using (const char *func_name,
  60                                              const char *the_namespace);
  61
  62 static void make_symbol_overload_list_qualified (const char *func_name);
  63
  64 /* The list of "maint cplus" commands.  */
  65
  66 struct cmd_list_element *maint_cplus_cmd_list = NULL;
  67
  68 /* The actual commands.  */
  69
  70 static void maint_cplus_command (char *arg, int from_tty);
  71 static void first_component_command (char *arg, int from_tty);
  72
  73 /* A list of typedefs which should not be substituted by replace_typedefs.  */
  74 static const char * const ignore_typedefs[] =
  75   {
  76     "std::istream", "std::iostream", "std::ostream", "std::string"
  77   };
  78
  79 static void
  80   replace_typedefs (struct demangle_parse_info *info,
  81                     struct demangle_component *ret_comp,
  82                     canonicalization_ftype *finder,
  83                     void *data);
  84
  85 /* A convenience function to copy STRING into OBSTACK, returning a pointer
  86    to the newly allocated string and saving the number of bytes saved in LEN.
  87
  88    It does not copy the terminating '\0' byte!  */
  89
  90 static char *
  91 copy_string_to_obstack (struct obstack *obstack, const char *string,
  92                         long *len)
  93 {
  94   *len = strlen (string);
  95   return (char *) obstack_copy (obstack, string, *len);
  96 }
  97
  98 /* Return 1 if STRING is clearly already in canonical form.  This
  99    function is conservative; things which it does not recognize are
 100    assumed to be non-canonical, and the parser will sort them out
 101    afterwards.  This speeds up the critical path for alphanumeric
 102    identifiers.  */
 103
 104 static int
 105 cp_already_canonical (const char *string)
 106 {
 107   /* Identifier start character [a-zA-Z_].  */
 108   if (!ISIDST (string[0]))
 109     return 0;
 110
 111   /* These are the only two identifiers which canonicalize to other
 112      than themselves or an error: unsigned -> unsigned int and
 113      signed -> int.  */
 114   if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
 115     return 0;
 116   else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
 117     return 0;
 118
 119   /* Identifier character [a-zA-Z0-9_].  */
 120   while (ISIDNUM (string[1]))
 121     string++;
 122
 123   if (string[1] == '\0')
 124     return 1;
 125   else
 126     return 0;
 127 }
 128
 129 /* Inspect the given RET_COMP for its type.  If it is a typedef,
 130    replace the node with the typedef's tree.
 131
 132    Returns 1 if any typedef substitutions were made, 0 otherwise.  */
 133
 134 static int
 135 inspect_type (struct demangle_parse_info *info,
 136               struct demangle_component *ret_comp,
 137               canonicalization_ftype *finder,
 138               void *data)
 139 {
 140   int i;
 141   char *name;
 142   struct symbol *sym;
 143
 144   /* Copy the symbol's name from RET_COMP and look it up
 145      in the symbol table.  */
 146   name = (char *) alloca (ret_comp->u.s_name.len + 1);
 147   memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
 148   name[ret_comp->u.s_name.len] = '\0';
 149
 150   /* Ignore any typedefs that should not be substituted.  */
 151   for (i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
 152     {
 153       if (strcmp (name, ignore_typedefs[i]) == 0)
 154         return 0;
 155     }
 156
 157   sym = NULL;
 158
 159   TRY
 160     {
 161       sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
 162     }
 163   CATCH (except, RETURN_MASK_ALL)
 164     {
 165       return 0;
 166     }
 167   END_CATCH
 168
 169   if (sym != NULL)
 170     {
 171       struct type *otype = SYMBOL_TYPE (sym);
 172
 173       if (finder != NULL)
 174         {
 175           const char *new_name = (*finder) (otype, data);
 176
 177           if (new_name != NULL)
 178             {
 179               ret_comp->u.s_name.s = new_name;
 180               ret_comp->u.s_name.len = strlen (new_name);
 181               return 1;
 182             }
 183
 184           return 0;
 185         }
 186
 187       /* If the type is a typedef or namespace alias, replace it.  */
 188       if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
 189           || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
 190         {
 191           long len;
 192           int is_anon;
 193           struct type *type;
 194           std::unique_ptr<demangle_parse_info> i;
 195
 196           /* Get the real type of the typedef.  */
 197           type = check_typedef (otype);
 198
 199           /* If the symbol is a namespace and its type name is no different
 200              than the name we looked up, this symbol is not a namespace
 201              alias and does not need to be substituted.  */
 202           if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
 203               && strcmp (TYPE_NAME (type), name) == 0)
 204             return 0;
 205
 206           is_anon = (TYPE_TAG_NAME (type) == NULL
 207                      && (TYPE_CODE (type) == TYPE_CODE_ENUM
 208                          || TYPE_CODE (type) == TYPE_CODE_STRUCT
 209                          || TYPE_CODE (type) == TYPE_CODE_UNION));
 210           if (is_anon)
 211             {
 212               struct type *last = otype;
 213
 214               /* Find the last typedef for the type.  */
 215               while (TYPE_TARGET_TYPE (last) != NULL
 216                      && (TYPE_CODE (TYPE_TARGET_TYPE (last))
 217                          == TYPE_CODE_TYPEDEF))
 218                 last = TYPE_TARGET_TYPE (last);
 219
 220               /* If there is only one typedef for this anonymous type,
 221                  do not substitute it.  */
 222               if (type == otype)
 223                 return 0;
 224               else
 225                 /* Use the last typedef seen as the type for this
 226                    anonymous type.  */
 227                 type = last;
 228             }
 229
 230           string_file buf;
 231           TRY
 232             {
 233               type_print (type, "", &buf, -1);
 234             }
 235           /* If type_print threw an exception, there is little point
 236              in continuing, so just bow out gracefully.  */
 237           CATCH (except, RETURN_MASK_ERROR)
 238             {
 239               return 0;
 240             }
 241           END_CATCH
 242
 243           len = buf.size ();
 244           name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
 245
 246           /* Turn the result into a new tree.  Note that this
 247              tree will contain pointers into NAME, so NAME cannot
 248              be free'd until all typedef conversion is done and
 249              the final result is converted into a string.  */
 250           i = cp_demangled_name_to_comp (name, NULL);
 251           if (i != NULL)
 252             {
 253               /* Merge the two trees.  */
 254               cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
 255
 256               /* Replace any newly introduced typedefs -- but not
 257                  if the type is anonymous (that would lead to infinite
 258                  looping).  */
 259               if (!is_anon)
 260                 replace_typedefs (info, ret_comp, finder, data);
 261             }
 262           else
 263             {
 264               /* This shouldn't happen unless the type printer has
 265                  output something that the name parser cannot grok.
 266                  Nonetheless, an ounce of prevention...
 267
 268                  Canonicalize the name again, and store it in the
 269                  current node (RET_COMP).  */
 270               std::string canon = cp_canonicalize_string_no_typedefs (name);
 271
 272               if (!canon.empty ())
 273                 {
 274                   /* Copy the canonicalization into the obstack.  */
 275                   name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
 276                 }
 277
 278               ret_comp->u.s_name.s = name;
 279               ret_comp->u.s_name.len = len;
 280             }
 281
 282           return 1;
 283         }
 284     }
 285
 286   return 0;
 287 }
 288
 289 /* Replace any typedefs appearing in the qualified name
 290    (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
 291    given in INFO.  */
 292
 293 static void
 294 replace_typedefs_qualified_name (struct demangle_parse_info *info,
 295                                  struct demangle_component *ret_comp,
 296                                  canonicalization_ftype *finder,
 297                                  void *data)
 298 {
 299   long len;
 300   char *name;
 301   string_file buf;
 302   struct demangle_component *comp = ret_comp;
 303
 304   /* Walk each node of the qualified name, reconstructing the name of
 305      this element.  With every node, check for any typedef substitutions.
 306      If a substitution has occurred, replace the qualified name node
 307      with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
 308      substituted name.  */
 309   while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
 310     {
 311       if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
 312         {
 313           struct demangle_component newobj;
 314
 315           buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len);
 316           len = buf.size ();
 317           name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
 318           newobj.type = DEMANGLE_COMPONENT_NAME;
 319           newobj.u.s_name.s = name;
 320           newobj.u.s_name.len = len;
 321           if (inspect_type (info, &newobj, finder, data))
 322             {
 323               char *n, *s;
 324               long slen;
 325
 326               /* A typedef was substituted in NEW.  Convert it to a
 327                  string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
 328                  node.  */
 329
 330               buf.clear ();
 331               n = cp_comp_to_string (&newobj, 100);
 332               if (n == NULL)
 333                 {
 334                   /* If something went astray, abort typedef substitutions.  */
 335                   return;
 336                 }
 337
 338               s = copy_string_to_obstack (&info->obstack, n, &slen);
 339               xfree (n);
 340
 341               d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
 342               d_left (ret_comp)->u.s_name.s = s;
 343               d_left (ret_comp)->u.s_name.len = slen;
 344               d_right (ret_comp) = d_right (comp);
 345               comp = ret_comp;
 346               continue;
 347             }
 348         }
 349       else
 350         {
 351           /* The current node is not a name, so simply replace any
 352              typedefs in it.  Then print it to the stream to continue
 353              checking for more typedefs in the tree.  */
 354           replace_typedefs (info, d_left (comp), finder, data);
 355           name = cp_comp_to_string (d_left (comp), 100);
 356           if (name == NULL)
 357             {
 358               /* If something went astray, abort typedef substitutions.  */
 359               return;
 360             }
 361           buf.puts (name);
 362           xfree (name);
 363         }
 364
 365       buf.write ("::", 2);
 366       comp = d_right (comp);
 367     }
 368
 369   /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
 370      name assembled above and append the name given by COMP.  Then use this
 371      reassembled name to check for a typedef.  */
 372
 373   if (comp->type == DEMANGLE_COMPONENT_NAME)
 374     {
 375       buf.write (comp->u.s_name.s, comp->u.s_name.len);
 376       len = buf.size ();
 377       name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
 378
 379       /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
 380          with a DEMANGLE_COMPONENT_NAME node containing the whole
 381          name.  */
 382       ret_comp->type = DEMANGLE_COMPONENT_NAME;
 383       ret_comp->u.s_name.s = name;
 384       ret_comp->u.s_name.len = len;
 385       inspect_type (info, ret_comp, finder, data);
 386     }
 387   else
 388     replace_typedefs (info, comp, finder, data);
 389 }
 390
 391
 392 /* A function to check const and volatile qualifiers for argument types.
 393
 394    "Parameter declarations that differ only in the presence
 395    or absence of `const' and/or `volatile' are equivalent."
 396    C++ Standard N3290, clause 13.1.3 #4.  */
 397
 398 static void
 399 check_cv_qualifiers (struct demangle_component *ret_comp)
 400 {
 401   while (d_left (ret_comp) != NULL
 402          && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
 403              || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
 404     {
 405       d_left (ret_comp) = d_left (d_left (ret_comp));
 406     }
 407 }
 408
 409 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
 410    their basic types.  */
 411
 412 static void
 413 replace_typedefs (struct demangle_parse_info *info,
 414                   struct demangle_component *ret_comp,
 415                   canonicalization_ftype *finder,
 416                   void *data)
 417 {
 418   if (ret_comp)
 419     {
 420       if (finder != NULL
 421           && (ret_comp->type == DEMANGLE_COMPONENT_NAME
 422               || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
 423               || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
 424               || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
 425         {
 426           char *local_name = cp_comp_to_string (ret_comp, 10);
 427
 428           if (local_name != NULL)
 429             {
 430               struct symbol *sym = NULL;
 431
 432               sym = NULL;
 433               TRY
 434                 {
 435                   sym = lookup_symbol (local_name, 0, VAR_DOMAIN, 0).symbol;
 436                 }
 437               CATCH (except, RETURN_MASK_ALL)
 438                 {
 439                 }
 440               END_CATCH
 441
 442               xfree (local_name);
 443
 444               if (sym != NULL)
 445                 {
 446                   struct type *otype = SYMBOL_TYPE (sym);
 447                   const char *new_name = (*finder) (otype, data);
 448
 449                   if (new_name != NULL)
 450                     {
 451                       ret_comp->type = DEMANGLE_COMPONENT_NAME;
 452                       ret_comp->u.s_name.s = new_name;
 453                       ret_comp->u.s_name.len = strlen (new_name);
 454                       return;
 455                     }
 456                 }
 457             }
 458         }
 459
 460       switch (ret_comp->type)
 461         {
 462         case DEMANGLE_COMPONENT_ARGLIST:
 463           check_cv_qualifiers (ret_comp);
 464           /* Fall through */
 465
 466         case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 467         case DEMANGLE_COMPONENT_TEMPLATE:
 468         case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 469         case DEMANGLE_COMPONENT_TYPED_NAME:
 470           replace_typedefs (info, d_left (ret_comp), finder, data);
 471           replace_typedefs (info, d_right (ret_comp), finder, data);
 472           break;
 473
 474         case DEMANGLE_COMPONENT_NAME:
 475           inspect_type (info, ret_comp, finder, data);
 476           break;
 477
 478         case DEMANGLE_COMPONENT_QUAL_NAME:
 479           replace_typedefs_qualified_name (info, ret_comp, finder, data);
 480           break;
 481
 482         case DEMANGLE_COMPONENT_LOCAL_NAME:
 483         case DEMANGLE_COMPONENT_CTOR:
 484         case DEMANGLE_COMPONENT_ARRAY_TYPE:
 485         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 486           replace_typedefs (info, d_right (ret_comp), finder, data);
 487           break;
 488
 489         case DEMANGLE_COMPONENT_CONST:
 490         case DEMANGLE_COMPONENT_RESTRICT:
 491         case DEMANGLE_COMPONENT_VOLATILE:
 492         case DEMANGLE_COMPONENT_VOLATILE_THIS:
 493         case DEMANGLE_COMPONENT_CONST_THIS:
 494         case DEMANGLE_COMPONENT_RESTRICT_THIS:
 495         case DEMANGLE_COMPONENT_POINTER:
 496         case DEMANGLE_COMPONENT_REFERENCE:
 497         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 498           replace_typedefs (info, d_left (ret_comp), finder, data);
 499           break;
 500
 501         default:
 502           break;
 503         }
 504     }
 505 }
 506
 507 /* Parse STRING and convert it to canonical form, resolving any
 508    typedefs.  If parsing fails, or if STRING is already canonical,
 509    return the empty string.  Otherwise return the canonical form.  If
 510    FINDER is not NULL, then type components are passed to FINDER to be
 511    looked up.  DATA is passed verbatim to FINDER.  */
 512
 513 std::string
 514 cp_canonicalize_string_full (const char *string,
 515                              canonicalization_ftype *finder,
 516                              void *data)
 517 {
 518   std::string ret;
 519   unsigned int estimated_len;
 520   std::unique_ptr<demangle_parse_info> info;
 521
 522   estimated_len = strlen (string) * 2;
 523   info = cp_demangled_name_to_comp (string, NULL);
 524   if (info != NULL)
 525     {
 526       /* Replace all the typedefs in the tree.  */
 527       replace_typedefs (info.get (), info->tree, finder, data);
 528
 529       /* Convert the tree back into a string.  */
 530       ret = cp_comp_to_string (info->tree, estimated_len);
 531       gdb_assert (!ret.empty ());
 532
 533       /* Finally, compare the original string with the computed
 534          name, returning NULL if they are the same.  */
 535       if (ret == string)
 536         return std::string ();
 537     }
 538
 539   return ret;
 540 }
 541
 542 /* Like cp_canonicalize_string_full, but always passes NULL for
 543    FINDER.  */
 544
 545 std::string
 546 cp_canonicalize_string_no_typedefs (const char *string)
 547 {
 548   return cp_canonicalize_string_full (string, NULL, NULL);
 549 }
 550
 551 /* Parse STRING and convert it to canonical form.  If parsing fails,
 552    or if STRING is already canonical, return the empty string.
 553    Otherwise return the canonical form.  */
 554
 555 std::string
 556 cp_canonicalize_string (const char *string)
 557 {
 558   std::unique_ptr<demangle_parse_info> info;
 559   unsigned int estimated_len;
 560
 561   if (cp_already_canonical (string))
 562     return std::string ();
 563
 564   info = cp_demangled_name_to_comp (string, NULL);
 565   if (info == NULL)
 566     return std::string ();
 567
 568   estimated_len = strlen (string) * 2;
 569   std::string ret = cp_comp_to_string (info->tree, estimated_len);
 570
 571   if (ret.empty ())
 572     {
 573       warning (_("internal error: string \"%s\" failed to be canonicalized"),
 574                string);
 575       return std::string ();
 576     }
 577
 578   if (ret == string)
 579     return std::string ();
 580
 581   return ret;
 582 }
 583
 584 /* Convert a mangled name to a demangle_component tree.  *MEMORY is
 585    set to the block of used memory that should be freed when finished
 586    with the tree.  DEMANGLED_P is set to the char * that should be
 587    freed when finished with the tree, or NULL if none was needed.
 588    OPTIONS will be passed to the demangler.  */
 589
 590 static std::unique_ptr<demangle_parse_info>
 591 mangled_name_to_comp (const char *mangled_name, int options,
 592                       void **memory, char **demangled_p)
 593 {
 594   char *demangled_name;
 595
 596   /* If it looks like a v3 mangled name, then try to go directly
 597      to trees.  */
 598   if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
 599     {
 600       struct demangle_component *ret;
 601
 602       ret = cplus_demangle_v3_components (mangled_name,
 603                                           options, memory);
 604       if (ret)
 605         {
 606           std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
 607           info->tree = ret;
 608           *demangled_p = NULL;
 609           return info;
 610         }
 611     }
 612
 613   /* If it doesn't, or if that failed, then try to demangle the
 614      name.  */
 615   demangled_name = gdb_demangle (mangled_name, options);
 616   if (demangled_name == NULL)
 617    return NULL;
 618
 619   /* If we could demangle the name, parse it to build the component
 620      tree.  */
 621   std::unique_ptr<demangle_parse_info> info
 622     = cp_demangled_name_to_comp (demangled_name, NULL);
 623
 624   if (info == NULL)
 625     {
 626       xfree (demangled_name);
 627       return NULL;
 628     }
 629
 630   *demangled_p = demangled_name;
 631   return info;
 632 }
 633
 634 /* Return the name of the class containing method PHYSNAME.  */
 635
 636 char *
 637 cp_class_name_from_physname (const char *physname)
 638 {
 639   void *storage = NULL;
 640   char *demangled_name = NULL, *ret;
 641   struct demangle_component *ret_comp, *prev_comp, *cur_comp;
 642   std::unique_ptr<demangle_parse_info> info;
 643   int done;
 644
 645   info = mangled_name_to_comp (physname, DMGL_ANSI,
 646                                &storage, &demangled_name);
 647   if (info == NULL)
 648     return NULL;
 649
 650   done = 0;
 651   ret_comp = info->tree;
 652
 653   /* First strip off any qualifiers, if we have a function or
 654      method.  */
 655   while (!done)
 656     switch (ret_comp->type)
 657       {
 658       case DEMANGLE_COMPONENT_CONST:
 659       case DEMANGLE_COMPONENT_RESTRICT:
 660       case DEMANGLE_COMPONENT_VOLATILE:
 661       case DEMANGLE_COMPONENT_CONST_THIS:
 662       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 663       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 664       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 665         ret_comp = d_left (ret_comp);
 666         break;
 667       default:
 668         done = 1;
 669         break;
 670       }
 671
 672   /* If what we have now is a function, discard the argument list.  */
 673   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 674     ret_comp = d_left (ret_comp);
 675
 676   /* If what we have now is a template, strip off the template
 677      arguments.  The left subtree may be a qualified name.  */
 678   if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
 679     ret_comp = d_left (ret_comp);
 680
 681   /* What we have now should be a name, possibly qualified.
 682      Additional qualifiers could live in the left subtree or the right
 683      subtree.  Find the last piece.  */
 684   done = 0;
 685   prev_comp = NULL;
 686   cur_comp = ret_comp;
 687   while (!done)
 688     switch (cur_comp->type)
 689       {
 690       case DEMANGLE_COMPONENT_QUAL_NAME:
 691       case DEMANGLE_COMPONENT_LOCAL_NAME:
 692         prev_comp = cur_comp;
 693         cur_comp = d_right (cur_comp);
 694         break;
 695       case DEMANGLE_COMPONENT_TEMPLATE:
 696       case DEMANGLE_COMPONENT_NAME:
 697       case DEMANGLE_COMPONENT_CTOR:
 698       case DEMANGLE_COMPONENT_DTOR:
 699       case DEMANGLE_COMPONENT_OPERATOR:
 700       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 701         done = 1;
 702         break;
 703       default:
 704         done = 1;
 705         cur_comp = NULL;
 706         break;
 707       }
 708
 709   ret = NULL;
 710   if (cur_comp != NULL && prev_comp != NULL)
 711     {
 712       /* We want to discard the rightmost child of PREV_COMP.  */
 713       *prev_comp = *d_left (prev_comp);
 714       /* The ten is completely arbitrary; we don't have a good
 715          estimate.  */
 716       ret = cp_comp_to_string (ret_comp, 10);
 717     }
 718
 719   xfree (storage);
 720   xfree (demangled_name);
 721   return ret;
 722 }
 723
 724 /* Return the child of COMP which is the basename of a method,
 725    variable, et cetera.  All scope qualifiers are discarded, but
 726    template arguments will be included.  The component tree may be
 727    modified.  */
 728
 729 static struct demangle_component *
 730 unqualified_name_from_comp (struct demangle_component *comp)
 731 {
 732   struct demangle_component *ret_comp = comp, *last_template;
 733   int done;
 734
 735   done = 0;
 736   last_template = NULL;
 737   while (!done)
 738     switch (ret_comp->type)
 739       {
 740       case DEMANGLE_COMPONENT_QUAL_NAME:
 741       case DEMANGLE_COMPONENT_LOCAL_NAME:
 742         ret_comp = d_right (ret_comp);
 743         break;
 744       case DEMANGLE_COMPONENT_TYPED_NAME:
 745         ret_comp = d_left (ret_comp);
 746         break;
 747       case DEMANGLE_COMPONENT_TEMPLATE:
 748         gdb_assert (last_template == NULL);
 749         last_template = ret_comp;
 750         ret_comp = d_left (ret_comp);
 751         break;
 752       case DEMANGLE_COMPONENT_CONST:
 753       case DEMANGLE_COMPONENT_RESTRICT:
 754       case DEMANGLE_COMPONENT_VOLATILE:
 755       case DEMANGLE_COMPONENT_CONST_THIS:
 756       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 757       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 758       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 759         ret_comp = d_left (ret_comp);
 760         break;
 761       case DEMANGLE_COMPONENT_NAME:
 762       case DEMANGLE_COMPONENT_CTOR:
 763       case DEMANGLE_COMPONENT_DTOR:
 764       case DEMANGLE_COMPONENT_OPERATOR:
 765       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 766         done = 1;
 767         break;
 768       default:
 769         return NULL;
 770         break;
 771       }
 772
 773   if (last_template)
 774     {
 775       d_left (last_template) = ret_comp;
 776       return last_template;
 777     }
 778
 779   return ret_comp;
 780 }
 781
 782 /* Return the name of the method whose linkage name is PHYSNAME.  */
 783
 784 char *
 785 method_name_from_physname (const char *physname)
 786 {
 787   void *storage = NULL;
 788   char *demangled_name = NULL, *ret;
 789   struct demangle_component *ret_comp;
 790   std::unique_ptr<demangle_parse_info> info;
 791
 792   info = mangled_name_to_comp (physname, DMGL_ANSI,
 793                                &storage, &demangled_name);
 794   if (info == NULL)
 795     return NULL;
 796
 797   ret_comp = unqualified_name_from_comp (info->tree);
 798
 799   ret = NULL;
 800   if (ret_comp != NULL)
 801     /* The ten is completely arbitrary; we don't have a good
 802        estimate.  */
 803     ret = cp_comp_to_string (ret_comp, 10);
 804
 805   xfree (storage);
 806   xfree (demangled_name);
 807   return ret;
 808 }
 809
 810 /* If FULL_NAME is the demangled name of a C++ function (including an
 811    arg list, possibly including namespace/class qualifications),
 812    return a new string containing only the function name (without the
 813    arg list/class qualifications).  Otherwise, return NULL.  The
 814    caller is responsible for freeing the memory in question.  */
 815
 816 char *
 817 cp_func_name (const char *full_name)
 818 {
 819   char *ret;
 820   struct demangle_component *ret_comp;
 821   std::unique_ptr<demangle_parse_info> info;
 822
 823   info = cp_demangled_name_to_comp (full_name, NULL);
 824   if (!info)
 825     return NULL;
 826
 827   ret_comp = unqualified_name_from_comp (info->tree);
 828
 829   ret = NULL;
 830   if (ret_comp != NULL)
 831     ret = cp_comp_to_string (ret_comp, 10);
 832
 833   return ret;
 834 }
 835
 836 /* DEMANGLED_NAME is the name of a function, including parameters and
 837    (optionally) a return type.  Return the name of the function without
 838    parameters or return type, or NULL if we can not parse the name.  */
 839
 840 char *
 841 cp_remove_params (const char *demangled_name)
 842 {
 843   int done = 0;
 844   struct demangle_component *ret_comp;
 845   std::unique_ptr<demangle_parse_info> info;
 846   char *ret = NULL;
 847
 848   if (demangled_name == NULL)
 849     return NULL;
 850
 851   info = cp_demangled_name_to_comp (demangled_name, NULL);
 852   if (info == NULL)
 853     return NULL;
 854
 855   /* First strip off any qualifiers, if we have a function or method.  */
 856   ret_comp = info->tree;
 857   while (!done)
 858     switch (ret_comp->type)
 859       {
 860       case DEMANGLE_COMPONENT_CONST:
 861       case DEMANGLE_COMPONENT_RESTRICT:
 862       case DEMANGLE_COMPONENT_VOLATILE:
 863       case DEMANGLE_COMPONENT_CONST_THIS:
 864       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 865       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 866       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 867         ret_comp = d_left (ret_comp);
 868         break;
 869       default:
 870         done = 1;
 871         break;
 872       }
 873
 874   /* What we have now should be a function.  Return its name.  */
 875   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 876     ret = cp_comp_to_string (d_left (ret_comp), 10);
 877
 878   return ret;
 879 }
 880
 881 /* Here are some random pieces of trivia to keep in mind while trying
 882    to take apart demangled names:
 883
 884    - Names can contain function arguments or templates, so the process
 885      has to be, to some extent recursive: maybe keep track of your
 886      depth based on encountering <> and ().
 887
 888    - Parentheses don't just have to happen at the end of a name: they
 889      can occur even if the name in question isn't a function, because
 890      a template argument might be a type that's a function.
 891
 892    - Conversely, even if you're trying to deal with a function, its
 893      demangled name might not end with ')': it could be a const or
 894      volatile class method, in which case it ends with "const" or
 895      "volatile".
 896
 897    - Parentheses are also used in anonymous namespaces: a variable
 898      'foo' in an anonymous namespace gets demangled as "(anonymous
 899      namespace)::foo".
 900
 901    - And operator names can contain parentheses or angle brackets.  */
 902
 903 /* FIXME: carlton/2003-03-13: We have several functions here with
 904    overlapping functionality; can we combine them?  Also, do they
 905    handle all the above considerations correctly?  */
 906
 907
 908 /* This returns the length of first component of NAME, which should be
 909    the demangled name of a C++ variable/function/method/etc.
 910    Specifically, it returns the index of the first colon forming the
 911    boundary of the first component: so, given 'A::foo' or 'A::B::foo'
 912    it returns the 1, and given 'foo', it returns 0.  */
 913
 914 /* The character in NAME indexed by the return value is guaranteed to
 915    always be either ':' or '\0'.  */
 916
 917 /* NOTE: carlton/2003-03-13: This function is currently only intended
 918    for internal use: it's probably not entirely safe when called on
 919    user-generated input, because some of the 'index += 2' lines in
 920    cp_find_first_component_aux might go past the end of malformed
 921    input.  */
 922
 923 unsigned int
 924 cp_find_first_component (const char *name)
 925 {
 926   return cp_find_first_component_aux (name, 0);
 927 }
 928
 929 /* Helper function for cp_find_first_component.  Like that function,
 930    it returns the length of the first component of NAME, but to make
 931    the recursion easier, it also stops if it reaches an unexpected ')'
 932    or '>' if the value of PERMISSIVE is nonzero.  */
 933
 934 /* Let's optimize away calls to strlen("operator").  */
 935
 936 #define LENGTH_OF_OPERATOR 8
 937
 938 static unsigned int
 939 cp_find_first_component_aux (const char *name, int permissive)
 940 {
 941   unsigned int index = 0;
 942   /* Operator names can show up in unexpected places.  Since these can
 943      contain parentheses or angle brackets, they can screw up the
 944      recursion.  But not every string 'operator' is part of an
 945      operater name: e.g. you could have a variable 'cooperator'.  So
 946      this variable tells us whether or not we should treat the string
 947      'operator' as starting an operator.  */
 948   int operator_possible = 1;
 949
 950   for (;; ++index)
 951     {
 952       switch (name[index])
 953         {
 954         case '<':
 955           /* Template; eat it up.  The calls to cp_first_component
 956              should only return (I hope!) when they reach the '>'
 957              terminating the component or a '::' between two
 958              components.  (Hence the '+ 2'.)  */
 959           index += 1;
 960           for (index += cp_find_first_component_aux (name + index, 1);
 961                name[index] != '>';
 962                index += cp_find_first_component_aux (name + index, 1))
 963             {
 964               if (name[index] != ':')
 965                 {
 966                   demangled_name_complaint (name);
 967                   return strlen (name);
 968                 }
 969               index += 2;
 970             }
 971           operator_possible = 1;
 972           break;
 973         case '(':
 974           /* Similar comment as to '<'.  */
 975           index += 1;
 976           for (index += cp_find_first_component_aux (name + index, 1);
 977                name[index] != ')';
 978                index += cp_find_first_component_aux (name + index, 1))
 979             {
 980               if (name[index] != ':')
 981                 {
 982                   demangled_name_complaint (name);
 983                   return strlen (name);
 984                 }
 985               index += 2;
 986             }
 987           operator_possible = 1;
 988           break;
 989         case '>':
 990         case ')':
 991           if (permissive)
 992             return index;
 993           else
 994             {
 995               demangled_name_complaint (name);
 996               return strlen (name);
 997             }
 998         case '\0':
 999           return index;
1000         case ':':
1001           /* ':' marks a component iff the next character is also a ':'.
1002              Otherwise it is probably malformed input.  */
1003           if (name[index + 1] == ':')
1004             return index;
1005           break;
1006         case 'o':
1007           /* Operator names can screw up the recursion.  */
1008           if (operator_possible
1009               && strncmp (name + index, "operator",
1010                           LENGTH_OF_OPERATOR) == 0)
1011             {
1012               index += LENGTH_OF_OPERATOR;
1013               while (ISSPACE(name[index]))
1014                 ++index;
1015               switch (name[index])
1016                 {
1017                   /* Skip over one less than the appropriate number of
1018                      characters: the for loop will skip over the last
1019                      one.  */
1020                 case '<':
1021                   if (name[index + 1] == '<')
1022                     index += 1;
1023                   else
1024                     index += 0;
1025                   break;
1026                 case '>':
1027                 case '-':
1028                   if (name[index + 1] == '>')
1029                     index += 1;
1030                   else
1031                     index += 0;
1032                   break;
1033                 case '(':
1034                   index += 1;
1035                   break;
1036                 default:
1037                   index += 0;
1038                   break;
1039                 }
1040             }
1041           operator_possible = 0;
1042           break;
1043         case ' ':
1044         case ',':
1045         case '.':
1046         case '&':
1047         case '*':
1048           /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1049              set of relevant characters are here: it's necessary to
1050              include any character that can show up before 'operator'
1051              in a demangled name, and it's safe to include any
1052              character that can't be part of an identifier's name.  */
1053           operator_possible = 1;
1054           break;
1055         default:
1056           operator_possible = 0;
1057           break;
1058         }
1059     }
1060 }
1061
1062 /* Complain about a demangled name that we don't know how to parse.
1063    NAME is the demangled name in question.  */
1064
1065 static void
1066 demangled_name_complaint (const char *name)
1067 {
1068   complaint (&symfile_complaints,
1069              "unexpected demangled name '%s'", name);
1070 }
1071
1072 /* If NAME is the fully-qualified name of a C++
1073    function/variable/method/etc., this returns the length of its
1074    entire prefix: all of the namespaces and classes that make up its
1075    name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1076    4, given 'foo', it returns 0.  */
1077
1078 unsigned int
1079 cp_entire_prefix_len (const char *name)
1080 {
1081   unsigned int current_len = cp_find_first_component (name);
1082   unsigned int previous_len = 0;
1083
1084   while (name[current_len] != '\0')
1085     {
1086       gdb_assert (name[current_len] == ':');
1087       previous_len = current_len;
1088       /* Skip the '::'.  */
1089       current_len += 2;
1090       current_len += cp_find_first_component (name + current_len);
1091     }
1092
1093   return previous_len;
1094 }
1095
1096 /* Overload resolution functions.  */
1097
1098 /* Test to see if SYM is a symbol that we haven't seen corresponding
1099    to a function named OLOAD_NAME.  If so, add it to the current
1100    completion list.  */
1101
1102 static void
1103 overload_list_add_symbol (struct symbol *sym,
1104                           const char *oload_name)
1105 {
1106   int newsize;
1107   int i;
1108   char *sym_name;
1109
1110   /* If there is no type information, we can't do anything, so
1111      skip.  */
1112   if (SYMBOL_TYPE (sym) == NULL)
1113     return;
1114
1115   /* skip any symbols that we've already considered.  */
1116   for (i = 0; i < sym_return_val_index; ++i)
1117     if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1118                 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
1119       return;
1120
1121   /* Get the demangled name without parameters */
1122   sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1123   if (!sym_name)
1124     return;
1125
1126   /* skip symbols that cannot match */
1127   if (strcmp (sym_name, oload_name) != 0)
1128     {
1129       xfree (sym_name);
1130       return;
1131     }
1132
1133   xfree (sym_name);
1134
1135   /* We have a match for an overload instance, so add SYM to the
1136      current list of overload instances */
1137   if (sym_return_val_index + 3 > sym_return_val_size)
1138     {
1139       newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
1140       sym_return_val = (struct symbol **)
1141         xrealloc ((char *) sym_return_val, newsize);
1142     }
1143   sym_return_val[sym_return_val_index++] = sym;
1144   sym_return_val[sym_return_val_index] = NULL;
1145 }
1146
1147 /* Return a null-terminated list of pointers to function symbols that
1148    are named FUNC_NAME and are visible within NAMESPACE.  */
1149
1150 struct symbol **
1151 make_symbol_overload_list (const char *func_name,
1152                            const char *the_namespace)
1153 {
1154   struct cleanup *old_cleanups;
1155   const char *name;
1156
1157   sym_return_val_size = 100;
1158   sym_return_val_index = 0;
1159   sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
1160   sym_return_val[0] = NULL;
1161
1162   old_cleanups = make_cleanup (xfree, sym_return_val);
1163
1164   make_symbol_overload_list_using (func_name, the_namespace);
1165
1166   if (the_namespace[0] == '\0')
1167     name = func_name;
1168   else
1169     {
1170       char *concatenated_name
1171         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1172       strcpy (concatenated_name, the_namespace);
1173       strcat (concatenated_name, "::");
1174       strcat (concatenated_name, func_name);
1175       name = concatenated_name;
1176     }
1177
1178   make_symbol_overload_list_qualified (name);
1179
1180   discard_cleanups (old_cleanups);
1181
1182   return sym_return_val;
1183 }
1184
1185 /* Add all symbols with a name matching NAME in BLOCK to the overload
1186    list.  */
1187
1188 static void
1189 make_symbol_overload_list_block (const char *name,
1190                                  const struct block *block)
1191 {
1192   struct block_iterator iter;
1193   struct symbol *sym;
1194
1195   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
1196     overload_list_add_symbol (sym, name);
1197 }
1198
1199 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
1200
1201 static void
1202 make_symbol_overload_list_namespace (const char *func_name,
1203                                      const char *the_namespace)
1204 {
1205   const char *name;
1206   const struct block *block = NULL;
1207
1208   if (the_namespace[0] == '\0')
1209     name = func_name;
1210   else
1211     {
1212       char *concatenated_name
1213         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1214
1215       strcpy (concatenated_name, the_namespace);
1216       strcat (concatenated_name, "::");
1217       strcat (concatenated_name, func_name);
1218       name = concatenated_name;
1219     }
1220
1221   /* Look in the static block.  */
1222   block = block_static_block (get_selected_block (0));
1223   if (block)
1224     make_symbol_overload_list_block (name, block);
1225
1226   /* Look in the global block.  */
1227   block = block_global_block (block);
1228   if (block)
1229     make_symbol_overload_list_block (name, block);
1230
1231 }
1232
1233 /* Search the namespace of the given type and namespace of and public
1234    base types.  */
1235
1236 static void
1237 make_symbol_overload_list_adl_namespace (struct type *type,
1238                                          const char *func_name)
1239 {
1240   char *the_namespace;
1241   const char *type_name;
1242   int i, prefix_len;
1243
1244   while (TYPE_CODE (type) == TYPE_CODE_PTR
1245          || TYPE_IS_REFERENCE (type)
1246          || TYPE_CODE (type) == TYPE_CODE_ARRAY
1247          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1248     {
1249       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1250         type = check_typedef(type);
1251       else
1252         type = TYPE_TARGET_TYPE (type);
1253     }
1254
1255   type_name = TYPE_NAME (type);
1256
1257   if (type_name == NULL)
1258     return;
1259
1260   prefix_len = cp_entire_prefix_len (type_name);
1261
1262   if (prefix_len != 0)
1263     {
1264       the_namespace = (char *) alloca (prefix_len + 1);
1265       strncpy (the_namespace, type_name, prefix_len);
1266       the_namespace[prefix_len] = '\0';
1267
1268       make_symbol_overload_list_namespace (func_name, the_namespace);
1269     }
1270
1271   /* Check public base type */
1272   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1273     for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1274       {
1275         if (BASETYPE_VIA_PUBLIC (type, i))
1276           make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1277                                                                    i),
1278                                                    func_name);
1279       }
1280 }
1281
1282 /* Adds the overload list overload candidates for FUNC_NAME found
1283    through argument dependent lookup.  */
1284
1285 struct symbol **
1286 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1287                                const char *func_name)
1288 {
1289   int i;
1290
1291   gdb_assert (sym_return_val_size != -1);
1292
1293   for (i = 1; i <= nargs; i++)
1294     make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1295                                              func_name);
1296
1297   return sym_return_val;
1298 }
1299
1300 /* Used for cleanups to reset the "searched" flag in case of an
1301    error.  */
1302
1303 static void
1304 reset_directive_searched (void *data)
1305 {
1306   struct using_direct *direct = (struct using_direct *) data;
1307   direct->searched = 0;
1308 }
1309
1310 /* This applies the using directives to add namespaces to search in,
1311    and then searches for overloads in all of those namespaces.  It
1312    adds the symbols found to sym_return_val.  Arguments are as in
1313    make_symbol_overload_list.  */
1314
1315 static void
1316 make_symbol_overload_list_using (const char *func_name,
1317                                  const char *the_namespace)
1318 {
1319   struct using_direct *current;
1320   const struct block *block;
1321
1322   /* First, go through the using directives.  If any of them apply,
1323      look in the appropriate namespaces for new functions to match
1324      on.  */
1325
1326   for (block = get_selected_block (0);
1327        block != NULL;
1328        block = BLOCK_SUPERBLOCK (block))
1329     for (current = block_using (block);
1330         current != NULL;
1331         current = current->next)
1332       {
1333         /* Prevent recursive calls.  */
1334         if (current->searched)
1335           continue;
1336
1337         /* If this is a namespace alias or imported declaration ignore
1338            it.  */
1339         if (current->alias != NULL || current->declaration != NULL)
1340           continue;
1341
1342         if (strcmp (the_namespace, current->import_dest) == 0)
1343           {
1344             /* Mark this import as searched so that the recursive call
1345                does not search it again.  */
1346             struct cleanup *old_chain;
1347             current->searched = 1;
1348             old_chain = make_cleanup (reset_directive_searched,
1349                                       current);
1350
1351             make_symbol_overload_list_using (func_name,
1352                                              current->import_src);
1353
1354             current->searched = 0;
1355             discard_cleanups (old_chain);
1356           }
1357       }
1358
1359   /* Now, add names for this namespace.  */
1360   make_symbol_overload_list_namespace (func_name, the_namespace);
1361 }
1362
1363 /* This does the bulk of the work of finding overloaded symbols.
1364    FUNC_NAME is the name of the overloaded function we're looking for
1365    (possibly including namespace info).  */
1366
1367 static void
1368 make_symbol_overload_list_qualified (const char *func_name)
1369 {
1370   struct compunit_symtab *cust;
1371   struct objfile *objfile;
1372   const struct block *b, *surrounding_static_block = 0;
1373
1374   /* Look through the partial symtabs for all symbols which begin by
1375      matching FUNC_NAME.  Make sure we read that symbol table in.  */
1376
1377   ALL_OBJFILES (objfile)
1378   {
1379     if (objfile->sf)
1380       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1381   }
1382
1383   /* Search upwards from currently selected frame (so that we can
1384      complete on local vars.  */
1385
1386   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1387     make_symbol_overload_list_block (func_name, b);
1388
1389   surrounding_static_block = block_static_block (get_selected_block (0));
1390
1391   /* Go through the symtabs and check the externs and statics for
1392      symbols which match.  */
1393
1394   ALL_COMPUNITS (objfile, cust)
1395   {
1396     QUIT;
1397     b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1398     make_symbol_overload_list_block (func_name, b);
1399   }
1400
1401   ALL_COMPUNITS (objfile, cust)
1402   {
1403     QUIT;
1404     b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1405     /* Don't do this block twice.  */
1406     if (b == surrounding_static_block)
1407       continue;
1408     make_symbol_overload_list_block (func_name, b);
1409   }
1410 }
1411
1412 /* Lookup the rtti type for a class name.  */
1413
1414 struct type *
1415 cp_lookup_rtti_type (const char *name, struct block *block)
1416 {
1417   struct symbol * rtti_sym;
1418   struct type * rtti_type;
1419
1420   /* Use VAR_DOMAIN here as NAME may be a typedef.  PR 18141, 18417.
1421      Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN.  */
1422   rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1423
1424   if (rtti_sym == NULL)
1425     {
1426       warning (_("RTTI symbol not found for class '%s'"), name);
1427       return NULL;
1428     }
1429
1430   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1431     {
1432       warning (_("RTTI symbol for class '%s' is not a type"), name);
1433       return NULL;
1434     }
1435
1436   rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1437
1438   switch (TYPE_CODE (rtti_type))
1439     {
1440     case TYPE_CODE_STRUCT:
1441       break;
1442     case TYPE_CODE_NAMESPACE:
1443       /* chastain/2003-11-26: the symbol tables often contain fake
1444          symbols for namespaces with the same name as the struct.
1445          This warning is an indication of a bug in the lookup order
1446          or a bug in the way that the symbol tables are populated.  */
1447       warning (_("RTTI symbol for class '%s' is a namespace"), name);
1448       return NULL;
1449     default:
1450       warning (_("RTTI symbol for class '%s' has bad type"), name);
1451       return NULL;
1452     }
1453
1454   return rtti_type;
1455 }
1456
1457 #ifdef HAVE_WORKING_FORK
1458
1459 /* If nonzero, attempt to catch crashes in the demangler and print
1460    useful debugging information.  */
1461
1462 static int catch_demangler_crashes = 1;
1463
1464 /* Stack context and environment for demangler crash recovery.  */
1465
1466 static SIGJMP_BUF gdb_demangle_jmp_buf;
1467
1468 /* If nonzero, attempt to dump core from the signal handler.  */
1469
1470 static int gdb_demangle_attempt_core_dump = 1;
1471
1472 /* Signal handler for gdb_demangle.  */
1473
1474 static void
1475 gdb_demangle_signal_handler (int signo)
1476 {
1477   if (gdb_demangle_attempt_core_dump)
1478     {
1479       if (fork () == 0)
1480         dump_core ();
1481
1482       gdb_demangle_attempt_core_dump = 0;
1483     }
1484
1485   SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1486 }
1487
1488 #endif
1489
1490 /* A wrapper for bfd_demangle.  */
1491
1492 char *
1493 gdb_demangle (const char *name, int options)
1494 {
1495   char *result = NULL;
1496   int crash_signal = 0;
1497
1498 #ifdef HAVE_WORKING_FORK
1499 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1500   struct sigaction sa, old_sa;
1501 #else
1502   sighandler_t ofunc;
1503 #endif
1504   static int core_dump_allowed = -1;
1505
1506   if (core_dump_allowed == -1)
1507     {
1508       core_dump_allowed = can_dump_core (LIMIT_CUR);
1509
1510       if (!core_dump_allowed)
1511         gdb_demangle_attempt_core_dump = 0;
1512     }
1513
1514   if (catch_demangler_crashes)
1515     {
1516 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1517       sa.sa_handler = gdb_demangle_signal_handler;
1518       sigemptyset (&sa.sa_mask);
1519 #ifdef HAVE_SIGALTSTACK
1520       sa.sa_flags = SA_ONSTACK;
1521 #else
1522       sa.sa_flags = 0;
1523 #endif
1524       sigaction (SIGSEGV, &sa, &old_sa);
1525 #else
1526       ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1527 #endif
1528
1529       crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1530     }
1531 #endif
1532
1533   if (crash_signal == 0)
1534     result = bfd_demangle (NULL, name, options);
1535
1536 #ifdef HAVE_WORKING_FORK
1537   if (catch_demangler_crashes)
1538     {
1539 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1540       sigaction (SIGSEGV, &old_sa, NULL);
1541 #else
1542       signal (SIGSEGV, ofunc);
1543 #endif
1544
1545       if (crash_signal != 0)
1546         {
1547           static int error_reported = 0;
1548
1549           if (!error_reported)
1550             {
1551               char *short_msg, *long_msg;
1552               struct cleanup *back_to;
1553
1554               short_msg = xstrprintf (_("unable to demangle '%s' "
1555                                       "(demangler failed with signal %d)"),
1556                                     name, crash_signal);
1557               back_to = make_cleanup (xfree, short_msg);
1558
1559               long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__,
1560                                     "demangler-warning", short_msg);
1561               make_cleanup (xfree, long_msg);
1562
1563               make_cleanup_restore_target_terminal ();
1564               target_terminal_ours_for_output ();
1565
1566               begin_line ();
1567               if (core_dump_allowed)
1568                 fprintf_unfiltered (gdb_stderr,
1569                                     _("%s\nAttempting to dump core.\n"),
1570                                     long_msg);
1571               else
1572                 warn_cant_dump_core (long_msg);
1573
1574               demangler_warning (__FILE__, __LINE__, "%s", short_msg);
1575
1576               do_cleanups (back_to);
1577
1578               error_reported = 1;
1579             }
1580
1581           result = NULL;
1582         }
1583     }
1584 #endif
1585
1586   return result;
1587 }
1588
1589 /* See cp-support.h.  */
1590
1591 int
1592 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1593 {
1594   *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1595   return *demangled != NULL;
1596 }
1597
1598 /* Don't allow just "maintenance cplus".  */
1599
1600 static  void
1601 maint_cplus_command (char *arg, int from_tty)
1602 {
1603   printf_unfiltered (_("\"maintenance cplus\" must be followed "
1604                        "by the name of a command.\n"));
1605   help_list (maint_cplus_cmd_list,
1606              "maintenance cplus ",
1607              all_commands, gdb_stdout);
1608 }
1609
1610 /* This is a front end for cp_find_first_component, for unit testing.
1611    Be careful when using it: see the NOTE above
1612    cp_find_first_component.  */
1613
1614 static void
1615 first_component_command (char *arg, int from_tty)
1616 {
1617   int len;
1618   char *prefix;
1619
1620   if (!arg)
1621     return;
1622
1623   len = cp_find_first_component (arg);
1624   prefix = (char *) alloca (len + 1);
1625
1626   memcpy (prefix, arg, len);
1627   prefix[len] = '\0';
1628
1629   printf_unfiltered ("%s\n", prefix);
1630 }
1631
1632 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1633
1634
1635 /* Implement "info vtbl".  */
1636
1637 static void
1638 info_vtbl_command (char *arg, int from_tty)
1639 {
1640   struct value *value;
1641
1642   value = parse_and_eval (arg);
1643   cplus_print_vtable (value);
1644 }
1645
1646 void
1647 _initialize_cp_support (void)
1648 {
1649   add_prefix_cmd ("cplus", class_maintenance,
1650                   maint_cplus_command,
1651                   _("C++ maintenance commands."),
1652                   &maint_cplus_cmd_list,
1653                   "maintenance cplus ",
1654                   0, &maintenancelist);
1655   add_alias_cmd ("cp", "cplus",
1656                  class_maintenance, 1,
1657                  &maintenancelist);
1658
1659   add_cmd ("first_component",
1660            class_maintenance,
1661            first_component_command,
1662            _("Print the first class/namespace component of NAME."),
1663            &maint_cplus_cmd_list);
1664
1665   add_info ("vtbl", info_vtbl_command,
1666             _("Show the virtual function table for a C++ object.\n\
1667 Usage: info vtbl EXPRESSION\n\
1668 Evaluate EXPRESSION and display the virtual function table for the\n\
1669 resulting object."));
1670
1671 #ifdef HAVE_WORKING_FORK
1672   add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
1673                            &catch_demangler_crashes, _("\
1674 Set whether to attempt to catch demangler crashes."), _("\
1675 Show whether to attempt to catch demangler crashes."), _("\
1676 If enabled GDB will attempt to catch demangler crashes and\n\
1677 display the offending symbol."),
1678                            NULL,
1679                            NULL,
1680                            &maintenance_set_cmdlist,
1681                            &maintenance_show_cmdlist);
1682 #endif
1683 }