gdb/cp-support.c

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