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 (char *) 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 = XNEWVEC (struct symbol *, sym_return_val_size + 1);
1196   sym_return_val[0] = NULL;
1197
1198   old_cleanups = make_cleanup (xfree, sym_return_val);
1199
1200   make_symbol_overload_list_using (func_name, the_namespace);
1201
1202   if (the_namespace[0] == '\0')
1203     name = func_name;
1204   else
1205     {
1206       char *concatenated_name
1207         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1208       strcpy (concatenated_name, the_namespace);
1209       strcat (concatenated_name, "::");
1210       strcat (concatenated_name, func_name);
1211       name = concatenated_name;
1212     }
1213
1214   make_symbol_overload_list_qualified (name);
1215
1216   discard_cleanups (old_cleanups);
1217
1218   return sym_return_val;
1219 }
1220
1221 /* Add all symbols with a name matching NAME in BLOCK to the overload
1222    list.  */
1223
1224 static void
1225 make_symbol_overload_list_block (const char *name,
1226                                  const struct block *block)
1227 {
1228   struct block_iterator iter;
1229   struct symbol *sym;
1230
1231   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
1232     overload_list_add_symbol (sym, name);
1233 }
1234
1235 /* Adds the function FUNC_NAME from NAMESPACE to the overload set.  */
1236
1237 static void
1238 make_symbol_overload_list_namespace (const char *func_name,
1239                                      const char *the_namespace)
1240 {
1241   const char *name;
1242   const struct block *block = NULL;
1243
1244   if (the_namespace[0] == '\0')
1245     name = func_name;
1246   else
1247     {
1248       char *concatenated_name
1249         = (char *) alloca (strlen (the_namespace) + 2 + strlen (func_name) + 1);
1250
1251       strcpy (concatenated_name, the_namespace);
1252       strcat (concatenated_name, "::");
1253       strcat (concatenated_name, func_name);
1254       name = concatenated_name;
1255     }
1256
1257   /* Look in the static block.  */
1258   block = block_static_block (get_selected_block (0));
1259   if (block)
1260     make_symbol_overload_list_block (name, block);
1261
1262   /* Look in the global block.  */
1263   block = block_global_block (block);
1264   if (block)
1265     make_symbol_overload_list_block (name, block);
1266
1267 }
1268
1269 /* Search the namespace of the given type and namespace of and public
1270    base types.  */
1271
1272 static void
1273 make_symbol_overload_list_adl_namespace (struct type *type,
1274                                          const char *func_name)
1275 {
1276   char *the_namespace;
1277   const char *type_name;
1278   int i, prefix_len;
1279
1280   while (TYPE_CODE (type) == TYPE_CODE_PTR
1281          || TYPE_CODE (type) == TYPE_CODE_REF
1282          || TYPE_CODE (type) == TYPE_CODE_ARRAY
1283          || TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1284     {
1285       if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
1286         type = check_typedef(type);
1287       else
1288         type = TYPE_TARGET_TYPE (type);
1289     }
1290
1291   type_name = TYPE_NAME (type);
1292
1293   if (type_name == NULL)
1294     return;
1295
1296   prefix_len = cp_entire_prefix_len (type_name);
1297
1298   if (prefix_len != 0)
1299     {
1300       the_namespace = (char *) alloca (prefix_len + 1);
1301       strncpy (the_namespace, type_name, prefix_len);
1302       the_namespace[prefix_len] = '\0';
1303
1304       make_symbol_overload_list_namespace (func_name, the_namespace);
1305     }
1306
1307   /* Check public base type */
1308   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
1309     for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
1310       {
1311         if (BASETYPE_VIA_PUBLIC (type, i))
1312           make_symbol_overload_list_adl_namespace (TYPE_BASECLASS (type,
1313                                                                    i),
1314                                                    func_name);
1315       }
1316 }
1317
1318 /* Adds the overload list overload candidates for FUNC_NAME found
1319    through argument dependent lookup.  */
1320
1321 struct symbol **
1322 make_symbol_overload_list_adl (struct type **arg_types, int nargs,
1323                                const char *func_name)
1324 {
1325   int i;
1326
1327   gdb_assert (sym_return_val_size != -1);
1328
1329   for (i = 1; i <= nargs; i++)
1330     make_symbol_overload_list_adl_namespace (arg_types[i - 1],
1331                                              func_name);
1332
1333   return sym_return_val;
1334 }
1335
1336 /* Used for cleanups to reset the "searched" flag in case of an
1337    error.  */
1338
1339 static void
1340 reset_directive_searched (void *data)
1341 {
1342   struct using_direct *direct = (struct using_direct *) data;
1343   direct->searched = 0;
1344 }
1345
1346 /* This applies the using directives to add namespaces to search in,
1347    and then searches for overloads in all of those namespaces.  It
1348    adds the symbols found to sym_return_val.  Arguments are as in
1349    make_symbol_overload_list.  */
1350
1351 static void
1352 make_symbol_overload_list_using (const char *func_name,
1353                                  const char *the_namespace)
1354 {
1355   struct using_direct *current;
1356   const struct block *block;
1357
1358   /* First, go through the using directives.  If any of them apply,
1359      look in the appropriate namespaces for new functions to match
1360      on.  */
1361
1362   for (block = get_selected_block (0);
1363        block != NULL;
1364        block = BLOCK_SUPERBLOCK (block))
1365     for (current = block_using (block);
1366         current != NULL;
1367         current = current->next)
1368       {
1369         /* Prevent recursive calls.  */
1370         if (current->searched)
1371           continue;
1372
1373         /* If this is a namespace alias or imported declaration ignore
1374            it.  */
1375         if (current->alias != NULL || current->declaration != NULL)
1376           continue;
1377
1378         if (strcmp (the_namespace, current->import_dest) == 0)
1379           {
1380             /* Mark this import as searched so that the recursive call
1381                does not search it again.  */
1382             struct cleanup *old_chain;
1383             current->searched = 1;
1384             old_chain = make_cleanup (reset_directive_searched,
1385                                       current);
1386
1387             make_symbol_overload_list_using (func_name,
1388                                              current->import_src);
1389
1390             current->searched = 0;
1391             discard_cleanups (old_chain);
1392           }
1393       }
1394
1395   /* Now, add names for this namespace.  */
1396   make_symbol_overload_list_namespace (func_name, the_namespace);
1397 }
1398
1399 /* This does the bulk of the work of finding overloaded symbols.
1400    FUNC_NAME is the name of the overloaded function we're looking for
1401    (possibly including namespace info).  */
1402
1403 static void
1404 make_symbol_overload_list_qualified (const char *func_name)
1405 {
1406   struct compunit_symtab *cust;
1407   struct objfile *objfile;
1408   const struct block *b, *surrounding_static_block = 0;
1409
1410   /* Look through the partial symtabs for all symbols which begin by
1411      matching FUNC_NAME.  Make sure we read that symbol table in.  */
1412
1413   ALL_OBJFILES (objfile)
1414   {
1415     if (objfile->sf)
1416       objfile->sf->qf->expand_symtabs_for_function (objfile, func_name);
1417   }
1418
1419   /* Search upwards from currently selected frame (so that we can
1420      complete on local vars.  */
1421
1422   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
1423     make_symbol_overload_list_block (func_name, b);
1424
1425   surrounding_static_block = block_static_block (get_selected_block (0));
1426
1427   /* Go through the symtabs and check the externs and statics for
1428      symbols which match.  */
1429
1430   ALL_COMPUNITS (objfile, cust)
1431   {
1432     QUIT;
1433     b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), GLOBAL_BLOCK);
1434     make_symbol_overload_list_block (func_name, b);
1435   }
1436
1437   ALL_COMPUNITS (objfile, cust)
1438   {
1439     QUIT;
1440     b = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
1441     /* Don't do this block twice.  */
1442     if (b == surrounding_static_block)
1443       continue;
1444     make_symbol_overload_list_block (func_name, b);
1445   }
1446 }
1447
1448 /* Lookup the rtti type for a class name.  */
1449
1450 struct type *
1451 cp_lookup_rtti_type (const char *name, struct block *block)
1452 {
1453   struct symbol * rtti_sym;
1454   struct type * rtti_type;
1455
1456   /* Use VAR_DOMAIN here as NAME may be a typedef.  PR 18141, 18417.
1457      Classes "live" in both STRUCT_DOMAIN and VAR_DOMAIN.  */
1458   rtti_sym = lookup_symbol (name, block, VAR_DOMAIN, NULL).symbol;
1459
1460   if (rtti_sym == NULL)
1461     {
1462       warning (_("RTTI symbol not found for class '%s'"), name);
1463       return NULL;
1464     }
1465
1466   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
1467     {
1468       warning (_("RTTI symbol for class '%s' is not a type"), name);
1469       return NULL;
1470     }
1471
1472   rtti_type = check_typedef (SYMBOL_TYPE (rtti_sym));
1473
1474   switch (TYPE_CODE (rtti_type))
1475     {
1476     case TYPE_CODE_STRUCT:
1477       break;
1478     case TYPE_CODE_NAMESPACE:
1479       /* chastain/2003-11-26: the symbol tables often contain fake
1480          symbols for namespaces with the same name as the struct.
1481          This warning is an indication of a bug in the lookup order
1482          or a bug in the way that the symbol tables are populated.  */
1483       warning (_("RTTI symbol for class '%s' is a namespace"), name);
1484       return NULL;
1485     default:
1486       warning (_("RTTI symbol for class '%s' has bad type"), name);
1487       return NULL;
1488     }
1489
1490   return rtti_type;
1491 }
1492
1493 #ifdef HAVE_WORKING_FORK
1494
1495 /* If nonzero, attempt to catch crashes in the demangler and print
1496    useful debugging information.  */
1497
1498 static int catch_demangler_crashes = 1;
1499
1500 /* Stack context and environment for demangler crash recovery.  */
1501
1502 static SIGJMP_BUF gdb_demangle_jmp_buf;
1503
1504 /* If nonzero, attempt to dump core from the signal handler.  */
1505
1506 static int gdb_demangle_attempt_core_dump = 1;
1507
1508 /* Signal handler for gdb_demangle.  */
1509
1510 static void
1511 gdb_demangle_signal_handler (int signo)
1512 {
1513   if (gdb_demangle_attempt_core_dump)
1514     {
1515       if (fork () == 0)
1516         dump_core ();
1517
1518       gdb_demangle_attempt_core_dump = 0;
1519     }
1520
1521   SIGLONGJMP (gdb_demangle_jmp_buf, signo);
1522 }
1523
1524 #endif
1525
1526 /* A wrapper for bfd_demangle.  */
1527
1528 char *
1529 gdb_demangle (const char *name, int options)
1530 {
1531   char *result = NULL;
1532   int crash_signal = 0;
1533
1534 #ifdef HAVE_WORKING_FORK
1535 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1536   struct sigaction sa, old_sa;
1537 #else
1538   sighandler_t ofunc;
1539 #endif
1540   static int core_dump_allowed = -1;
1541
1542   if (core_dump_allowed == -1)
1543     {
1544       core_dump_allowed = can_dump_core (LIMIT_CUR);
1545
1546       if (!core_dump_allowed)
1547         gdb_demangle_attempt_core_dump = 0;
1548     }
1549
1550   if (catch_demangler_crashes)
1551     {
1552 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1553       sa.sa_handler = gdb_demangle_signal_handler;
1554       sigemptyset (&sa.sa_mask);
1555 #ifdef HAVE_SIGALTSTACK
1556       sa.sa_flags = SA_ONSTACK;
1557 #else
1558       sa.sa_flags = 0;
1559 #endif
1560       sigaction (SIGSEGV, &sa, &old_sa);
1561 #else
1562       ofunc = signal (SIGSEGV, gdb_demangle_signal_handler);
1563 #endif
1564
1565       crash_signal = SIGSETJMP (gdb_demangle_jmp_buf);
1566     }
1567 #endif
1568
1569   if (crash_signal == 0)
1570     result = bfd_demangle (NULL, name, options);
1571
1572 #ifdef HAVE_WORKING_FORK
1573   if (catch_demangler_crashes)
1574     {
1575 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1576       sigaction (SIGSEGV, &old_sa, NULL);
1577 #else
1578       signal (SIGSEGV, ofunc);
1579 #endif
1580
1581       if (crash_signal != 0)
1582         {
1583           static int error_reported = 0;
1584
1585           if (!error_reported)
1586             {
1587               char *short_msg, *long_msg;
1588               struct cleanup *back_to;
1589
1590               short_msg = xstrprintf (_("unable to demangle '%s' "
1591                                       "(demangler failed with signal %d)"),
1592                                     name, crash_signal);
1593               back_to = make_cleanup (xfree, short_msg);
1594
1595               long_msg = xstrprintf ("%s:%d: %s: %s", __FILE__, __LINE__,
1596                                     "demangler-warning", short_msg);
1597               make_cleanup (xfree, long_msg);
1598
1599               target_terminal_ours ();
1600               begin_line ();
1601               if (core_dump_allowed)
1602                 fprintf_unfiltered (gdb_stderr,
1603                                     _("%s\nAttempting to dump core.\n"),
1604                                     long_msg);
1605               else
1606                 warn_cant_dump_core (long_msg);
1607
1608               demangler_warning (__FILE__, __LINE__, "%s", short_msg);
1609
1610               do_cleanups (back_to);
1611
1612               error_reported = 1;
1613             }
1614
1615           result = NULL;
1616         }
1617     }
1618 #endif
1619
1620   return result;
1621 }
1622
1623 /* Don't allow just "maintenance cplus".  */
1624
1625 static  void
1626 maint_cplus_command (char *arg, int from_tty)
1627 {
1628   printf_unfiltered (_("\"maintenance cplus\" must be followed "
1629                        "by the name of a command.\n"));
1630   help_list (maint_cplus_cmd_list,
1631              "maintenance cplus ",
1632              all_commands, gdb_stdout);
1633 }
1634
1635 /* This is a front end for cp_find_first_component, for unit testing.
1636    Be careful when using it: see the NOTE above
1637    cp_find_first_component.  */
1638
1639 static void
1640 first_component_command (char *arg, int from_tty)
1641 {
1642   int len;
1643   char *prefix;
1644
1645   if (!arg)
1646     return;
1647
1648   len = cp_find_first_component (arg);
1649   prefix = (char *) alloca (len + 1);
1650
1651   memcpy (prefix, arg, len);
1652   prefix[len] = '\0';
1653
1654   printf_unfiltered ("%s\n", prefix);
1655 }
1656
1657 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
1658
1659
1660 /* Implement "info vtbl".  */
1661
1662 static void
1663 info_vtbl_command (char *arg, int from_tty)
1664 {
1665   struct value *value;
1666
1667   value = parse_and_eval (arg);
1668   cplus_print_vtable (value);
1669 }
1670
1671 void
1672 _initialize_cp_support (void)
1673 {
1674   add_prefix_cmd ("cplus", class_maintenance,
1675                   maint_cplus_command,
1676                   _("C++ maintenance commands."),
1677                   &maint_cplus_cmd_list,
1678                   "maintenance cplus ",
1679                   0, &maintenancelist);
1680   add_alias_cmd ("cp", "cplus",
1681                  class_maintenance, 1,
1682                  &maintenancelist);
1683
1684   add_cmd ("first_component",
1685            class_maintenance,
1686            first_component_command,
1687            _("Print the first class/namespace component of NAME."),
1688            &maint_cplus_cmd_list);
1689
1690   add_info ("vtbl", info_vtbl_command,
1691             _("Show the virtual function table for a C++ object.\n\
1692 Usage: info vtbl EXPRESSION\n\
1693 Evaluate EXPRESSION and display the virtual function table for the\n\
1694 resulting object."));
1695
1696 #ifdef HAVE_WORKING_FORK
1697   add_setshow_boolean_cmd ("catch-demangler-crashes", class_maintenance,
1698                            &catch_demangler_crashes, _("\
1699 Set whether to attempt to catch demangler crashes."), _("\
1700 Show whether to attempt to catch demangler crashes."), _("\
1701 If enabled GDB will attempt to catch demangler crashes and\n\
1702 display the offending symbol."),
1703                            NULL,
1704                            NULL,
1705                            &maintenance_set_cmdlist,
1706                            &maintenance_show_cmdlist);
1707 #endif
1708 }