gdb/cp-support.c

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