gdb/cp-support.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2002-2019 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 "common/gdb_setjmp.h"
  38 #include "safe-ctype.h"
  39 #include "common/selftest.h"
  40
  41 #define d_left(dc) (dc)->u.s_binary.left
  42 #define d_right(dc) (dc)->u.s_binary.right
  43
  44 /* Functions related to demangled name parsing.  */
  45
  46 static unsigned int cp_find_first_component_aux (const char *name,
  47                                                  int permissive);
  48
  49 static void demangled_name_complaint (const char *name);
  50
  51 /* Functions related to overload resolution.  */
  52
  53 static void overload_list_add_symbol (struct symbol *sym,
  54                                       const char *oload_name,
  55                                       std::vector<symbol *> *overload_list);
  56
  57 static void add_symbol_overload_list_using
  58   (const char *func_name, const char *the_namespace,
  59    std::vector<symbol *> *overload_list);
  60
  61 static void add_symbol_overload_list_qualified
  62   (const char *func_name,
  63    std::vector<symbol *> *overload_list);
  64
  65 /* The list of "maint cplus" commands.  */
  66
  67 struct cmd_list_element *maint_cplus_cmd_list = NULL;
  68
  69 /* A list of typedefs which should not be substituted by replace_typedefs.  */
  70 static const char * const ignore_typedefs[] =
  71   {
  72     "std::istream", "std::iostream", "std::ostream", "std::string"
  73   };
  74
  75 static void
  76   replace_typedefs (struct demangle_parse_info *info,
  77                     struct demangle_component *ret_comp,
  78                     canonicalization_ftype *finder,
  79                     void *data);
  80
  81 /* A convenience function to copy STRING into OBSTACK, returning a pointer
  82    to the newly allocated string and saving the number of bytes saved in LEN.
  83
  84    It does not copy the terminating '\0' byte!  */
  85
  86 static char *
  87 copy_string_to_obstack (struct obstack *obstack, const char *string,
  88                         long *len)
  89 {
  90   *len = strlen (string);
  91   return (char *) obstack_copy (obstack, string, *len);
  92 }
  93
  94 /* Return 1 if STRING is clearly already in canonical form.  This
  95    function is conservative; things which it does not recognize are
  96    assumed to be non-canonical, and the parser will sort them out
  97    afterwards.  This speeds up the critical path for alphanumeric
  98    identifiers.  */
  99
 100 static int
 101 cp_already_canonical (const char *string)
 102 {
 103   /* Identifier start character [a-zA-Z_].  */
 104   if (!ISIDST (string[0]))
 105     return 0;
 106
 107   /* These are the only two identifiers which canonicalize to other
 108      than themselves or an error: unsigned -> unsigned int and
 109      signed -> int.  */
 110   if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
 111     return 0;
 112   else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
 113     return 0;
 114
 115   /* Identifier character [a-zA-Z0-9_].  */
 116   while (ISIDNUM (string[1]))
 117     string++;
 118
 119   if (string[1] == '\0')
 120     return 1;
 121   else
 122     return 0;
 123 }
 124
 125 /* Inspect the given RET_COMP for its type.  If it is a typedef,
 126    replace the node with the typedef's tree.
 127
 128    Returns 1 if any typedef substitutions were made, 0 otherwise.  */
 129
 130 static int
 131 inspect_type (struct demangle_parse_info *info,
 132               struct demangle_component *ret_comp,
 133               canonicalization_ftype *finder,
 134               void *data)
 135 {
 136   char *name;
 137   struct symbol *sym;
 138
 139   /* Copy the symbol's name from RET_COMP and look it up
 140      in the symbol table.  */
 141   name = (char *) alloca (ret_comp->u.s_name.len + 1);
 142   memcpy (name, ret_comp->u.s_name.s, ret_comp->u.s_name.len);
 143   name[ret_comp->u.s_name.len] = '\0';
 144
 145   /* Ignore any typedefs that should not be substituted.  */
 146   for (int i = 0; i < ARRAY_SIZE (ignore_typedefs); ++i)
 147     {
 148       if (strcmp (name, ignore_typedefs[i]) == 0)
 149         return 0;
 150     }
 151
 152   sym = NULL;
 153
 154   TRY
 155     {
 156       sym = lookup_symbol (name, 0, VAR_DOMAIN, 0).symbol;
 157     }
 158   CATCH (except, RETURN_MASK_ALL)
 159     {
 160       return 0;
 161     }
 162   END_CATCH
 163
 164   if (sym != NULL)
 165     {
 166       struct type *otype = SYMBOL_TYPE (sym);
 167
 168       if (finder != NULL)
 169         {
 170           const char *new_name = (*finder) (otype, data);
 171
 172           if (new_name != NULL)
 173             {
 174               ret_comp->u.s_name.s = new_name;
 175               ret_comp->u.s_name.len = strlen (new_name);
 176               return 1;
 177             }
 178
 179           return 0;
 180         }
 181
 182       /* If the type is a typedef or namespace alias, replace it.  */
 183       if (TYPE_CODE (otype) == TYPE_CODE_TYPEDEF
 184           || TYPE_CODE (otype) == TYPE_CODE_NAMESPACE)
 185         {
 186           long len;
 187           int is_anon;
 188           struct type *type;
 189           std::unique_ptr<demangle_parse_info> i;
 190
 191           /* Get the real type of the typedef.  */
 192           type = check_typedef (otype);
 193
 194           /* If the symbol is a namespace and its type name is no different
 195              than the name we looked up, this symbol is not a namespace
 196              alias and does not need to be substituted.  */
 197           if (TYPE_CODE (otype) == TYPE_CODE_NAMESPACE
 198               && strcmp (TYPE_NAME (type), name) == 0)
 199             return 0;
 200
 201           is_anon = (TYPE_NAME (type) == NULL
 202                      && (TYPE_CODE (type) == TYPE_CODE_ENUM
 203                          || TYPE_CODE (type) == TYPE_CODE_STRUCT
 204                          || TYPE_CODE (type) == TYPE_CODE_UNION));
 205           if (is_anon)
 206             {
 207               struct type *last = otype;
 208
 209               /* Find the last typedef for the type.  */
 210               while (TYPE_TARGET_TYPE (last) != NULL
 211                      && (TYPE_CODE (TYPE_TARGET_TYPE (last))
 212                          == TYPE_CODE_TYPEDEF))
 213                 last = TYPE_TARGET_TYPE (last);
 214
 215               /* If there is only one typedef for this anonymous type,
 216                  do not substitute it.  */
 217               if (type == otype)
 218                 return 0;
 219               else
 220                 /* Use the last typedef seen as the type for this
 221                    anonymous type.  */
 222                 type = last;
 223             }
 224
 225           string_file buf;
 226           TRY
 227             {
 228               type_print (type, "", &buf, -1);
 229             }
 230           /* If type_print threw an exception, there is little point
 231              in continuing, so just bow out gracefully.  */
 232           CATCH (except, RETURN_MASK_ERROR)
 233             {
 234               return 0;
 235             }
 236           END_CATCH
 237
 238           len = buf.size ();
 239           name = (char *) obstack_copy0 (&info->obstack, buf.c_str (), len);
 240
 241           /* Turn the result into a new tree.  Note that this
 242              tree will contain pointers into NAME, so NAME cannot
 243              be free'd until all typedef conversion is done and
 244              the final result is converted into a string.  */
 245           i = cp_demangled_name_to_comp (name, NULL);
 246           if (i != NULL)
 247             {
 248               /* Merge the two trees.  */
 249               cp_merge_demangle_parse_infos (info, ret_comp, i.get ());
 250
 251               /* Replace any newly introduced typedefs -- but not
 252                  if the type is anonymous (that would lead to infinite
 253                  looping).  */
 254               if (!is_anon)
 255                 replace_typedefs (info, ret_comp, finder, data);
 256             }
 257           else
 258             {
 259               /* This shouldn't happen unless the type printer has
 260                  output something that the name parser cannot grok.
 261                  Nonetheless, an ounce of prevention...
 262
 263                  Canonicalize the name again, and store it in the
 264                  current node (RET_COMP).  */
 265               std::string canon = cp_canonicalize_string_no_typedefs (name);
 266
 267               if (!canon.empty ())
 268                 {
 269                   /* Copy the canonicalization into the obstack.  */
 270                   name = copy_string_to_obstack (&info->obstack, canon.c_str (), &len);
 271                 }
 272
 273               ret_comp->u.s_name.s = name;
 274               ret_comp->u.s_name.len = len;
 275             }
 276
 277           return 1;
 278         }
 279     }
 280
 281   return 0;
 282 }
 283
 284 /* Replace any typedefs appearing in the qualified name
 285    (DEMANGLE_COMPONENT_QUAL_NAME) represented in RET_COMP for the name parse
 286    given in INFO.  */
 287
 288 static void
 289 replace_typedefs_qualified_name (struct demangle_parse_info *info,
 290                                  struct demangle_component *ret_comp,
 291                                  canonicalization_ftype *finder,
 292                                  void *data)
 293 {
 294   string_file buf;
 295   struct demangle_component *comp = ret_comp;
 296
 297   /* Walk each node of the qualified name, reconstructing the name of
 298      this element.  With every node, check for any typedef substitutions.
 299      If a substitution has occurred, replace the qualified name node
 300      with a DEMANGLE_COMPONENT_NAME node representing the new, typedef-
 301      substituted name.  */
 302   while (comp->type == DEMANGLE_COMPONENT_QUAL_NAME)
 303     {
 304       if (d_left (comp)->type == DEMANGLE_COMPONENT_NAME)
 305         {
 306           struct demangle_component newobj;
 307
 308           buf.write (d_left (comp)->u.s_name.s, d_left (comp)->u.s_name.len);
 309           newobj.type = DEMANGLE_COMPONENT_NAME;
 310           newobj.u.s_name.s
 311             = (char *) obstack_copy0 (&info->obstack,
 312                                       buf.c_str (), buf.size ());
 313           newobj.u.s_name.len = buf.size ();
 314           if (inspect_type (info, &newobj, finder, data))
 315             {
 316               char *s;
 317               long slen;
 318
 319               /* A typedef was substituted in NEW.  Convert it to a
 320                  string and replace the top DEMANGLE_COMPONENT_QUAL_NAME
 321                  node.  */
 322
 323               buf.clear ();
 324               gdb::unique_xmalloc_ptr<char> n
 325                 = cp_comp_to_string (&newobj, 100);
 326               if (n == NULL)
 327                 {
 328                   /* If something went astray, abort typedef substitutions.  */
 329                   return;
 330                 }
 331
 332               s = copy_string_to_obstack (&info->obstack, n.get (), &slen);
 333
 334               d_left (ret_comp)->type = DEMANGLE_COMPONENT_NAME;
 335               d_left (ret_comp)->u.s_name.s = s;
 336               d_left (ret_comp)->u.s_name.len = slen;
 337               d_right (ret_comp) = d_right (comp);
 338               comp = ret_comp;
 339               continue;
 340             }
 341         }
 342       else
 343         {
 344           /* The current node is not a name, so simply replace any
 345              typedefs in it.  Then print it to the stream to continue
 346              checking for more typedefs in the tree.  */
 347           replace_typedefs (info, d_left (comp), finder, data);
 348           gdb::unique_xmalloc_ptr<char> name
 349             = cp_comp_to_string (d_left (comp), 100);
 350           if (name == NULL)
 351             {
 352               /* If something went astray, abort typedef substitutions.  */
 353               return;
 354             }
 355           buf.puts (name.get ());
 356         }
 357
 358       buf.write ("::", 2);
 359       comp = d_right (comp);
 360     }
 361
 362   /* If the next component is DEMANGLE_COMPONENT_NAME, save the qualified
 363      name assembled above and append the name given by COMP.  Then use this
 364      reassembled name to check for a typedef.  */
 365
 366   if (comp->type == DEMANGLE_COMPONENT_NAME)
 367     {
 368       buf.write (comp->u.s_name.s, comp->u.s_name.len);
 369
 370       /* Replace the top (DEMANGLE_COMPONENT_QUAL_NAME) node
 371          with a DEMANGLE_COMPONENT_NAME node containing the whole
 372          name.  */
 373       ret_comp->type = DEMANGLE_COMPONENT_NAME;
 374       ret_comp->u.s_name.s
 375         = (char *) obstack_copy0 (&info->obstack,
 376                                   buf.c_str (), buf.size ());
 377       ret_comp->u.s_name.len = buf.size ();
 378       inspect_type (info, ret_comp, finder, data);
 379     }
 380   else
 381     replace_typedefs (info, comp, finder, data);
 382 }
 383
 384
 385 /* A function to check const and volatile qualifiers for argument types.
 386
 387    "Parameter declarations that differ only in the presence
 388    or absence of `const' and/or `volatile' are equivalent."
 389    C++ Standard N3290, clause 13.1.3 #4.  */
 390
 391 static void
 392 check_cv_qualifiers (struct demangle_component *ret_comp)
 393 {
 394   while (d_left (ret_comp) != NULL
 395          && (d_left (ret_comp)->type == DEMANGLE_COMPONENT_CONST
 396              || d_left (ret_comp)->type == DEMANGLE_COMPONENT_VOLATILE))
 397     {
 398       d_left (ret_comp) = d_left (d_left (ret_comp));
 399     }
 400 }
 401
 402 /* Walk the parse tree given by RET_COMP, replacing any typedefs with
 403    their basic types.  */
 404
 405 static void
 406 replace_typedefs (struct demangle_parse_info *info,
 407                   struct demangle_component *ret_comp,
 408                   canonicalization_ftype *finder,
 409                   void *data)
 410 {
 411   if (ret_comp)
 412     {
 413       if (finder != NULL
 414           && (ret_comp->type == DEMANGLE_COMPONENT_NAME
 415               || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
 416               || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE
 417               || ret_comp->type == DEMANGLE_COMPONENT_BUILTIN_TYPE))
 418         {
 419           gdb::unique_xmalloc_ptr<char> local_name
 420             = cp_comp_to_string (ret_comp, 10);
 421
 422           if (local_name != NULL)
 423             {
 424               struct symbol *sym = NULL;
 425
 426               sym = NULL;
 427               TRY
 428                 {
 429                   sym = lookup_symbol (local_name.get (), 0,
 430                                        VAR_DOMAIN, 0).symbol;
 431                 }
 432               CATCH (except, RETURN_MASK_ALL)
 433                 {
 434                 }
 435               END_CATCH
 436
 437               if (sym != NULL)
 438                 {
 439                   struct type *otype = SYMBOL_TYPE (sym);
 440                   const char *new_name = (*finder) (otype, data);
 441
 442                   if (new_name != NULL)
 443                     {
 444                       ret_comp->type = DEMANGLE_COMPONENT_NAME;
 445                       ret_comp->u.s_name.s = new_name;
 446                       ret_comp->u.s_name.len = strlen (new_name);
 447                       return;
 448                     }
 449                 }
 450             }
 451         }
 452
 453       switch (ret_comp->type)
 454         {
 455         case DEMANGLE_COMPONENT_ARGLIST:
 456           check_cv_qualifiers (ret_comp);
 457           /* Fall through */
 458
 459         case DEMANGLE_COMPONENT_FUNCTION_TYPE:
 460         case DEMANGLE_COMPONENT_TEMPLATE:
 461         case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
 462         case DEMANGLE_COMPONENT_TYPED_NAME:
 463           replace_typedefs (info, d_left (ret_comp), finder, data);
 464           replace_typedefs (info, d_right (ret_comp), finder, data);
 465           break;
 466
 467         case DEMANGLE_COMPONENT_NAME:
 468           inspect_type (info, ret_comp, finder, data);
 469           break;
 470
 471         case DEMANGLE_COMPONENT_QUAL_NAME:
 472           replace_typedefs_qualified_name (info, ret_comp, finder, data);
 473           break;
 474
 475         case DEMANGLE_COMPONENT_LOCAL_NAME:
 476         case DEMANGLE_COMPONENT_CTOR:
 477         case DEMANGLE_COMPONENT_ARRAY_TYPE:
 478         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
 479           replace_typedefs (info, d_right (ret_comp), finder, data);
 480           break;
 481
 482         case DEMANGLE_COMPONENT_CONST:
 483         case DEMANGLE_COMPONENT_RESTRICT:
 484         case DEMANGLE_COMPONENT_VOLATILE:
 485         case DEMANGLE_COMPONENT_VOLATILE_THIS:
 486         case DEMANGLE_COMPONENT_CONST_THIS:
 487         case DEMANGLE_COMPONENT_RESTRICT_THIS:
 488         case DEMANGLE_COMPONENT_POINTER:
 489         case DEMANGLE_COMPONENT_REFERENCE:
 490         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
 491           replace_typedefs (info, d_left (ret_comp), finder, data);
 492           break;
 493
 494         default:
 495           break;
 496         }
 497     }
 498 }
 499
 500 /* Parse STRING and convert it to canonical form, resolving any
 501    typedefs.  If parsing fails, or if STRING is already canonical,
 502    return the empty string.  Otherwise return the canonical form.  If
 503    FINDER is not NULL, then type components are passed to FINDER to be
 504    looked up.  DATA is passed verbatim to FINDER.  */
 505
 506 std::string
 507 cp_canonicalize_string_full (const char *string,
 508                              canonicalization_ftype *finder,
 509                              void *data)
 510 {
 511   std::string ret;
 512   unsigned int estimated_len;
 513   std::unique_ptr<demangle_parse_info> info;
 514
 515   estimated_len = strlen (string) * 2;
 516   info = cp_demangled_name_to_comp (string, NULL);
 517   if (info != NULL)
 518     {
 519       /* Replace all the typedefs in the tree.  */
 520       replace_typedefs (info.get (), info->tree, finder, data);
 521
 522       /* Convert the tree back into a string.  */
 523       gdb::unique_xmalloc_ptr<char> us = cp_comp_to_string (info->tree,
 524                                                             estimated_len);
 525       gdb_assert (us);
 526
 527       ret = us.get ();
 528       /* Finally, compare the original string with the computed
 529          name, returning NULL if they are the same.  */
 530       if (ret == string)
 531         return std::string ();
 532     }
 533
 534   return ret;
 535 }
 536
 537 /* Like cp_canonicalize_string_full, but always passes NULL for
 538    FINDER.  */
 539
 540 std::string
 541 cp_canonicalize_string_no_typedefs (const char *string)
 542 {
 543   return cp_canonicalize_string_full (string, NULL, NULL);
 544 }
 545
 546 /* Parse STRING and convert it to canonical form.  If parsing fails,
 547    or if STRING is already canonical, return the empty string.
 548    Otherwise return the canonical form.  */
 549
 550 std::string
 551 cp_canonicalize_string (const char *string)
 552 {
 553   std::unique_ptr<demangle_parse_info> info;
 554   unsigned int estimated_len;
 555
 556   if (cp_already_canonical (string))
 557     return std::string ();
 558
 559   info = cp_demangled_name_to_comp (string, NULL);
 560   if (info == NULL)
 561     return std::string ();
 562
 563   estimated_len = strlen (string) * 2;
 564   gdb::unique_xmalloc_ptr<char> us (cp_comp_to_string (info->tree,
 565                                                        estimated_len));
 566
 567   if (!us)
 568     {
 569       warning (_("internal error: string \"%s\" failed to be canonicalized"),
 570                string);
 571       return std::string ();
 572     }
 573
 574   std::string ret (us.get ());
 575
 576   if (ret == string)
 577     return std::string ();
 578
 579   return ret;
 580 }
 581
 582 /* Convert a mangled name to a demangle_component tree.  *MEMORY is
 583    set to the block of used memory that should be freed when finished
 584    with the tree.  DEMANGLED_P is set to the char * that should be
 585    freed when finished with the tree, or NULL if none was needed.
 586    OPTIONS will be passed to the demangler.  */
 587
 588 static std::unique_ptr<demangle_parse_info>
 589 mangled_name_to_comp (const char *mangled_name, int options,
 590                       void **memory, char **demangled_p)
 591 {
 592   char *demangled_name;
 593
 594   /* If it looks like a v3 mangled name, then try to go directly
 595      to trees.  */
 596   if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
 597     {
 598       struct demangle_component *ret;
 599
 600       ret = cplus_demangle_v3_components (mangled_name,
 601                                           options, memory);
 602       if (ret)
 603         {
 604           std::unique_ptr<demangle_parse_info> info (new demangle_parse_info);
 605           info->tree = ret;
 606           *demangled_p = NULL;
 607           return info;
 608         }
 609     }
 610
 611   /* If it doesn't, or if that failed, then try to demangle the
 612      name.  */
 613   demangled_name = gdb_demangle (mangled_name, options);
 614   if (demangled_name == NULL)
 615    return NULL;
 616
 617   /* If we could demangle the name, parse it to build the component
 618      tree.  */
 619   std::unique_ptr<demangle_parse_info> info
 620     = cp_demangled_name_to_comp (demangled_name, NULL);
 621
 622   if (info == NULL)
 623     {
 624       xfree (demangled_name);
 625       return NULL;
 626     }
 627
 628   *demangled_p = demangled_name;
 629   return info;
 630 }
 631
 632 /* Return the name of the class containing method PHYSNAME.  */
 633
 634 char *
 635 cp_class_name_from_physname (const char *physname)
 636 {
 637   void *storage = NULL;
 638   char *demangled_name = NULL;
 639   gdb::unique_xmalloc_ptr<char> ret;
 640   struct demangle_component *ret_comp, *prev_comp, *cur_comp;
 641   std::unique_ptr<demangle_parse_info> info;
 642   int done;
 643
 644   info = mangled_name_to_comp (physname, DMGL_ANSI,
 645                                &storage, &demangled_name);
 646   if (info == NULL)
 647     return NULL;
 648
 649   done = 0;
 650   ret_comp = info->tree;
 651
 652   /* First strip off any qualifiers, if we have a function or
 653      method.  */
 654   while (!done)
 655     switch (ret_comp->type)
 656       {
 657       case DEMANGLE_COMPONENT_CONST:
 658       case DEMANGLE_COMPONENT_RESTRICT:
 659       case DEMANGLE_COMPONENT_VOLATILE:
 660       case DEMANGLE_COMPONENT_CONST_THIS:
 661       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 662       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 663       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 664         ret_comp = d_left (ret_comp);
 665         break;
 666       default:
 667         done = 1;
 668         break;
 669       }
 670
 671   /* If what we have now is a function, discard the argument list.  */
 672   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 673     ret_comp = d_left (ret_comp);
 674
 675   /* If what we have now is a template, strip off the template
 676      arguments.  The left subtree may be a qualified name.  */
 677   if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
 678     ret_comp = d_left (ret_comp);
 679
 680   /* What we have now should be a name, possibly qualified.
 681      Additional qualifiers could live in the left subtree or the right
 682      subtree.  Find the last piece.  */
 683   done = 0;
 684   prev_comp = NULL;
 685   cur_comp = ret_comp;
 686   while (!done)
 687     switch (cur_comp->type)
 688       {
 689       case DEMANGLE_COMPONENT_QUAL_NAME:
 690       case DEMANGLE_COMPONENT_LOCAL_NAME:
 691         prev_comp = cur_comp;
 692         cur_comp = d_right (cur_comp);
 693         break;
 694       case DEMANGLE_COMPONENT_TEMPLATE:
 695       case DEMANGLE_COMPONENT_NAME:
 696       case DEMANGLE_COMPONENT_CTOR:
 697       case DEMANGLE_COMPONENT_DTOR:
 698       case DEMANGLE_COMPONENT_OPERATOR:
 699       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 700         done = 1;
 701         break;
 702       default:
 703         done = 1;
 704         cur_comp = NULL;
 705         break;
 706       }
 707
 708   if (cur_comp != NULL && prev_comp != NULL)
 709     {
 710       /* We want to discard the rightmost child of PREV_COMP.  */
 711       *prev_comp = *d_left (prev_comp);
 712       /* The ten is completely arbitrary; we don't have a good
 713          estimate.  */
 714       ret = cp_comp_to_string (ret_comp, 10);
 715     }
 716
 717   xfree (storage);
 718   xfree (demangled_name);
 719   return ret.release ();
 720 }
 721
 722 /* Return the child of COMP which is the basename of a method,
 723    variable, et cetera.  All scope qualifiers are discarded, but
 724    template arguments will be included.  The component tree may be
 725    modified.  */
 726
 727 static struct demangle_component *
 728 unqualified_name_from_comp (struct demangle_component *comp)
 729 {
 730   struct demangle_component *ret_comp = comp, *last_template;
 731   int done;
 732
 733   done = 0;
 734   last_template = NULL;
 735   while (!done)
 736     switch (ret_comp->type)
 737       {
 738       case DEMANGLE_COMPONENT_QUAL_NAME:
 739       case DEMANGLE_COMPONENT_LOCAL_NAME:
 740         ret_comp = d_right (ret_comp);
 741         break;
 742       case DEMANGLE_COMPONENT_TYPED_NAME:
 743         ret_comp = d_left (ret_comp);
 744         break;
 745       case DEMANGLE_COMPONENT_TEMPLATE:
 746         gdb_assert (last_template == NULL);
 747         last_template = ret_comp;
 748         ret_comp = d_left (ret_comp);
 749         break;
 750       case DEMANGLE_COMPONENT_CONST:
 751       case DEMANGLE_COMPONENT_RESTRICT:
 752       case DEMANGLE_COMPONENT_VOLATILE:
 753       case DEMANGLE_COMPONENT_CONST_THIS:
 754       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 755       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 756       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 757         ret_comp = d_left (ret_comp);
 758         break;
 759       case DEMANGLE_COMPONENT_NAME:
 760       case DEMANGLE_COMPONENT_CTOR:
 761       case DEMANGLE_COMPONENT_DTOR:
 762       case DEMANGLE_COMPONENT_OPERATOR:
 763       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 764         done = 1;
 765         break;
 766       default:
 767         return NULL;
 768         break;
 769       }
 770
 771   if (last_template)
 772     {
 773       d_left (last_template) = ret_comp;
 774       return last_template;
 775     }
 776
 777   return ret_comp;
 778 }
 779
 780 /* Return the name of the method whose linkage name is PHYSNAME.  */
 781
 782 char *
 783 method_name_from_physname (const char *physname)
 784 {
 785   void *storage = NULL;
 786   char *demangled_name = NULL;
 787   gdb::unique_xmalloc_ptr<char> ret;
 788   struct demangle_component *ret_comp;
 789   std::unique_ptr<demangle_parse_info> info;
 790
 791   info = mangled_name_to_comp (physname, DMGL_ANSI,
 792                                &storage, &demangled_name);
 793   if (info == NULL)
 794     return NULL;
 795
 796   ret_comp = unqualified_name_from_comp (info->tree);
 797
 798   if (ret_comp != NULL)
 799     /* The ten is completely arbitrary; we don't have a good
 800        estimate.  */
 801     ret = cp_comp_to_string (ret_comp, 10);
 802
 803   xfree (storage);
 804   xfree (demangled_name);
 805   return ret.release ();
 806 }
 807
 808 /* If FULL_NAME is the demangled name of a C++ function (including an
 809    arg list, possibly including namespace/class qualifications),
 810    return a new string containing only the function name (without the
 811    arg list/class qualifications).  Otherwise, return NULL.  */
 812
 813 gdb::unique_xmalloc_ptr<char>
 814 cp_func_name (const char *full_name)
 815 {
 816   gdb::unique_xmalloc_ptr<char> ret;
 817   struct demangle_component *ret_comp;
 818   std::unique_ptr<demangle_parse_info> info;
 819
 820   info = cp_demangled_name_to_comp (full_name, NULL);
 821   if (!info)
 822     return nullptr;
 823
 824   ret_comp = unqualified_name_from_comp (info->tree);
 825
 826   if (ret_comp != NULL)
 827     ret = cp_comp_to_string (ret_comp, 10);
 828
 829   return ret;
 830 }
 831
 832 /* Helper for cp_remove_params.  DEMANGLED_NAME is the name of a
 833    function, including parameters and (optionally) a return type.
 834    Return the name of the function without parameters or return type,
 835    or NULL if we can not parse the name.  If REQUIRE_PARAMS is false,
 836    then tolerate a non-existing or unbalanced parameter list.  */
 837
 838 static gdb::unique_xmalloc_ptr<char>
 839 cp_remove_params_1 (const char *demangled_name, bool require_params)
 840 {
 841   bool done = false;
 842   struct demangle_component *ret_comp;
 843   std::unique_ptr<demangle_parse_info> info;
 844   gdb::unique_xmalloc_ptr<char> ret;
 845
 846   if (demangled_name == NULL)
 847     return NULL;
 848
 849   info = cp_demangled_name_to_comp (demangled_name, NULL);
 850   if (info == NULL)
 851     return NULL;
 852
 853   /* First strip off any qualifiers, if we have a function or method.  */
 854   ret_comp = info->tree;
 855   while (!done)
 856     switch (ret_comp->type)
 857       {
 858       case DEMANGLE_COMPONENT_CONST:
 859       case DEMANGLE_COMPONENT_RESTRICT:
 860       case DEMANGLE_COMPONENT_VOLATILE:
 861       case DEMANGLE_COMPONENT_CONST_THIS:
 862       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 863       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 864       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 865         ret_comp = d_left (ret_comp);
 866         break;
 867       default:
 868         done = true;
 869         break;
 870       }
 871
 872   /* What we have now should be a function.  Return its name.  */
 873   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 874     ret = cp_comp_to_string (d_left (ret_comp), 10);
 875   else if (!require_params
 876            && (ret_comp->type == DEMANGLE_COMPONENT_NAME
 877                || ret_comp->type == DEMANGLE_COMPONENT_QUAL_NAME
 878                || ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE))
 879     ret = cp_comp_to_string (ret_comp, 10);
 880
 881   return ret;
 882 }
 883
 884 /* DEMANGLED_NAME is the name of a function, including parameters and
 885    (optionally) a return type.  Return the name of the function
 886    without parameters or return type, or NULL if we can not parse the
 887    name.  */
 888
 889 gdb::unique_xmalloc_ptr<char>
 890 cp_remove_params (const char *demangled_name)
 891 {
 892   return cp_remove_params_1 (demangled_name, true);
 893 }
 894
 895 /* See cp-support.h.  */
 896
 897 gdb::unique_xmalloc_ptr<char>
 898 cp_remove_params_if_any (const char *demangled_name, bool completion_mode)
 899 {
 900   /* Trying to remove parameters from the empty string fails.  If
 901      we're completing / matching everything, avoid returning NULL
 902      which would make callers interpret the result as an error.  */
 903   if (demangled_name[0] == '\0' && completion_mode)
 904     return gdb::unique_xmalloc_ptr<char> (xstrdup (""));
 905
 906   gdb::unique_xmalloc_ptr<char> without_params
 907     = cp_remove_params_1 (demangled_name, false);
 908
 909   if (without_params == NULL && completion_mode)
 910     {
 911       std::string copy = demangled_name;
 912
 913       while (!copy.empty ())
 914         {
 915           copy.pop_back ();
 916           without_params = cp_remove_params_1 (copy.c_str (), false);
 917           if (without_params != NULL)
 918             break;
 919         }
 920     }
 921
 922   return without_params;
 923 }
 924
 925 /* Here are some random pieces of trivia to keep in mind while trying
 926    to take apart demangled names:
 927
 928    - Names can contain function arguments or templates, so the process
 929      has to be, to some extent recursive: maybe keep track of your
 930      depth based on encountering <> and ().
 931
 932    - Parentheses don't just have to happen at the end of a name: they
 933      can occur even if the name in question isn't a function, because
 934      a template argument might be a type that's a function.
 935
 936    - Conversely, even if you're trying to deal with a function, its
 937      demangled name might not end with ')': it could be a const or
 938      volatile class method, in which case it ends with "const" or
 939      "volatile".
 940
 941    - Parentheses are also used in anonymous namespaces: a variable
 942      'foo' in an anonymous namespace gets demangled as "(anonymous
 943      namespace)::foo".
 944
 945    - And operator names can contain parentheses or angle brackets.  */
 946
 947 /* FIXME: carlton/2003-03-13: We have several functions here with
 948    overlapping functionality; can we combine them?  Also, do they
 949    handle all the above considerations correctly?  */
 950
 951
 952 /* This returns the length of first component of NAME, which should be
 953    the demangled name of a C++ variable/function/method/etc.
 954    Specifically, it returns the index of the first colon forming the
 955    boundary of the first component: so, given 'A::foo' or 'A::B::foo'
 956    it returns the 1, and given 'foo', it returns 0.  */
 957
 958 /* The character in NAME indexed by the return value is guaranteed to
 959    always be either ':' or '\0'.  */
 960
 961 /* NOTE: carlton/2003-03-13: This function is currently only intended
 962    for internal use: it's probably not entirely safe when called on
 963    user-generated input, because some of the 'index += 2' lines in
 964    cp_find_first_component_aux might go past the end of malformed
 965    input.  */
 966
 967 unsigned int
 968 cp_find_first_component (const char *name)
 969 {
 970   return cp_find_first_component_aux (name, 0);
 971 }
 972
 973 /* Helper function for cp_find_first_component.  Like that function,
 974    it returns the length of the first component of NAME, but to make
 975    the recursion easier, it also stops if it reaches an unexpected ')'
 976    or '>' if the value of PERMISSIVE is nonzero.  */
 977
 978 static unsigned int
 979 cp_find_first_component_aux (const char *name, int permissive)
 980 {
 981   unsigned int index = 0;
 982   /* Operator names can show up in unexpected places.  Since these can
 983      contain parentheses or angle brackets, they can screw up the
 984      recursion.  But not every string 'operator' is part of an
 985      operater name: e.g. you could have a variable 'cooperator'.  So
 986      this variable tells us whether or not we should treat the string
 987      'operator' as starting an operator.  */
 988   int operator_possible = 1;
 989
 990   for (;; ++index)
 991     {
 992       switch (name[index])
 993         {
 994         case '<':
 995           /* Template; eat it up.  The calls to cp_first_component
 996              should only return (I hope!) when they reach the '>'
 997              terminating the component or a '::' between two
 998              components.  (Hence the '+ 2'.)  */
 999           index += 1;
1000           for (index += cp_find_first_component_aux (name + index, 1);
1001                name[index] != '>';
1002                index += cp_find_first_component_aux (name + index, 1))
1003             {
1004               if (name[index] != ':')
1005                 {
1006                   demangled_name_complaint (name);
1007                   return strlen (name);
1008                 }
1009               index += 2;
1010             }
1011           operator_possible = 1;
1012           break;
1013         case '(':
1014           /* Similar comment as to '<'.  */
1015           index += 1;
1016           for (index += cp_find_first_component_aux (name + index, 1);
1017                name[index] != ')';
1018                index += cp_find_first_component_aux (name + index, 1))
1019             {
1020               if (name[index] != ':')
1021                 {
1022                   demangled_name_complaint (name);
1023                   return strlen (name);
1024                 }
1025               index += 2;
1026             }
1027           operator_possible = 1;
1028           break;
1029         case '>':
1030         case ')':
1031           if (permissive)
1032             return index;
1033           else
1034             {
1035               demangled_name_complaint (name);
1036               return strlen (name);
1037             }
1038         case '\0':
1039           return index;
1040         case ':':
1041           /* ':' marks a component iff the next character is also a ':'.
1042              Otherwise it is probably malformed input.  */
1043           if (name[index + 1] == ':')
1044             return index;
1045           break;
1046         case 'o':
1047           /* Operator names can screw up the recursion.  */
1048           if (operator_possible
1049               && startswith (name + index, CP_OPERATOR_STR))
1050             {
1051               index += CP_OPERATOR_LEN;
1052               while (ISSPACE(name[index]))
1053                 ++index;
1054               switch (name[index])
1055                 {
1056                 case '\0':
1057                   return index;
1058                   /* Skip over one less than the appropriate number of
1059                      characters: the for loop will skip over the last
1060                      one.  */
1061                 case '<':
1062                   if (name[index + 1] == '<')
1063                     index += 1;
1064                   else
1065                     index += 0;
1066                   break;
1067                 case '>':
1068                 case '-':
1069                   if (name[index + 1] == '>')
1070                     index += 1;
1071                   else
1072                     index += 0;
1073                   break;
1074                 case '(':
1075                   index += 1;
1076                   break;
1077                 default:
1078                   index += 0;
1079                   break;
1080                 }
1081             }
1082           operator_possible = 0;
1083           break;
1084         case ' ':
1085         case ',':
1086         case '.':
1087         case '&':
1088         case '*':
1089           /* NOTE: carlton/2003-04-18: I'm not sure what the precise
1090              set of relevant characters are here: it's necessary to
1091              include any character that can show up before 'operator'
1092              in a demangled name, and it's safe to include any
1093              character that can't be part of an identifier's name.  */
1094           operator_possible = 1;
1095           break;
1096         default:
1097           operator_possible = 0;
1098           break;
1099         }
1100     }
1101 }
1102
1103 /* Complain about a demangled name that we don't know how to parse.
1104    NAME is the demangled name in question.  */
1105
1106 static void
1107 demangled_name_complaint (const char *name)
1108 {
1109   complaint ("unexpected demangled name '%s'", name);
1110 }
1111
1112 /* If NAME is the fully-qualified name of a C++
1113    function/variable/method/etc., this returns the length of its
1114    entire prefix: all of the namespaces and classes that make up its
1115    name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
1116    4, given 'foo', it returns 0.  */
1117
1118 unsigned int
1119 cp_entire_prefix_len (const char *name)
1120 {
1121   unsigned int current_len = cp_find_first_component (name);
1122   unsigned int previous_len = 0;
1123
1124   while (name[current_len] != '\0')
1125     {
1126       gdb_assert (name[current_len] == ':');
1127       previous_len = current_len;
1128       /* Skip the '::'.  */
1129       current_len += 2;
1130       current_len += cp_find_first_component (name + current_len);
1131     }
1132
1133   return previous_len;
1134 }
1135
1136 /* Overload resolution functions.  */
1137
1138 /* Test to see if SYM is a symbol that we haven't seen corresponding
1139    to a function named OLOAD_NAME.  If so, add it to
1140    OVERLOAD_LIST.  */
1141
1142 static void
1143 overload_list_add_symbol (struct symbol *sym,
1144                           const char *oload_name,
1145                           std::vector<symbol *> *overload_list)
1146 {
1147   /* If there is no type information, we can't do anything, so
1148      skip.  */
1149   if (SYMBOL_TYPE (sym) == NULL)
1150     return;
1151
1152   /* skip any symbols that we've already considered.  */
1153   for (symbol *listed_sym : *overload_list)
1154     if (strcmp (SYMBOL_LINKAGE_NAME (sym),
1155                 SYMBOL_LINKAGE_NAME (listed_sym)) == 0)
1156       return;
1157
1158   /* Get the demangled name without parameters */
1159   gdb::unique_xmalloc_ptr<char> sym_name
1160     = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
1161   if (!sym_name)
1162     return;
1163
1164   /* skip symbols that cannot match */
1165   if (strcmp (sym_name.get (), oload_name) != 0)
1166     return;
1167
1168   overload_list->push_back (sym);
1169 }
1170
1171 /* Return a null-terminated list of pointers to function symbols that
1172    are named FUNC_NAME and are visible within NAMESPACE.  */
1173
1174 struct std::vector<symbol *>
1175 make_symbol_overload_list (const char *func_name,
1176                            const char *the_namespace)
1177 {
1178   const char *name;
1179   std::vector<symbol *> overload_list;
1180
1181   overload_list.reserve (100);
1182
1183   add_symbol_overload_list_using (func_name, the_namespace, &overload_list);
1184
1185   if (the_namespace[0] == '\0')
1186     name = func_name;
1187   else
1188     {
1189       char *concatenated_name
1190         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1191       strcpy (concatenated_name, the_namespace);
1192       strcat (concatenated_name, "::");
1193       strcat (concatenated_name, func_name);
1194       name = concatenated_name;
1195     }
1196
1197   add_symbol_overload_list_qualified (name, &overload_list);
1198   return overload_list;
1199 }
1200
1201 /* Add all symbols with a name matching NAME in BLOCK to the overload
1202    list.  */
1203
1204 static void
1205 add_symbol_overload_list_block (const char *name,
1206                                 const struct block *block,
1207                                 std::vector<symbol *> *overload_list)
1208 {
1209   struct block_iterator iter;
1210   struct symbol *sym;
1211
1212   lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
1213
1214   ALL_BLOCK_SYMBOLS_WITH_NAME (block, lookup_name, iter, sym)
1215     overload_list_add_symbol (sym, name, overload_list);
1216 }
1217
1218 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
1219
1220 static void
1221 add_symbol_overload_list_namespace (const char *func_name,
1222                                     const char *the_namespace,
1223                                     std::vector<symbol *> *overload_list)
1224 {
1225   const char *name;
1226   const struct block *block = NULL;
1227
1228   if (the_namespace[0] == '\0')
1229     name = func_name;
1230   else
1231     {
1232       char *concatenated_name
1233         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1234
1235       strcpy (concatenated_name, the_namespace);
1236       strcat (concatenated_name, "::");
1237       strcat (concatenated_name, func_name);
1238       name = concatenated_name;
1239     }
1240
1241   /* Look in the static block.  */
1242   block = block_static_block (get_selected_block (0));
1243   if (block)
1244     add_symbol_overload_list_block (name, block, overload_list);
1245
1246   /* Look in the global block.  */
1247   block = block_global_block (block);
1248   if (block)
1249     add_symbol_overload_list_block (name, block, overload_list);
1250
1251 }
1252
1253 /* Search the namespace of the given type and namespace of and public
1254    base types.  */
1255
1256 static void
1257 add_symbol_overload_list_adl_namespace (struct type *type,
1258                                         const char *func_name,
1259                                         std::vector<symbol *> *overload_list)
1260 {
1261   char *the_namespace;
1262   const char *type_name;
1263   int i, prefix_len;
1264
1265   while (TYPE_CODE (type) == TYPE_CODE_PTR
1266          || TYPE_IS_REFERENCE (type)
1267          || TYPE_CODE (type) == TYPE_CODE_ARRAY
1268          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1269     {
1270       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1271         type = check_typedef(type);
1272       else
1273         type = TYPE_TARGET_TYPE (type);
1274     }
1275
1276   type_name = TYPE_NAME (type);
1277
1278   if (type_name == NULL)
1279     return;
1280
1281   prefix_len = cp_entire_prefix_len (type_name);
1282
1283   if (prefix_len != 0)
1284     {
1285       the_namespace = (char *) alloca (prefix_len + 1);
1286       strncpy (the_namespace, type_name, prefix_len);
1287       the_namespace[prefix_len] = '\0';
1288
1289       add_symbol_overload_list_namespace (func_name, the_namespace,
1290                                           overload_list);
1291     }
1292
1293   /* Check public base type */
1294   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1295     for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1296       {
1297         if (BASETYPE_VIA_PUBLIC (type, i))
1298           add_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type, i),
1299                                                   func_name,
1300                                                   overload_list);
1301       }
1302 }
1303
1304 /* Adds to OVERLOAD_LIST the overload list overload candidates for
1305    FUNC_NAME found through argument dependent lookup.  */
1306
1307 void
1308 add_symbol_overload_list_adl (gdb::array_view<type *> arg_types,
1309                               const char *func_name,
1310                               std::vector<symbol *> *overload_list)
1311 {
1312   for (type *arg_type : arg_types)
1313     add_symbol_overload_list_adl_namespace (arg_type, func_name,
1314                                             overload_list);
1315 }
1316
1317 /* This applies the using directives to add namespaces to search in,
1318    and then searches for overloads in all of those namespaces.  It
1319    adds the symbols found to sym_return_val.  Arguments are as in
1320    make_symbol_overload_list.  */
1321
1322 static void
1323 add_symbol_overload_list_using (const char *func_name,
1324                                 const char *the_namespace,
1325                                 std::vector<symbol *> *overload_list)
1326 {
1327   struct using_direct *current;
1328   const struct block *block;
1329
1330   /* First, go through the using directives.  If any of them apply,
1331      look in the appropriate namespaces for new functions to match
1332      on.  */
1333
1334   for (block = get_selected_block (0);
1335        block != NULL;
1336        block = BLOCK_SUPERBLOCK (block))
1337     for (current = block_using (block);
1338         current != NULL;
1339         current = current->next)
1340       {
1341         /* Prevent recursive calls.  */
1342         if (current->searched)
1343           continue;
1344
1345         /* If this is a namespace alias or imported declaration ignore
1346            it.  */
1347         if (current->alias != NULL || current->declaration != NULL)
1348           continue;
1349
1350         if (strcmp (the_namespace, current->import_dest) == 0)
1351           {
1352             /* Mark this import as searched so that the recursive call
1353                does not search it again.  */
1354             scoped_restore reset_directive_searched
1355               = make_scoped_restore (&current->searched, 1);
1356
1357             add_symbol_overload_list_using (func_name,
1358                                             current->import_src,
1359                                             overload_list);
1360           }
1361       }
1362
1363   /* Now, add names for this namespace.  */
1364   add_symbol_overload_list_namespace (func_name, the_namespace,
1365                                       overload_list);
1366 }
1367
1368 /* This does the bulk of the work of finding overloaded symbols.
1369    FUNC_NAME is the name of the overloaded function we're looking for
1370    (possibly including namespace info).  */
1371
1372 static void
1373 add_symbol_overload_list_qualified (const char *func_name,
1374                                     std::vector<symbol *> *overload_list)
1375 {
1376   const struct block *b, *surrounding_static_block = 0;
1377
1378   /* Look through the partial symtabs for all symbols which begin by
1379      matching FUNC_NAME.  Make sure we read that symbol table in.  */
1380
1381   for (objfile *objf : current_program_space->objfiles ())
1382     {
1383       if (objf->sf)
1384         objf->sf->qf->expand_symtabs_for_function (objf, func_name);
1385     }
1386
1387   /* Search upwards from currently selected frame (so that we can
1388      complete on local vars.  */
1389
1390   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1391     add_symbol_overload_list_block (func_name, b, overload_list);
1392
1393   surrounding_static_block = block_static_block (get_selected_block (0));
1394
1395   /* Go through the symtabs and check the externs and statics for
1396      symbols which match.  */
1397
1398   for (objfile *objfile : current_program_space->objfiles ())
1399     {
1400       for (compunit_symtab *cust : objfile->compunits ())
1401         {
1402           QUIT;
1403           b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1404           add_symbol_overload_list_block (func_name, b, overload_list);
1405         }
1406     }
1407
1408   for (objfile *objfile : current_program_space->objfiles ())
1409     {
1410       for (compunit_symtab *cust : objfile->compunits ())
1411         {
1412           QUIT;
1413           b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1414           /* Don't do this block twice.  */
1415           if (b == surrounding_static_block)
1416             continue;
1417           add_symbol_overload_list_block (func_name, b, overload_list);
1418         }
1419     }
1420 }
1421
1422 /* Lookup the rtti type for a class name.  */
1423
1424 struct type *
1425 cp_lookup_rtti_type (const char *name, const struct block *block)
1426 {
1427   struct symbol * rtti_sym;
1428   struct type * rtti_type;
1429
1430   /* Use VAR_DOMAIN here as NAME may be a typedef.  PR 18141, 18417.
1431      Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN.  */
1432   rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1433
1434   if (rtti_sym == NULL)
1435     {
1436       warning (_("RTTI symbol not found for class '%s'"), name);
1437       return NULL;
1438     }
1439
1440   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1441     {
1442       warning (_("RTTI symbol for class '%s' is not a type"), name);
1443       return NULL;
1444     }
1445
1446   rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1447
1448   switch (TYPE_CODE (rtti_type))
1449     {
1450     case TYPE_CODE_STRUCT:
1451       break;
1452     case TYPE_CODE_NAMESPACE:
1453       /* chastain/2003-11-26: the symbol tables often contain fake
1454          symbols for namespaces with the same name as the struct.
1455          This warning is an indication of a bug in the lookup order
1456          or a bug in the way that the symbol tables are populated.  */
1457       warning (_("RTTI symbol for class '%s' is a namespace"), name);
1458       return NULL;
1459     default:
1460       warning (_("RTTI symbol for class '%s' has bad type"), name);
1461       return NULL;
1462     }
1463
1464   return rtti_type;
1465 }
1466
1467 #ifdef HAVE_WORKING_FORK
1468
1469 /* If nonzero, attempt to catch crashes in the demangler and print
1470    useful debugging information.  */
1471
1472 static int catch_demangler_crashes = 1;
1473
1474 /* Stack context and environment for demangler crash recovery.  */
1475
1476 static SIGJMP_BUF gdb_demangle_jmp_buf;
1477
1478 /* If nonzero, attempt to dump core from the signal handler.  */
1479
1480 static int gdb_demangle_attempt_core_dump = 1;
1481
1482 /* Signal handler for gdb_demangle.  */
1483
1484 static void
1485 gdb_demangle_signal_handler (int signo)
1486 {
1487   if (gdb_demangle_attempt_core_dump)
1488     {
1489       if (fork () == 0)
1490         dump_core ();
1491
1492       gdb_demangle_attempt_core_dump = 0;
1493     }
1494
1495   SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1496 }
1497
1498 #endif
1499
1500 /* A wrapper for bfd_demangle.  */
1501
1502 char *
1503 gdb_demangle (const char *name, int options)
1504 {
1505   char *result = NULL;
1506   int crash_signal = 0;
1507
1508 #ifdef HAVE_WORKING_FORK
1509 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1510   struct sigaction sa, old_sa;
1511 #else
1512   sighandler_t ofunc;
1513 #endif
1514   static int core_dump_allowed = -1;
1515
1516   if (core_dump_allowed == -1)
1517     {
1518       core_dump_allowed = can_dump_core (LIMIT_CUR);
1519
1520       if (!core_dump_allowed)
1521         gdb_demangle_attempt_core_dump = 0;
1522     }
1523
1524   if (catch_demangler_crashes)
1525     {
1526 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1527       sa.sa_handler = gdb_demangle_signal_handler;
1528       sigemptyset (&sa.sa_mask);
1529 #ifdef HAVE_SIGALTSTACK
1530       sa.sa_flags = SA_ONSTACK;
1531 #else
1532       sa.sa_flags = 0;
1533 #endif
1534       sigaction (SIGSEGV, &sa, &old_sa);
1535 #else
1536       ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1537 #endif
1538
1539       crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1540     }
1541 #endif
1542
1543   if (crash_signal == 0)
1544     result = bfd_demangle (NULL, name, options);
1545
1546 #ifdef HAVE_WORKING_FORK
1547   if (catch_demangler_crashes)
1548     {
1549 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1550       sigaction (SIGSEGV, &old_sa, NULL);
1551 #else
1552       signal (SIGSEGV, ofunc);
1553 #endif
1554
1555       if (crash_signal != 0)
1556         {
1557           static int error_reported = 0;
1558
1559           if (!error_reported)
1560             {
1561               std::string short_msg
1562                 = string_printf (_("unable to demangle '%s' "
1563                                    "(demangler failed with signal %d)"),
1564                                  name, crash_signal);
1565
1566               std::string long_msg
1567                 = string_printf ("%s:%d: %s: %s", __FILE__, __LINE__,
1568                                  "demangler-warning", short_msg.c_str ());
1569
1570               target_terminal::scoped_restore_terminal_state term_state;
1571               target_terminal::ours_for_output ();
1572
1573               begin_line ();
1574               if (core_dump_allowed)
1575                 fprintf_unfiltered (gdb_stderr,
1576                                     _("%s\nAttempting to dump core.\n"),
1577                                     long_msg.c_str ());
1578               else
1579                 warn_cant_dump_core (long_msg.c_str ());
1580
1581               demangler_warning (__FILE__, __LINE__, "%s", short_msg.c_str ());
1582
1583               error_reported = 1;
1584             }
1585
1586           result = NULL;
1587         }
1588     }
1589 #endif
1590
1591   return result;
1592 }
1593
1594 /* See cp-support.h.  */
1595
1596 int
1597 gdb_sniff_from_mangled_name (const char *mangled, char **demangled)
1598 {
1599   *demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
1600   return *demangled != NULL;
1601 }
1602
1603 /* See cp-support.h.  */
1604
1605 unsigned int
1606 cp_search_name_hash (const char *search_name)
1607 {
1608   /* cp_entire_prefix_len assumes a fully-qualified name with no
1609      leading "::".  */
1610   if (startswith (search_name, "::"))
1611     search_name += 2;
1612
1613   unsigned int prefix_len = cp_entire_prefix_len (search_name);
1614   if (prefix_len != 0)
1615     search_name += prefix_len + 2;
1616
1617   unsigned int hash = 0;
1618   for (const char *string = search_name; *string != '\0'; ++string)
1619     {
1620       string = skip_spaces (string);
1621
1622       if (*string == '(')
1623         break;
1624
1625       /* Ignore ABI tags such as "[abi:cxx11].  */
1626       if (*string == '['
1627           && startswith (string + 1, "abi:")
1628           && string[5] != ':')
1629         break;
1630
1631       hash = SYMBOL_HASH_NEXT (hash, *string);
1632     }
1633   return hash;
1634 }
1635
1636 /* Helper for cp_symbol_name_matches (i.e., symbol_name_matcher_ftype
1637    implementation for symbol_name_match_type::WILD matching).  Split
1638    to a separate function for unit-testing convenience.
1639
1640    If SYMBOL_SEARCH_NAME has more scopes than LOOKUP_NAME, we try to
1641    match ignoring the extra leading scopes of SYMBOL_SEARCH_NAME.
1642    This allows conveniently setting breakpoints on functions/methods
1643    inside any namespace/class without specifying the fully-qualified
1644    name.
1645
1646    E.g., these match:
1647
1648     [symbol search name]   [lookup name]
1649     foo::bar::func         foo::bar::func
1650     foo::bar::func         bar::func
1651     foo::bar::func         func
1652
1653    While these don't:
1654
1655     [symbol search name]   [lookup name]
1656     foo::zbar::func        bar::func
1657     foo::bar::func         foo::func
1658
1659    See more examples in the test_cp_symbol_name_matches selftest
1660    function below.
1661
1662    See symbol_name_matcher_ftype for description of SYMBOL_SEARCH_NAME
1663    and COMP_MATCH_RES.
1664
1665    LOOKUP_NAME/LOOKUP_NAME_LEN is the name we're looking up.
1666
1667    See strncmp_iw_with_mode for description of MODE.
1668 */
1669
1670 static bool
1671 cp_symbol_name_matches_1 (const char *symbol_search_name,
1672                           const char *lookup_name,
1673                           size_t lookup_name_len,
1674                           strncmp_iw_mode mode,
1675                           completion_match_result *comp_match_res)
1676 {
1677   const char *sname = symbol_search_name;
1678   completion_match_for_lcd *match_for_lcd
1679     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1680
1681   while (true)
1682     {
1683       if (strncmp_iw_with_mode (sname, lookup_name, lookup_name_len,
1684                                 mode, language_cplus, match_for_lcd) == 0)
1685         {
1686           if (comp_match_res != NULL)
1687             {
1688               /* Note here we set different MATCH and MATCH_FOR_LCD
1689                  strings.  This is because with
1690
1691                   (gdb) b push_bac[TAB]
1692
1693                  we want the completion matches to list
1694
1695                   std::vector<int>::push_back(...)
1696                   std::vector<char>::push_back(...)
1697
1698                  etc., which are SYMBOL_SEARCH_NAMEs, while we want
1699                  the input line to auto-complete to
1700
1701                   (gdb) push_back(...)
1702
1703                  which is SNAME, not to
1704
1705                   (gdb) std::vector<
1706
1707                  which would be the regular common prefix between all
1708                  the matches otherwise.  */
1709               comp_match_res->set_match (symbol_search_name, sname);
1710             }
1711           return true;
1712         }
1713
1714       unsigned int len = cp_find_first_component (sname);
1715
1716       if (sname[len] == '\0')
1717         return false;
1718
1719       gdb_assert (sname[len] == ':');
1720       /* Skip the '::'.  */
1721       sname += len + 2;
1722     }
1723 }
1724
1725 /* C++ symbol_name_matcher_ftype implementation.  */
1726
1727 static bool
1728 cp_fq_symbol_name_matches (const char *symbol_search_name,
1729                            const lookup_name_info &lookup_name,
1730                            completion_match_result *comp_match_res)
1731 {
1732   /* Get the demangled name.  */
1733   const std::string &name = lookup_name.cplus ().lookup_name ();
1734   completion_match_for_lcd *match_for_lcd
1735     = (comp_match_res != NULL ? &comp_match_res->match_for_lcd : NULL);
1736   strncmp_iw_mode mode = (lookup_name.completion_mode ()
1737                           ? strncmp_iw_mode::NORMAL
1738                           : strncmp_iw_mode::MATCH_PARAMS);
1739
1740   if (strncmp_iw_with_mode (symbol_search_name,
1741                             name.c_str (), name.size (),
1742                             mode, language_cplus, match_for_lcd) == 0)
1743     {
1744       if (comp_match_res != NULL)
1745         comp_match_res->set_match (symbol_search_name);
1746       return true;
1747     }
1748
1749   return false;
1750 }
1751
1752 /* C++ symbol_name_matcher_ftype implementation for wild matches.
1753    Defers work to cp_symbol_name_matches_1.  */
1754
1755 static bool
1756 cp_symbol_name_matches (const char *symbol_search_name,
1757                         const lookup_name_info &lookup_name,
1758                         completion_match_result *comp_match_res)
1759 {
1760   /* Get the demangled name.  */
1761   const std::string &name = lookup_name.cplus ().lookup_name ();
1762
1763   strncmp_iw_mode mode = (lookup_name.completion_mode ()
1764                           ? strncmp_iw_mode::NORMAL
1765                           : strncmp_iw_mode::MATCH_PARAMS);
1766
1767   return cp_symbol_name_matches_1 (symbol_search_name,
1768                                    name.c_str (), name.size (),
1769                                    mode, comp_match_res);
1770 }
1771
1772 /* See cp-support.h.  */
1773
1774 symbol_name_matcher_ftype *
1775 cp_get_symbol_name_matcher (const lookup_name_info &lookup_name)
1776 {
1777   switch (lookup_name.match_type ())
1778     {
1779     case symbol_name_match_type::FULL:
1780     case symbol_name_match_type::EXPRESSION:
1781     case symbol_name_match_type::SEARCH_NAME:
1782       return cp_fq_symbol_name_matches;
1783     case symbol_name_match_type::WILD:
1784       return cp_symbol_name_matches;
1785     }
1786
1787   gdb_assert_not_reached ("");
1788 }
1789
1790 #if GDB_SELF_TEST
1791
1792 namespace selftests {
1793
1794 void
1795 test_cp_symbol_name_matches ()
1796 {
1797 #define CHECK_MATCH(SYMBOL, INPUT)                                      \
1798   SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL,                         \
1799                                         INPUT, sizeof (INPUT) - 1,      \
1800                                         strncmp_iw_mode::MATCH_PARAMS,  \
1801                                         NULL))
1802
1803 #define CHECK_NOT_MATCH(SYMBOL, INPUT)                                  \
1804   SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL,                        \
1805                                          INPUT, sizeof (INPUT) - 1,     \
1806                                          strncmp_iw_mode::MATCH_PARAMS, \
1807                                          NULL))
1808
1809   /* Like CHECK_MATCH, and also check that INPUT (and all substrings
1810      that start at index 0) completes to SYMBOL.  */
1811 #define CHECK_MATCH_C(SYMBOL, INPUT)                                    \
1812   do                                                                    \
1813     {                                                                   \
1814       CHECK_MATCH (SYMBOL, INPUT);                                      \
1815       for (size_t i = 0; i < sizeof (INPUT) - 1; i++)                   \
1816         SELF_CHECK (cp_symbol_name_matches_1 (SYMBOL, INPUT, i,         \
1817                                               strncmp_iw_mode::NORMAL,  \
1818                                               NULL));                   \
1819     } while (0)
1820
1821   /* Like CHECK_NOT_MATCH, and also check that INPUT does NOT complete
1822      to SYMBOL.  */
1823 #define CHECK_NOT_MATCH_C(SYMBOL, INPUT)                                \
1824   do                                                                    \
1825     {                                                                   \
1826       CHECK_NOT_MATCH (SYMBOL, INPUT);                                  \
1827       SELF_CHECK (!cp_symbol_name_matches_1 (SYMBOL, INPUT,             \
1828                                              sizeof (INPUT) - 1,        \
1829                                              strncmp_iw_mode::NORMAL,   \
1830                                              NULL));                    \
1831     } while (0)
1832
1833   /* Lookup name without parens matches all overloads.  */
1834   CHECK_MATCH_C ("function()", "function");
1835   CHECK_MATCH_C ("function(int)", "function");
1836
1837   /* Check whitespace around parameters is ignored.  */
1838   CHECK_MATCH_C ("function()", "function ()");
1839   CHECK_MATCH_C ("function ( )", "function()");
1840   CHECK_MATCH_C ("function ()", "function( )");
1841   CHECK_MATCH_C ("func(int)", "func( int )");
1842   CHECK_MATCH_C ("func(int)", "func ( int ) ");
1843   CHECK_MATCH_C ("func ( int )", "func( int )");
1844   CHECK_MATCH_C ("func ( int )", "func ( int ) ");
1845
1846   /* Check symbol name prefixes aren't incorrectly matched.  */
1847   CHECK_NOT_MATCH ("func", "function");
1848   CHECK_NOT_MATCH ("function", "func");
1849   CHECK_NOT_MATCH ("function()", "func");
1850
1851   /* Check that if the lookup name includes parameters, only the right
1852      overload matches.  */
1853   CHECK_MATCH_C ("function(int)", "function(int)");
1854   CHECK_NOT_MATCH_C ("function(int)", "function()");
1855
1856   /* Check that whitespace within symbol names is not ignored.  */
1857   CHECK_NOT_MATCH_C ("function", "func tion");
1858   CHECK_NOT_MATCH_C ("func__tion", "func_ _tion");
1859   CHECK_NOT_MATCH_C ("func11tion", "func1 1tion");
1860
1861   /* Check the converse, which can happen with template function,
1862      where the return type is part of the demangled name.  */
1863   CHECK_NOT_MATCH_C ("func tion", "function");
1864   CHECK_NOT_MATCH_C ("func1 1tion", "func11tion");
1865   CHECK_NOT_MATCH_C ("func_ _tion", "func__tion");
1866
1867   /* Within parameters too.  */
1868   CHECK_NOT_MATCH_C ("func(param)", "func(par am)");
1869
1870   /* Check handling of whitespace around C++ operators.  */
1871   CHECK_NOT_MATCH_C ("operator<<", "opera tor<<");
1872   CHECK_NOT_MATCH_C ("operator<<", "operator< <");
1873   CHECK_NOT_MATCH_C ("operator<<", "operator < <");
1874   CHECK_NOT_MATCH_C ("operator==", "operator= =");
1875   CHECK_NOT_MATCH_C ("operator==", "operator = =");
1876   CHECK_MATCH_C ("operator<<", "operator <<");
1877   CHECK_MATCH_C ("operator<<()", "operator <<");
1878   CHECK_NOT_MATCH_C ("operator<<()", "operator<<(int)");
1879   CHECK_NOT_MATCH_C ("operator<<(int)", "operator<<()");
1880   CHECK_MATCH_C ("operator==", "operator ==");
1881   CHECK_MATCH_C ("operator==()", "operator ==");
1882   CHECK_MATCH_C ("operator <<", "operator<<");
1883   CHECK_MATCH_C ("operator ==", "operator==");
1884   CHECK_MATCH_C ("operator bool", "operator  bool");
1885   CHECK_MATCH_C ("operator bool ()", "operator  bool");
1886   CHECK_MATCH_C ("operatorX<<", "operatorX < <");
1887   CHECK_MATCH_C ("Xoperator<<", "Xoperator < <");
1888
1889   CHECK_MATCH_C ("operator()(int)", "operator()(int)");
1890   CHECK_MATCH_C ("operator()(int)", "operator ( ) ( int )");
1891   CHECK_MATCH_C ("operator()<long>(int)", "operator ( ) < long > ( int )");
1892   /* The first "()" is not the parameter list.  */
1893   CHECK_NOT_MATCH ("operator()(int)", "operator");
1894
1895   /* Misc user-defined operator tests.  */
1896
1897   CHECK_NOT_MATCH_C ("operator/=()", "operator ^=");
1898   /* Same length at end of input.  */
1899   CHECK_NOT_MATCH_C ("operator>>", "operator[]");
1900   /* Same length but not at end of input.  */
1901   CHECK_NOT_MATCH_C ("operator>>()", "operator[]()");
1902
1903   CHECK_MATCH_C ("base::operator char*()", "base::operator char*()");
1904   CHECK_MATCH_C ("base::operator char*()", "base::operator char * ()");
1905   CHECK_MATCH_C ("base::operator char**()", "base::operator char * * ()");
1906   CHECK_MATCH ("base::operator char**()", "base::operator char * *");
1907   CHECK_MATCH_C ("base::operator*()", "base::operator*()");
1908   CHECK_NOT_MATCH_C ("base::operator char*()", "base::operatorc");
1909   CHECK_NOT_MATCH ("base::operator char*()", "base::operator char");
1910   CHECK_NOT_MATCH ("base::operator char*()", "base::operat");
1911
1912   /* Check handling of whitespace around C++ scope operators.  */
1913   CHECK_NOT_MATCH_C ("foo::bar", "foo: :bar");
1914   CHECK_MATCH_C ("foo::bar", "foo :: bar");
1915   CHECK_MATCH_C ("foo :: bar", "foo::bar");
1916
1917   CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi()");
1918   CHECK_MATCH_C ("abc::def::ghi ( )", "abc::def::ghi()");
1919   CHECK_MATCH_C ("abc::def::ghi()", "abc::def::ghi ( )");
1920   CHECK_MATCH_C ("function()", "function()");
1921   CHECK_MATCH_C ("bar::function()", "bar::function()");
1922
1923   /* Wild matching tests follow.  */
1924
1925   /* Tests matching symbols in some scope.  */
1926   CHECK_MATCH_C ("foo::function()", "function");
1927   CHECK_MATCH_C ("foo::function(int)", "function");
1928   CHECK_MATCH_C ("foo::bar::function()", "function");
1929   CHECK_MATCH_C ("bar::function()", "bar::function");
1930   CHECK_MATCH_C ("foo::bar::function()", "bar::function");
1931   CHECK_MATCH_C ("foo::bar::function(int)", "bar::function");
1932
1933   /* Same, with parameters in the lookup name.  */
1934   CHECK_MATCH_C ("foo::function()", "function()");
1935   CHECK_MATCH_C ("foo::bar::function()", "function()");
1936   CHECK_MATCH_C ("foo::function(int)", "function(int)");
1937   CHECK_MATCH_C ("foo::function()", "foo::function()");
1938   CHECK_MATCH_C ("foo::bar::function()", "bar::function()");
1939   CHECK_MATCH_C ("foo::bar::function(int)", "bar::function(int)");
1940   CHECK_MATCH_C ("bar::function()", "bar::function()");
1941
1942   CHECK_NOT_MATCH_C ("foo::bar::function(int)", "bar::function()");
1943
1944   CHECK_MATCH_C ("(anonymous namespace)::bar::function(int)",
1945                  "bar::function(int)");
1946   CHECK_MATCH_C ("foo::(anonymous namespace)::bar::function(int)",
1947                  "function(int)");
1948
1949   /* Lookup scope wider than symbol scope, should not match.  */
1950   CHECK_NOT_MATCH_C ("function()", "bar::function");
1951   CHECK_NOT_MATCH_C ("function()", "bar::function()");
1952
1953   /* Explicit global scope doesn't match.  */
1954   CHECK_NOT_MATCH_C ("foo::function()", "::function");
1955   CHECK_NOT_MATCH_C ("foo::function()", "::function()");
1956   CHECK_NOT_MATCH_C ("foo::function(int)", "::function()");
1957   CHECK_NOT_MATCH_C ("foo::function(int)", "::function(int)");
1958
1959   /* Test ABI tag matching/ignoring.  */
1960
1961   /* If the symbol name has an ABI tag, but the lookup name doesn't,
1962      then the ABI tag in the symbol name is ignored.  */
1963   CHECK_MATCH_C ("function[abi:foo]()", "function");
1964   CHECK_MATCH_C ("function[abi:foo](int)", "function");
1965   CHECK_MATCH_C ("function[abi:foo]()", "function ()");
1966   CHECK_NOT_MATCH_C ("function[abi:foo]()", "function (int)");
1967
1968   CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo]");
1969   CHECK_MATCH_C ("function[abi:foo](int)", "function[abi:foo]");
1970   CHECK_MATCH_C ("function[abi:foo]()", "function[abi:foo] ()");
1971   CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function");
1972   CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function");
1973   CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo]");
1974   CHECK_MATCH_C ("function[abi:foo][abi:bar](int)", "function[abi:foo]");
1975   CHECK_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] ()");
1976   CHECK_NOT_MATCH_C ("function[abi:foo][abi:bar]()", "function[abi:foo] (int)");
1977
1978   CHECK_MATCH_C ("function  [abi:foo][abi:bar] ( )", "function [abi:foo]");
1979
1980   /* If the symbol name does not have an ABI tag, while the lookup
1981      name has one, then there's no match.  */
1982   CHECK_NOT_MATCH_C ("function()", "function[abi:foo]()");
1983   CHECK_NOT_MATCH_C ("function()", "function[abi:foo]");
1984 }
1985
1986 /* If non-NULL, return STR wrapped in quotes.  Otherwise, return a
1987    "<null>" string (with no quotes).  */
1988
1989 static std::string
1990 quote (const char *str)
1991 {
1992   if (str != NULL)
1993     return std::string (1, '\"') + str + '\"';
1994   else
1995     return "<null>";
1996 }
1997
1998 /* Check that removing parameter info out of NAME produces EXPECTED.
1999    COMPLETION_MODE indicates whether we're testing normal and
2000    completion mode.  FILE and LINE are used to provide better test
2001    location information in case ithe check fails.  */
2002
2003 static void
2004 check_remove_params (const char *file, int line,
2005                       const char *name, const char *expected,
2006                       bool completion_mode)
2007 {
2008   gdb::unique_xmalloc_ptr<char> result
2009     = cp_remove_params_if_any (name, completion_mode);
2010
2011   if ((expected == NULL) != (result == NULL)
2012       || (expected != NULL
2013           && strcmp (result.get (), expected) != 0))
2014     {
2015       error (_("%s:%d: make-paramless self-test failed: (completion=%d) "
2016                "\"%s\" -> %s, expected %s"),
2017              file, line, completion_mode, name,
2018              quote (result.get ()).c_str (), quote (expected).c_str ());
2019     }
2020 }
2021
2022 /* Entry point for cp_remove_params unit tests.  */
2023
2024 static void
2025 test_cp_remove_params ()
2026 {
2027   /* Check that removing parameter info out of NAME produces EXPECTED.
2028      Checks both normal and completion modes.  */
2029 #define CHECK(NAME, EXPECTED)                                           \
2030   do                                                                    \
2031     {                                                                   \
2032       check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, false);  \
2033       check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true);   \
2034     }                                                                   \
2035   while (0)
2036
2037   /* Similar, but used when NAME is incomplete -- i.e., is has
2038      unbalanced parentheses.  In this case, looking for the exact name
2039      should fail / return empty.  */
2040 #define CHECK_INCOMPL(NAME, EXPECTED)                                   \
2041   do                                                                    \
2042     {                                                                   \
2043       check_remove_params (__FILE__, __LINE__, NAME, NULL, false);      \
2044       check_remove_params (__FILE__, __LINE__, NAME, EXPECTED, true);   \
2045     }                                                                   \
2046   while (0)
2047
2048   CHECK ("function()", "function");
2049   CHECK_INCOMPL ("function(", "function");
2050   CHECK ("function() const", "function");
2051
2052   CHECK ("(anonymous namespace)::A::B::C",
2053          "(anonymous namespace)::A::B::C");
2054
2055   CHECK ("A::(anonymous namespace)",
2056          "A::(anonymous namespace)");
2057
2058   CHECK_INCOMPL ("A::(anonymou", "A");
2059
2060   CHECK ("A::foo<int>()",
2061          "A::foo<int>");
2062
2063   CHECK_INCOMPL ("A::foo<int>(",
2064                  "A::foo<int>");
2065
2066   CHECK ("A::foo<(anonymous namespace)::B>::func(int)",
2067          "A::foo<(anonymous namespace)::B>::func");
2068
2069   CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::func(in",
2070                  "A::foo<(anonymous namespace)::B>::func");
2071
2072   CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>::",
2073                  "A::foo<(anonymous namespace)::B>");
2074
2075   CHECK_INCOMPL ("A::foo<(anonymous namespace)::B>:",
2076                  "A::foo<(anonymous namespace)::B>");
2077
2078   CHECK ("A::foo<(anonymous namespace)::B>",
2079          "A::foo<(anonymous namespace)::B>");
2080
2081   CHECK_INCOMPL ("A::foo<(anonymous namespace)::B",
2082                  "A::foo");
2083
2084   /* Shouldn't this parse?  Looks like a bug in
2085      cp_demangled_name_to_comp.  See PR c++/22411.  */
2086 #if 0
2087   CHECK ("A::foo<void(int)>::func(int)",
2088          "A::foo<void(int)>::func");
2089 #else
2090   CHECK_INCOMPL ("A::foo<void(int)>::func(int)",
2091                  "A::foo");
2092 #endif
2093
2094   CHECK_INCOMPL ("A::foo<void(int",
2095                  "A::foo");
2096
2097 #undef CHECK
2098 #undef CHECK_INCOMPL
2099 }
2100
2101 } // namespace selftests
2102
2103 #endif /* GDB_SELF_CHECK */
2104
2105 /* Don't allow just "maintenance cplus".  */
2106
2107 static  void
2108 maint_cplus_command (const char *arg, int from_tty)
2109 {
2110   printf_unfiltered (_("\"maintenance cplus\" must be followed "
2111                        "by the name of a command.\n"));
2112   help_list (maint_cplus_cmd_list,
2113              "maintenance cplus ",
2114              all_commands, gdb_stdout);
2115 }
2116
2117 /* This is a front end for cp_find_first_component, for unit testing.
2118    Be careful when using it: see the NOTE above
2119    cp_find_first_component.  */
2120
2121 static void
2122 first_component_command (const char *arg, int from_tty)
2123 {
2124   int len;
2125   char *prefix;
2126
2127   if (!arg)
2128     return;
2129
2130   len = cp_find_first_component (arg);
2131   prefix = (char *) alloca (len + 1);
2132
2133   memcpy (prefix, arg, len);
2134   prefix[len] = '\0';
2135
2136   printf_unfiltered ("%s\n", prefix);
2137 }
2138
2139 /* Implement "info vtbl".  */
2140
2141 static void
2142 info_vtbl_command (const char *arg, int from_tty)
2143 {
2144   struct value *value;
2145
2146   value = parse_and_eval (arg);
2147   cplus_print_vtable (value);
2148 }
2149
2150 void
2151 _initialize_cp_support (void)
2152 {
2153   add_prefix_cmd ("cplus", class_maintenance,
2154                   maint_cplus_command,
2155                   _("C++ maintenance commands."),
2156                   &maint_cplus_cmd_list,
2157                   "maintenance cplus ",
2158                   0, &maintenancelist);
2159   add_alias_cmd ("cp", "cplus",
2160                  class_maintenance, 1,
2161                  &maintenancelist);
2162
2163   add_cmd ("first_component",
2164            class_maintenance,
2165            first_component_command,
2166            _("Print the first class/namespace component of NAME."),
2167            &maint_cplus_cmd_list);
2168
2169   add_info ("vtbl", info_vtbl_command,
2170             _("Show the virtual function table for a C++ object.\n\
2171 Usage: info vtbl EXPRESSION\n\
2172 Evaluate EXPRESSION and display the virtual function table for the\n\
2173 resulting object."));
2174
2175 #ifdef HAVE_WORKING_FORK
2176   add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
2177                            &catch_demangler_crashes, _("\
2178 Set whether to attempt to catch demangler crashes."), _("\
2179 Show whether to attempt to catch demangler crashes."), _("\
2180 If enabled GDB will attempt to catch demangler crashes and\n\
2181 display the offending symbol."),
2182                            NULL,
2183                            NULL,
2184                            &maintenance_set_cmdlist,
2185                            &maintenance_show_cmdlist);
2186 #endif
2187
2188 #if GDB_SELF_TEST
2189   selftests::register_test ("cp_symbol_name_matches",
2190                             selftests::test_cp_symbol_name_matches);
2191   selftests::register_test ("cp_remove_params",
2192                             selftests::test_cp_remove_params);
2193 #endif
2194 }