gdb/cp-support.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2007 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 <ctype.h>
  23 #include "cp-support.h"
  24 #include "gdb_string.h"
  25 #include "demangle.h"
  26 #include "gdb_assert.h"
  27 #include "gdbcmd.h"
  28 #include "dictionary.h"
  29 #include "objfiles.h"
  30 #include "frame.h"
  31 #include "symtab.h"
  32 #include "block.h"
  33 #include "complaints.h"
  34 #include "gdbtypes.h"
  35
  36 #define d_left(dc) (dc)->u.s_binary.left
  37 #define d_right(dc) (dc)->u.s_binary.right
  38
  39 /* Functions related to demangled name parsing.  */
  40
  41 static unsigned int cp_find_first_component_aux (const char *name,
  42                                                  int permissive);
  43
  44 static void demangled_name_complaint (const char *name);
  45
  46 /* Functions/variables related to overload resolution.  */
  47
  48 static int sym_return_val_size;
  49 static int sym_return_val_index;
  50 static struct symbol **sym_return_val;
  51
  52 static void overload_list_add_symbol (struct symbol *sym,
  53                                       const char *oload_name);
  54
  55 static void make_symbol_overload_list_using (const char *func_name,
  56                                              const char *namespace);
  57
  58 static void make_symbol_overload_list_qualified (const char *func_name);
  59
  60 static void read_in_psymtabs (const char *oload_name);
  61
  62 /* The list of "maint cplus" commands.  */
  63
  64 struct cmd_list_element *maint_cplus_cmd_list = NULL;
  65
  66 /* The actual commands.  */
  67
  68 static void maint_cplus_command (char *arg, int from_tty);
  69 static void first_component_command (char *arg, int from_tty);
  70
  71 /* Return the canonicalized form of STRING, or NULL if STRING can not be
  72    parsed.  The return value is allocated via xmalloc.
  73
  74    drow/2005-03-07: Should we also return NULL for things that trivially do
  75    not require any change?  e.g. simple identifiers.  This could be more
  76    efficient.  */
  77
  78 char *
  79 cp_canonicalize_string (const char *string)
  80 {
  81   void *storage;
  82   struct demangle_component *ret_comp;
  83   char *ret;
  84   int len = strlen (string);
  85
  86   len = len + len / 8;
  87
  88   ret_comp = cp_demangled_name_to_comp (string, &storage, NULL);
  89   if (ret_comp == NULL)
  90     return NULL;
  91
  92   ret = cp_comp_to_string (ret_comp, len);
  93
  94   xfree (storage);
  95
  96   return ret;
  97 }
  98
  99 /* Convert a mangled name to a demangle_component tree.  *MEMORY is set to the
 100    block of used memory that should be freed when finished with the tree.
 101    DEMANGLED_P is set to the char * that should be freed when finished with
 102    the tree, or NULL if none was needed.  OPTIONS will be passed to the
 103    demangler.  */
 104
 105 static struct demangle_component *
 106 mangled_name_to_comp (const char *mangled_name, int options,
 107                       void **memory, char **demangled_p)
 108 {
 109   struct demangle_component *ret;
 110   char *demangled_name;
 111   int len;
 112
 113   /* If it looks like a v3 mangled name, then try to go directly
 114      to trees.  */
 115   if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
 116     {
 117       ret = cplus_demangle_v3_components (mangled_name, options, memory);
 118       if (ret)
 119         {
 120           *demangled_p = NULL;
 121           return ret;
 122         }
 123     }
 124
 125   /* If it doesn't, or if that failed, then try to demangle the name.  */
 126   demangled_name = cplus_demangle (mangled_name, options);
 127   if (demangled_name == NULL)
 128    return NULL;
 129
 130   /* If we could demangle the name, parse it to build the component tree.  */
 131   ret = cp_demangled_name_to_comp (demangled_name, memory, NULL);
 132
 133   if (ret == NULL)
 134     {
 135       free (demangled_name);
 136       return NULL;
 137     }
 138
 139   *demangled_p = demangled_name;
 140   return ret;
 141 }
 142
 143 /* Return the name of the class containing method PHYSNAME.  */
 144
 145 char *
 146 cp_class_name_from_physname (const char *physname)
 147 {
 148   void *storage;
 149   char *demangled_name = NULL, *ret;
 150   struct demangle_component *ret_comp, *prev_comp, *cur_comp;
 151   int done;
 152
 153   ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
 154                                    &demangled_name);
 155   if (ret_comp == NULL)
 156     return NULL;
 157
 158   done = 0;
 159
 160   /* First strip off any qualifiers, if we have a function or method.  */
 161   while (!done)
 162     switch (ret_comp->type)
 163       {
 164       case DEMANGLE_COMPONENT_CONST:
 165       case DEMANGLE_COMPONENT_RESTRICT:
 166       case DEMANGLE_COMPONENT_VOLATILE:
 167       case DEMANGLE_COMPONENT_CONST_THIS:
 168       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 169       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 170       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 171         ret_comp = d_left (ret_comp);
 172         break;
 173       default:
 174         done = 1;
 175         break;
 176       }
 177
 178   /* If what we have now is a function, discard the argument list.  */
 179   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 180     ret_comp = d_left (ret_comp);
 181
 182   /* If what we have now is a template, strip off the template
 183      arguments.  The left subtree may be a qualified name.  */
 184   if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
 185     ret_comp = d_left (ret_comp);
 186
 187   /* What we have now should be a name, possibly qualified.  Additional
 188      qualifiers could live in the left subtree or the right subtree.  Find
 189      the last piece.  */
 190   done = 0;
 191   prev_comp = NULL;
 192   cur_comp = ret_comp;
 193   while (!done)
 194     switch (cur_comp->type)
 195       {
 196       case DEMANGLE_COMPONENT_QUAL_NAME:
 197       case DEMANGLE_COMPONENT_LOCAL_NAME:
 198         prev_comp = cur_comp;
 199         cur_comp = d_right (cur_comp);
 200         break;
 201       case DEMANGLE_COMPONENT_TEMPLATE:
 202       case DEMANGLE_COMPONENT_NAME:
 203       case DEMANGLE_COMPONENT_CTOR:
 204       case DEMANGLE_COMPONENT_DTOR:
 205       case DEMANGLE_COMPONENT_OPERATOR:
 206       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 207         done = 1;
 208         break;
 209       default:
 210         done = 1;
 211         cur_comp = NULL;
 212         break;
 213       }
 214
 215   ret = NULL;
 216   if (cur_comp != NULL && prev_comp != NULL)
 217     {
 218       /* We want to discard the rightmost child of PREV_COMP.  */
 219       *prev_comp = *d_left (prev_comp);
 220       /* The ten is completely arbitrary; we don't have a good estimate.  */
 221       ret = cp_comp_to_string (ret_comp, 10);
 222     }
 223
 224   xfree (storage);
 225   if (demangled_name)
 226     xfree (demangled_name);
 227   return ret;
 228 }
 229
 230 /* Return the child of COMP which is the basename of a method, variable,
 231    et cetera.  All scope qualifiers are discarded, but template arguments
 232    will be included.  The component tree may be modified.  */
 233
 234 static struct demangle_component *
 235 unqualified_name_from_comp (struct demangle_component *comp)
 236 {
 237   struct demangle_component *ret_comp = comp, *last_template;
 238   int done;
 239
 240   done = 0;
 241   last_template = NULL;
 242   while (!done)
 243     switch (ret_comp->type)
 244       {
 245       case DEMANGLE_COMPONENT_QUAL_NAME:
 246       case DEMANGLE_COMPONENT_LOCAL_NAME:
 247         ret_comp = d_right (ret_comp);
 248         break;
 249       case DEMANGLE_COMPONENT_TYPED_NAME:
 250         ret_comp = d_left (ret_comp);
 251         break;
 252       case DEMANGLE_COMPONENT_TEMPLATE:
 253         gdb_assert (last_template == NULL);
 254         last_template = ret_comp;
 255         ret_comp = d_left (ret_comp);
 256         break;
 257       case DEMANGLE_COMPONENT_CONST:
 258       case DEMANGLE_COMPONENT_RESTRICT:
 259       case DEMANGLE_COMPONENT_VOLATILE:
 260       case DEMANGLE_COMPONENT_CONST_THIS:
 261       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 262       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 263       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 264         ret_comp = d_left (ret_comp);
 265         break;
 266       case DEMANGLE_COMPONENT_NAME:
 267       case DEMANGLE_COMPONENT_CTOR:
 268       case DEMANGLE_COMPONENT_DTOR:
 269       case DEMANGLE_COMPONENT_OPERATOR:
 270       case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
 271         done = 1;
 272         break;
 273       default:
 274         return NULL;
 275         break;
 276       }
 277
 278   if (last_template)
 279     {
 280       d_left (last_template) = ret_comp;
 281       return last_template;
 282     }
 283
 284   return ret_comp;
 285 }
 286
 287 /* Return the name of the method whose linkage name is PHYSNAME.  */
 288
 289 char *
 290 method_name_from_physname (const char *physname)
 291 {
 292   void *storage;
 293   char *demangled_name = NULL, *ret;
 294   struct demangle_component *ret_comp;
 295   int done;
 296
 297   ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
 298                                    &demangled_name);
 299   if (ret_comp == NULL)
 300     return NULL;
 301
 302   ret_comp = unqualified_name_from_comp (ret_comp);
 303
 304   ret = NULL;
 305   if (ret_comp != NULL)
 306     /* The ten is completely arbitrary; we don't have a good estimate.  */
 307     ret = cp_comp_to_string (ret_comp, 10);
 308
 309   xfree (storage);
 310   if (demangled_name)
 311     xfree (demangled_name);
 312   return ret;
 313 }
 314
 315 /* If FULL_NAME is the demangled name of a C++ function (including an
 316    arg list, possibly including namespace/class qualifications),
 317    return a new string containing only the function name (without the
 318    arg list/class qualifications).  Otherwise, return NULL.  The
 319    caller is responsible for freeing the memory in question.  */
 320
 321 char *
 322 cp_func_name (const char *full_name)
 323 {
 324   void *storage;
 325   char *ret;
 326   struct demangle_component *ret_comp;
 327   int done;
 328
 329   ret_comp = cp_demangled_name_to_comp (full_name, &storage, NULL);
 330   if (!ret_comp)
 331     return NULL;
 332
 333   ret_comp = unqualified_name_from_comp (ret_comp);
 334
 335   ret = NULL;
 336   if (ret_comp != NULL)
 337     ret = cp_comp_to_string (ret_comp, 10);
 338
 339   xfree (storage);
 340   return ret;
 341 }
 342
 343 /* DEMANGLED_NAME is the name of a function, including parameters and
 344    (optionally) a return type.  Return the name of the function without
 345    parameters or return type, or NULL if we can not parse the name.  */
 346
 347 static char *
 348 remove_params (const char *demangled_name)
 349 {
 350   int done = 0;
 351   struct demangle_component *ret_comp;
 352   void *storage;
 353   char *ret = NULL;
 354
 355   if (demangled_name == NULL)
 356     return NULL;
 357
 358   ret_comp = cp_demangled_name_to_comp (demangled_name, &storage, NULL);
 359   if (ret_comp == NULL)
 360     return NULL;
 361
 362   /* First strip off any qualifiers, if we have a function or method.  */
 363   while (!done)
 364     switch (ret_comp->type)
 365       {
 366       case DEMANGLE_COMPONENT_CONST:
 367       case DEMANGLE_COMPONENT_RESTRICT:
 368       case DEMANGLE_COMPONENT_VOLATILE:
 369       case DEMANGLE_COMPONENT_CONST_THIS:
 370       case DEMANGLE_COMPONENT_RESTRICT_THIS:
 371       case DEMANGLE_COMPONENT_VOLATILE_THIS:
 372       case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
 373         ret_comp = d_left (ret_comp);
 374         break;
 375       default:
 376         done = 1;
 377         break;
 378       }
 379
 380   /* What we have now should be a function.  Return its name.  */
 381   if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
 382     ret = cp_comp_to_string (d_left (ret_comp), 10);
 383
 384   xfree (storage);
 385   return ret;
 386 }
 387
 388 /* Here are some random pieces of trivia to keep in mind while trying
 389    to take apart demangled names:
 390
 391    - Names can contain function arguments or templates, so the process
 392      has to be, to some extent recursive: maybe keep track of your
 393      depth based on encountering <> and ().
 394
 395    - Parentheses don't just have to happen at the end of a name: they
 396      can occur even if the name in question isn't a function, because
 397      a template argument might be a type that's a function.
 398
 399    - Conversely, even if you're trying to deal with a function, its
 400      demangled name might not end with ')': it could be a const or
 401      volatile class method, in which case it ends with "const" or
 402      "volatile".
 403
 404    - Parentheses are also used in anonymous namespaces: a variable
 405      'foo' in an anonymous namespace gets demangled as "(anonymous
 406      namespace)::foo".
 407
 408    - And operator names can contain parentheses or angle brackets.  */
 409
 410 /* FIXME: carlton/2003-03-13: We have several functions here with
 411    overlapping functionality; can we combine them?  Also, do they
 412    handle all the above considerations correctly?  */
 413
 414
 415 /* This returns the length of first component of NAME, which should be
 416    the demangled name of a C++ variable/function/method/etc.
 417    Specifically, it returns the index of the first colon forming the
 418    boundary of the first component: so, given 'A::foo' or 'A::B::foo'
 419    it returns the 1, and given 'foo', it returns 0.  */
 420
 421 /* The character in NAME indexed by the return value is guaranteed to
 422    always be either ':' or '\0'.  */
 423
 424 /* NOTE: carlton/2003-03-13: This function is currently only intended
 425    for internal use: it's probably not entirely safe when called on
 426    user-generated input, because some of the 'index += 2' lines in
 427    cp_find_first_component_aux might go past the end of malformed
 428    input.  */
 429
 430 unsigned int
 431 cp_find_first_component (const char *name)
 432 {
 433   return cp_find_first_component_aux (name, 0);
 434 }
 435
 436 /* Helper function for cp_find_first_component.  Like that function,
 437    it returns the length of the first component of NAME, but to make
 438    the recursion easier, it also stops if it reaches an unexpected ')'
 439    or '>' if the value of PERMISSIVE is nonzero.  */
 440
 441 /* Let's optimize away calls to strlen("operator").  */
 442
 443 #define LENGTH_OF_OPERATOR 8
 444
 445 static unsigned int
 446 cp_find_first_component_aux (const char *name, int permissive)
 447 {
 448   unsigned int index = 0;
 449   /* Operator names can show up in unexpected places.  Since these can
 450      contain parentheses or angle brackets, they can screw up the
 451      recursion.  But not every string 'operator' is part of an
 452      operater name: e.g. you could have a variable 'cooperator'.  So
 453      this variable tells us whether or not we should treat the string
 454      'operator' as starting an operator.  */
 455   int operator_possible = 1;
 456
 457   for (;; ++index)
 458     {
 459       switch (name[index])
 460         {
 461         case '<':
 462           /* Template; eat it up.  The calls to cp_first_component
 463              should only return (I hope!) when they reach the '>'
 464              terminating the component or a '::' between two
 465              components.  (Hence the '+ 2'.)  */
 466           index += 1;
 467           for (index += cp_find_first_component_aux (name + index, 1);
 468                name[index] != '>';
 469                index += cp_find_first_component_aux (name + index, 1))
 470             {
 471               if (name[index] != ':')
 472                 {
 473                   demangled_name_complaint (name);
 474                   return strlen (name);
 475                 }
 476               index += 2;
 477             }
 478           operator_possible = 1;
 479           break;
 480         case '(':
 481           /* Similar comment as to '<'.  */
 482           index += 1;
 483           for (index += cp_find_first_component_aux (name + index, 1);
 484                name[index] != ')';
 485                index += cp_find_first_component_aux (name + index, 1))
 486             {
 487               if (name[index] != ':')
 488                 {
 489                   demangled_name_complaint (name);
 490                   return strlen (name);
 491                 }
 492               index += 2;
 493             }
 494           operator_possible = 1;
 495           break;
 496         case '>':
 497         case ')':
 498           if (permissive)
 499             return index;
 500           else
 501             {
 502               demangled_name_complaint (name);
 503               return strlen (name);
 504             }
 505         case '\0':
 506         case ':':
 507           return index;
 508         case 'o':
 509           /* Operator names can screw up the recursion.  */
 510           if (operator_possible
 511               && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
 512             {
 513               index += LENGTH_OF_OPERATOR;
 514               while (isspace(name[index]))
 515                 ++index;
 516               switch (name[index])
 517                 {
 518                   /* Skip over one less than the appropriate number of
 519                      characters: the for loop will skip over the last
 520                      one.  */
 521                 case '<':
 522                   if (name[index + 1] == '<')
 523                     index += 1;
 524                   else
 525                     index += 0;
 526                   break;
 527                 case '>':
 528                 case '-':
 529                   if (name[index + 1] == '>')
 530                     index += 1;
 531                   else
 532                     index += 0;
 533                   break;
 534                 case '(':
 535                   index += 1;
 536                   break;
 537                 default:
 538                   index += 0;
 539                   break;
 540                 }
 541             }
 542           operator_possible = 0;
 543           break;
 544         case ' ':
 545         case ',':
 546         case '.':
 547         case '&':
 548         case '*':
 549           /* NOTE: carlton/2003-04-18: I'm not sure what the precise
 550              set of relevant characters are here: it's necessary to
 551              include any character that can show up before 'operator'
 552              in a demangled name, and it's safe to include any
 553              character that can't be part of an identifier's name.  */
 554           operator_possible = 1;
 555           break;
 556         default:
 557           operator_possible = 0;
 558           break;
 559         }
 560     }
 561 }
 562
 563 /* Complain about a demangled name that we don't know how to parse.
 564    NAME is the demangled name in question.  */
 565
 566 static void
 567 demangled_name_complaint (const char *name)
 568 {
 569   complaint (&symfile_complaints,
 570              "unexpected demangled name '%s'", name);
 571 }
 572
 573 /* If NAME is the fully-qualified name of a C++
 574    function/variable/method/etc., this returns the length of its
 575    entire prefix: all of the namespaces and classes that make up its
 576    name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
 577    4, given 'foo', it returns 0.  */
 578
 579 unsigned int
 580 cp_entire_prefix_len (const char *name)
 581 {
 582   unsigned int current_len = cp_find_first_component (name);
 583   unsigned int previous_len = 0;
 584
 585   while (name[current_len] != '\0')
 586     {
 587       gdb_assert (name[current_len] == ':');
 588       previous_len = current_len;
 589       /* Skip the '::'.  */
 590       current_len += 2;
 591       current_len += cp_find_first_component (name + current_len);
 592     }
 593
 594   return previous_len;
 595 }
 596
 597 /* Overload resolution functions.  */
 598
 599 /* Test to see if SYM is a symbol that we haven't seen corresponding
 600    to a function named OLOAD_NAME.  If so, add it to the current
 601    completion list. */
 602
 603 static void
 604 overload_list_add_symbol (struct symbol *sym, const char *oload_name)
 605 {
 606   int newsize;
 607   int i;
 608   char *sym_name;
 609
 610   /* If there is no type information, we can't do anything, so skip */
 611   if (SYMBOL_TYPE (sym) == NULL)
 612     return;
 613
 614   /* skip any symbols that we've already considered. */
 615   for (i = 0; i < sym_return_val_index; ++i)
 616     if (strcmp (SYMBOL_LINKAGE_NAME (sym),
 617                 SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
 618       return;
 619
 620   /* Get the demangled name without parameters */
 621   sym_name = remove_params (SYMBOL_NATURAL_NAME (sym));
 622   if (!sym_name)
 623     return;
 624
 625   /* skip symbols that cannot match */
 626   if (strcmp (sym_name, oload_name) != 0)
 627     {
 628       xfree (sym_name);
 629       return;
 630     }
 631
 632   xfree (sym_name);
 633
 634   /* We have a match for an overload instance, so add SYM to the current list
 635    * of overload instances */
 636   if (sym_return_val_index + 3 > sym_return_val_size)
 637     {
 638       newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
 639       sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
 640     }
 641   sym_return_val[sym_return_val_index++] = sym;
 642   sym_return_val[sym_return_val_index] = NULL;
 643 }
 644
 645 /* Return a null-terminated list of pointers to function symbols that
 646    are named FUNC_NAME and are visible within NAMESPACE.  */
 647
 648 struct symbol **
 649 make_symbol_overload_list (const char *func_name,
 650                            const char *namespace)
 651 {
 652   struct cleanup *old_cleanups;
 653
 654   sym_return_val_size = 100;
 655   sym_return_val_index = 0;
 656   sym_return_val = xmalloc ((sym_return_val_size + 1) *
 657                             sizeof (struct symbol *));
 658   sym_return_val[0] = NULL;
 659
 660   old_cleanups = make_cleanup (xfree, sym_return_val);
 661
 662   make_symbol_overload_list_using (func_name, namespace);
 663
 664   discard_cleanups (old_cleanups);
 665
 666   return sym_return_val;
 667 }
 668
 669 /* This applies the using directives to add namespaces to search in,
 670    and then searches for overloads in all of those namespaces.  It
 671    adds the symbols found to sym_return_val.  Arguments are as in
 672    make_symbol_overload_list.  */
 673
 674 static void
 675 make_symbol_overload_list_using (const char *func_name,
 676                                  const char *namespace)
 677 {
 678   const struct using_direct *current;
 679
 680   /* First, go through the using directives.  If any of them apply,
 681      look in the appropriate namespaces for new functions to match
 682      on.  */
 683
 684   for (current = block_using (get_selected_block (0));
 685        current != NULL;
 686        current = current->next)
 687     {
 688       if (strcmp (namespace, current->outer) == 0)
 689         {
 690           make_symbol_overload_list_using (func_name,
 691                                            current->inner);
 692         }
 693     }
 694
 695   /* Now, add names for this namespace.  */
 696
 697   if (namespace[0] == '\0')
 698     {
 699       make_symbol_overload_list_qualified (func_name);
 700     }
 701   else
 702     {
 703       char *concatenated_name
 704         = alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
 705       strcpy (concatenated_name, namespace);
 706       strcat (concatenated_name, "::");
 707       strcat (concatenated_name, func_name);
 708       make_symbol_overload_list_qualified (concatenated_name);
 709     }
 710 }
 711
 712 /* This does the bulk of the work of finding overloaded symbols.
 713    FUNC_NAME is the name of the overloaded function we're looking for
 714    (possibly including namespace info).  */
 715
 716 static void
 717 make_symbol_overload_list_qualified (const char *func_name)
 718 {
 719   struct symbol *sym;
 720   struct symtab *s;
 721   struct objfile *objfile;
 722   const struct block *b, *surrounding_static_block = 0;
 723   struct dict_iterator iter;
 724   const struct dictionary *dict;
 725
 726   /* Look through the partial symtabs for all symbols which begin
 727      by matching FUNC_NAME.  Make sure we read that symbol table in. */
 728
 729   read_in_psymtabs (func_name);
 730
 731   /* Search upwards from currently selected frame (so that we can
 732      complete on local vars.  */
 733
 734   for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
 735     {
 736       dict = BLOCK_DICT (b);
 737
 738       for (sym = dict_iter_name_first (dict, func_name, &iter);
 739            sym;
 740            sym = dict_iter_name_next (func_name, &iter))
 741         {
 742           overload_list_add_symbol (sym, func_name);
 743         }
 744     }
 745
 746   surrounding_static_block = block_static_block (get_selected_block (0));
 747
 748   /* Go through the symtabs and check the externs and statics for
 749      symbols which match.  */
 750
 751   ALL_PRIMARY_SYMTABS (objfile, s)
 752   {
 753     QUIT;
 754     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
 755     dict = BLOCK_DICT (b);
 756
 757     for (sym = dict_iter_name_first (dict, func_name, &iter);
 758          sym;
 759          sym = dict_iter_name_next (func_name, &iter))
 760     {
 761       overload_list_add_symbol (sym, func_name);
 762     }
 763   }
 764
 765   ALL_PRIMARY_SYMTABS (objfile, s)
 766   {
 767     QUIT;
 768     b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
 769     /* Don't do this block twice.  */
 770     if (b == surrounding_static_block)
 771       continue;
 772     dict = BLOCK_DICT (b);
 773
 774     for (sym = dict_iter_name_first (dict, func_name, &iter);
 775          sym;
 776          sym = dict_iter_name_next (func_name, &iter))
 777     {
 778       overload_list_add_symbol (sym, func_name);
 779     }
 780   }
 781 }
 782
 783 /* Look through the partial symtabs for all symbols which begin
 784    by matching FUNC_NAME.  Make sure we read that symbol table in. */
 785
 786 static void
 787 read_in_psymtabs (const char *func_name)
 788 {
 789   struct partial_symtab *ps;
 790   struct objfile *objfile;
 791
 792   ALL_PSYMTABS (objfile, ps)
 793   {
 794     if (ps->readin)
 795       continue;
 796
 797     if ((lookup_partial_symbol (ps, func_name, NULL, 1, VAR_DOMAIN)
 798          != NULL)
 799         || (lookup_partial_symbol (ps, func_name, NULL, 0, VAR_DOMAIN)
 800             != NULL))
 801       psymtab_to_symtab (ps);
 802   }
 803 }
 804
 805 /* Lookup the rtti type for a class name. */
 806
 807 struct type *
 808 cp_lookup_rtti_type (const char *name, struct block *block)
 809 {
 810   struct symbol * rtti_sym;
 811   struct type * rtti_type;
 812
 813   rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL, NULL);
 814
 815   if (rtti_sym == NULL)
 816     {
 817       warning (_("RTTI symbol not found for class '%s'"), name);
 818       return NULL;
 819     }
 820
 821   if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
 822     {
 823       warning (_("RTTI symbol for class '%s' is not a type"), name);
 824       return NULL;
 825     }
 826
 827   rtti_type = SYMBOL_TYPE (rtti_sym);
 828
 829   switch (TYPE_CODE (rtti_type))
 830     {
 831     case TYPE_CODE_CLASS:
 832       break;
 833     case TYPE_CODE_NAMESPACE:
 834       /* chastain/2003-11-26: the symbol tables often contain fake
 835          symbols for namespaces with the same name as the struct.
 836          This warning is an indication of a bug in the lookup order
 837          or a bug in the way that the symbol tables are populated.  */
 838       warning (_("RTTI symbol for class '%s' is a namespace"), name);
 839       return NULL;
 840     default:
 841       warning (_("RTTI symbol for class '%s' has bad type"), name);
 842       return NULL;
 843     }
 844
 845   return rtti_type;
 846 }
 847
 848 /* Don't allow just "maintenance cplus".  */
 849
 850 static  void
 851 maint_cplus_command (char *arg, int from_tty)
 852 {
 853   printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
 854   help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
 855 }
 856
 857 /* This is a front end for cp_find_first_component, for unit testing.
 858    Be careful when using it: see the NOTE above
 859    cp_find_first_component.  */
 860
 861 static void
 862 first_component_command (char *arg, int from_tty)
 863 {
 864   int len = cp_find_first_component (arg);
 865   char *prefix = alloca (len + 1);
 866
 867   memcpy (prefix, arg, len);
 868   prefix[len] = '\0';
 869
 870   printf_unfiltered ("%s\n", prefix);
 871 }
 872
 873 extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
 874
 875 void
 876 _initialize_cp_support (void)
 877 {
 878   add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
 879                   _("C++ maintenance commands."), &maint_cplus_cmd_list,
 880                   "maintenance cplus ", 0, &maintenancelist);
 881   add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
 882
 883   add_cmd ("first_component", class_maintenance, first_component_command,
 884            _("Print the first class/namespace component of NAME."),
 885            &maint_cplus_cmd_list);
 886 }