gdb/cp-namespace.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2003-2015 Free Software Foundation, Inc.
   3
   4    Contributed by David Carlton and by Kealia, Inc.
   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 "gdb_obstack.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "block.h"
  27 #include "objfiles.h"
  28 #include "gdbtypes.h"
  29 #include "dictionary.h"
  30 #include "command.h"
  31 #include "frame.h"
  32 #include "buildsym.h"
  33 #include "language.h"
  34
  35 static struct symbol *
  36   cp_lookup_nested_symbol_1 (struct type *container_type,
  37                              const char *nested_name,
  38                              const char *concatenated_name,
  39                              const struct block *block,
  40                              int basic_lookup, int is_in_anonymous);
  41
  42 static struct type *cp_lookup_transparent_type_loop (const char *name,
  43                                                      const char *scope,
  44                                                      int scope_len);
  45
  46 /* Check to see if SYMBOL refers to an object contained within an
  47    anonymous namespace; if so, add an appropriate using directive.  */
  48
  49 void
  50 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
  51                                   struct objfile *const objfile)
  52 {
  53   if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
  54     {
  55       const char *name = SYMBOL_DEMANGLED_NAME (symbol);
  56       unsigned int previous_component;
  57       unsigned int next_component;
  58
  59       /* Start with a quick-and-dirty check for mention of "(anonymous
  60          namespace)".  */
  61
  62       if (!cp_is_in_anonymous (name))
  63         return;
  64
  65       previous_component = 0;
  66       next_component = cp_find_first_component (name + previous_component);
  67
  68       while (name[next_component] == ':')
  69         {
  70           if (((next_component - previous_component)
  71                == CP_ANONYMOUS_NAMESPACE_LEN)
  72               && strncmp (name + previous_component,
  73                           CP_ANONYMOUS_NAMESPACE_STR,
  74                           CP_ANONYMOUS_NAMESPACE_LEN) == 0)
  75             {
  76               int dest_len = (previous_component == 0
  77                               ? 0 : previous_component - 2);
  78               int src_len = next_component;
  79
  80               char *dest = alloca (dest_len + 1);
  81               char *src = alloca (src_len + 1);
  82
  83               memcpy (dest, name, dest_len);
  84               memcpy (src, name, src_len);
  85
  86               dest[dest_len] = '\0';
  87               src[src_len] = '\0';
  88
  89               /* We've found a component of the name that's an
  90                  anonymous namespace.  So add symbols in it to the
  91                  namespace given by the previous component if there is
  92                  one, or to the global namespace if there isn't.  */
  93               cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
  94                                       &objfile->objfile_obstack);
  95             }
  96           /* The "+ 2" is for the "::".  */
  97           previous_component = next_component + 2;
  98           next_component = (previous_component
  99                             + cp_find_first_component (name
 100                                                        + previous_component));
 101         }
 102     }
 103 }
 104
 105 /* Add a using directive to using_directives.  If the using directive
 106    in question has already been added, don't add it twice.
 107
 108    Create a new struct using_direct which imports the namespace SRC
 109    into the scope DEST.  ALIAS is the name of the imported namespace
 110    in the current scope.  If ALIAS is NULL then the namespace is known
 111    by its original name.  DECLARATION is the name if the imported
 112    varable if this is a declaration import (Eg. using A::x), otherwise
 113    it is NULL.  EXCLUDES is a list of names not to import from an
 114    imported module or NULL.  If COPY_NAMES is non-zero, then the
 115    arguments are copied into newly allocated memory so they can be
 116    temporaries.  For EXCLUDES the VEC pointers are copied but the
 117    pointed to characters are not copied.  */
 118
 119 void
 120 cp_add_using_directive (const char *dest,
 121                         const char *src,
 122                         const char *alias,
 123                         const char *declaration,
 124                         VEC (const_char_ptr) *excludes,
 125                         int copy_names,
 126                         struct obstack *obstack)
 127 {
 128   struct using_direct *current;
 129   struct using_direct *new;
 130
 131   /* Has it already been added?  */
 132
 133   for (current = using_directives; current != NULL; current = current->next)
 134     {
 135       int ix;
 136       const char *param;
 137
 138       if (strcmp (current->import_src, src) != 0)
 139         continue;
 140       if (strcmp (current->import_dest, dest) != 0)
 141         continue;
 142       if ((alias == NULL && current->alias != NULL)
 143           || (alias != NULL && current->alias == NULL)
 144           || (alias != NULL && current->alias != NULL
 145               && strcmp (alias, current->alias) != 0))
 146         continue;
 147       if ((declaration == NULL && current->declaration != NULL)
 148           || (declaration != NULL && current->declaration == NULL)
 149           || (declaration != NULL && current->declaration != NULL
 150               && strcmp (declaration, current->declaration) != 0))
 151         continue;
 152
 153       /* Compare the contents of EXCLUDES.  */
 154       for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
 155         if (current->excludes[ix] == NULL
 156             || strcmp (param, current->excludes[ix]) != 0)
 157           break;
 158       if (ix < VEC_length (const_char_ptr, excludes)
 159           || current->excludes[ix] != NULL)
 160         continue;
 161
 162       /* Parameters exactly match CURRENT.  */
 163       return;
 164     }
 165
 166   new = obstack_alloc (obstack, (sizeof (*new)
 167                                  + (VEC_length (const_char_ptr, excludes)
 168                                     * sizeof (*new->excludes))));
 169   memset (new, 0, sizeof (*new));
 170
 171   if (copy_names)
 172     {
 173       new->import_src = obstack_copy0 (obstack, src, strlen (src));
 174       new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
 175     }
 176   else
 177     {
 178       new->import_src = src;
 179       new->import_dest = dest;
 180     }
 181
 182   if (alias != NULL && copy_names)
 183     new->alias = obstack_copy0 (obstack, alias, strlen (alias));
 184   else
 185     new->alias = alias;
 186
 187   if (declaration != NULL && copy_names)
 188     new->declaration = obstack_copy0 (obstack,
 189                                       declaration, strlen (declaration));
 190   else
 191     new->declaration = declaration;
 192
 193   memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
 194           VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
 195   new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
 196
 197   new->next = using_directives;
 198   using_directives = new;
 199 }
 200
 201 /* Test whether or not NAMESPACE looks like it mentions an anonymous
 202    namespace; return nonzero if so.  */
 203
 204 int
 205 cp_is_in_anonymous (const char *symbol_name)
 206 {
 207   return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
 208           != NULL);
 209 }
 210
 211 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
 212    If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
 213    within an anonymous namespace.  */
 214
 215 static struct symbol *
 216 cp_basic_lookup_symbol (const char *name, const struct block *block,
 217                         const domain_enum domain, int is_in_anonymous)
 218 {
 219   struct symbol *sym;
 220
 221   sym = lookup_symbol_in_static_block (name, block, domain);
 222   if (sym != NULL)
 223     return sym;
 224
 225   if (is_in_anonymous)
 226     {
 227       /* Symbols defined in anonymous namespaces have external linkage
 228          but should be treated as local to a single file nonetheless.
 229          So we only search the current file's global block.  */
 230
 231       const struct block *global_block = block_global_block (block);
 232
 233       if (global_block != NULL)
 234         sym = lookup_symbol_in_block (name, global_block, domain);
 235     }
 236   else
 237     {
 238       sym = lookup_global_symbol (name, block, domain);
 239     }
 240
 241   return sym;
 242 }
 243
 244 /* Search bare symbol NAME in DOMAIN in BLOCK.
 245    NAME is guaranteed to not have any scope (no "::") in its name, though
 246    if for example NAME is a template spec then "::" may appear in the
 247    argument list.
 248    If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
 249    that language.  Normally we wouldn't need LANGDEF but fortran also uses
 250    this code.
 251    If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
 252    if so then also search for NAME in that class.  */
 253
 254 static struct symbol *
 255 cp_lookup_bare_symbol (const struct language_defn *langdef,
 256                        const char *name, const struct block *block,
 257                        const domain_enum domain, int search)
 258 {
 259   struct symbol *sym;
 260
 261   /* Note: We can't do a simple assert for ':' not being in NAME because
 262      ':' may be in the args of a template spec.  This isn't intended to be
 263      a complete test, just cheap and documentary.  */
 264   if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
 265     gdb_assert (strchr (name, ':') == NULL);
 266
 267   sym = lookup_symbol_in_static_block (name, block, domain);
 268   if (sym != NULL)
 269     return sym;
 270
 271   /* If we didn't find a definition for a builtin type in the static block,
 272      search for it now.  This is actually the right thing to do and can be
 273      a massive performance win.  E.g., when debugging a program with lots of
 274      shared libraries we could search all of them only to find out the
 275      builtin type isn't defined in any of them.  This is common for types
 276      like "void".  */
 277   if (langdef != NULL && domain == VAR_DOMAIN)
 278     {
 279       struct gdbarch *gdbarch;
 280
 281       if (block == NULL)
 282         gdbarch = target_gdbarch ();
 283       else
 284         gdbarch = block_gdbarch (block);
 285       sym = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
 286       if (sym != NULL)
 287         return sym;
 288     }
 289
 290   sym = lookup_global_symbol (name, block, domain);
 291   if (sym != NULL)
 292     return sym;
 293
 294   if (search)
 295     {
 296       struct symbol *this;
 297       struct type *type;
 298
 299       this = lookup_language_this (language_def (language_cplus), block);
 300       if (this == NULL)
 301         return NULL;
 302
 303       type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
 304       /* If TYPE_NAME is NULL, abandon trying to find this symbol.
 305          This can happen for lambda functions compiled with clang++,
 306          which outputs no name for the container class.  */
 307       if (TYPE_NAME (type) == NULL)
 308         return NULL;
 309
 310       /* Look for symbol NAME in this class.  */
 311       sym = cp_lookup_nested_symbol (type, name, block);
 312     }
 313
 314   return sym;
 315 }
 316
 317 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
 318    BLOCK specifies the context in which to perform the search.
 319    NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
 320    the length of the entire scope of NAME (up to, but not including, the last
 321    "::".
 322
 323    Note: At least in the case of Fortran, which also uses this code, there
 324    may be no text after the last "::".  */
 325
 326 static struct symbol *
 327 cp_search_static_and_baseclasses (const char *name,
 328                                   const struct block *block,
 329                                   const domain_enum domain,
 330                                   unsigned int prefix_len,
 331                                   int is_in_anonymous)
 332 {
 333   struct symbol *sym;
 334   char *klass, *nested;
 335   struct cleanup *cleanup;
 336   struct symbol *klass_sym;
 337   struct type *klass_type;
 338
 339   /* The test here uses <= instead of < because Fortran also uses this,
 340      and the module.exp testcase will pass "modmany::" for NAME here.  */
 341   gdb_assert (prefix_len + 2 <= strlen (name));
 342   gdb_assert (name[prefix_len + 1] == ':');
 343
 344   /* Find the name of the class and the name of the method, variable, etc.  */
 345
 346   /* The class name is everything up to and including PREFIX_LEN.  */
 347   klass = savestring (name, prefix_len);
 348
 349   /* The rest of the name is everything else past the initial scope
 350      operator.  */
 351   nested = xstrdup (name + prefix_len + 2);
 352
 353   /* Add cleanups to free memory for these strings.  */
 354   cleanup = make_cleanup (xfree, klass);
 355   make_cleanup (xfree, nested);
 356
 357   /* Lookup a class named KLASS.  If none is found, there is nothing
 358      more that can be done.  */
 359   klass_sym = lookup_global_symbol (klass, block, domain);
 360   if (klass_sym == NULL)
 361     {
 362       do_cleanups (cleanup);
 363       return NULL;
 364     }
 365   klass_type = SYMBOL_TYPE (klass_sym);
 366
 367   /* Look for a symbol named NESTED in this class.
 368      The caller is assumed to have already have done a basic lookup of NAME.
 369      So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here.  */
 370   sym = cp_lookup_nested_symbol_1 (klass_type, nested, name, block, 0,
 371                                    is_in_anonymous);
 372
 373   do_cleanups (cleanup);
 374   return sym;
 375 }
 376
 377 /* Look up NAME in the C++ namespace NAMESPACE.  Other arguments are
 378    as in cp_lookup_symbol_nonlocal.  If SEARCH is non-zero, search
 379    through base classes for a matching symbol.
 380
 381    Note: Part of the complexity is because NAME may itself specify scope.
 382    Part of the complexity is also because this handles the case where
 383    there is no scoping in which case we also try looking in the class of
 384    "this" if we can compute it.  */
 385
 386 static struct symbol *
 387 cp_lookup_symbol_in_namespace (const char *namespace, const char *name,
 388                                const struct block *block,
 389                                const domain_enum domain, int search)
 390 {
 391   char *concatenated_name = NULL;
 392   int is_in_anonymous;
 393   unsigned int prefix_len;
 394   struct symbol *sym;
 395
 396   if (namespace[0] != '\0')
 397     {
 398       concatenated_name = alloca (strlen (namespace) + 2
 399                                   + strlen (name) + 1);
 400       strcpy (concatenated_name, namespace);
 401       strcat (concatenated_name, "::");
 402       strcat (concatenated_name, name);
 403       name = concatenated_name;
 404     }
 405
 406   prefix_len = cp_entire_prefix_len (name);
 407   if (prefix_len == 0)
 408     return cp_lookup_bare_symbol (NULL, name, block, domain, search);
 409
 410   /* This would be simpler if we just called cp_lookup_nested_symbol
 411      at this point.  But that would require first looking up the containing
 412      class/namespace.  Since we're only searching static and global blocks
 413      there's often no need to first do that lookup.  */
 414
 415   is_in_anonymous = namespace[0] != '\0' && cp_is_in_anonymous (namespace);
 416   sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
 417   if (sym != NULL)
 418     return sym;
 419
 420   if (search)
 421     sym = cp_search_static_and_baseclasses (name, block, domain, prefix_len,
 422                                             is_in_anonymous);
 423
 424   return sym;
 425 }
 426
 427 /* Used for cleanups to reset the "searched" flag in case of an error.  */
 428
 429 static void
 430 reset_directive_searched (void *data)
 431 {
 432   struct using_direct *direct = data;
 433   direct->searched = 0;
 434 }
 435
 436 /* Search for NAME by applying all import statements belonging to
 437    BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
 438    search is restricted to using declarations.
 439    Example:
 440
 441      namespace A {
 442        int x;
 443      }
 444      using A::x;
 445
 446    If SEARCH_PARENTS the search will include imports which are
 447    applicable in parents of SCOPE.
 448    Example:
 449
 450      namespace A {
 451        using namespace X;
 452        namespace B {
 453          using namespace Y;
 454        }
 455      }
 456
 457    If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
 458    namespaces X and Y will be considered.  If SEARCH_PARENTS is false
 459    only the import of Y is considered.
 460
 461    SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
 462    pass 0 for it.  Internally we pass 1 when recursing.  */
 463
 464 static struct symbol *
 465 cp_lookup_symbol_via_imports (const char *scope,
 466                               const char *name,
 467                               const struct block *block,
 468                               const domain_enum domain,
 469                               const int search_scope_first,
 470                               const int declaration_only,
 471                               const int search_parents)
 472 {
 473   struct using_direct *current;
 474   struct symbol *sym = NULL;
 475   int len;
 476   int directive_match;
 477   struct cleanup *searched_cleanup;
 478
 479   /* First, try to find the symbol in the given namespace if requested.  */
 480   if (search_scope_first)
 481     sym = cp_lookup_symbol_in_namespace (scope, name,
 482                                          block, domain, 1);
 483
 484   if (sym != NULL)
 485     return sym;
 486
 487   /* Go through the using directives.  If any of them add new names to
 488      the namespace we're searching in, see if we can find a match by
 489      applying them.  */
 490
 491   for (current = block_using (block);
 492        current != NULL;
 493        current = current->next)
 494     {
 495       const char **excludep;
 496
 497       len = strlen (current->import_dest);
 498       directive_match = (search_parents
 499                          ? (strncmp (scope, current->import_dest,
 500                                      strlen (current->import_dest)) == 0
 501                             && (len == 0
 502                                 || scope[len] == ':'
 503                                 || scope[len] == '\0'))
 504                          : strcmp (scope, current->import_dest) == 0);
 505
 506       /* If the import destination is the current scope or one of its
 507          ancestors then it is applicable.  */
 508       if (directive_match && !current->searched)
 509         {
 510           /* Mark this import as searched so that the recursive call
 511              does not search it again.  */
 512           current->searched = 1;
 513           searched_cleanup = make_cleanup (reset_directive_searched,
 514                                            current);
 515
 516           /* If there is an import of a single declaration, compare the
 517              imported declaration (after optional renaming by its alias)
 518              with the sought out name.  If there is a match pass
 519              current->import_src as NAMESPACE to direct the search
 520              towards the imported namespace.  */
 521           if (current->declaration
 522               && strcmp (name, current->alias
 523                          ? current->alias : current->declaration) == 0)
 524             sym = cp_lookup_symbol_in_namespace (current->import_src,
 525                                                  current->declaration,
 526                                                  block, domain, 1);
 527
 528           /* If this is a DECLARATION_ONLY search or a symbol was found
 529              or this import statement was an import declaration, the
 530              search of this import is complete.  */
 531           if (declaration_only || sym != NULL || current->declaration)
 532             {
 533               current->searched = 0;
 534               discard_cleanups (searched_cleanup);
 535
 536               if (sym != NULL)
 537                 return sym;
 538
 539               continue;
 540             }
 541
 542           /* Do not follow CURRENT if NAME matches its EXCLUDES.  */
 543           for (excludep = current->excludes; *excludep; excludep++)
 544             if (strcmp (name, *excludep) == 0)
 545               break;
 546           if (*excludep)
 547             {
 548               discard_cleanups (searched_cleanup);
 549               continue;
 550             }
 551
 552           if (current->alias != NULL
 553               && strcmp (name, current->alias) == 0)
 554             /* If the import is creating an alias and the alias matches
 555                the sought name.  Pass current->import_src as the NAME to
 556                direct the search towards the aliased namespace.  */
 557             {
 558               sym = cp_lookup_symbol_in_namespace (scope,
 559                                                    current->import_src,
 560                                                    block, domain, 1);
 561             }
 562           else if (current->alias == NULL)
 563             {
 564               /* If this import statement creates no alias, pass
 565                  current->inner as NAMESPACE to direct the search
 566                  towards the imported namespace.  */
 567               sym = cp_lookup_symbol_via_imports (current->import_src,
 568                                                   name, block,
 569                                                   domain, 1, 0, 0);
 570             }
 571           current->searched = 0;
 572           discard_cleanups (searched_cleanup);
 573
 574           if (sym != NULL)
 575             return sym;
 576         }
 577     }
 578
 579   return NULL;
 580 }
 581
 582 /* Helper function that searches an array of symbols for one named NAME.  */
 583
 584 static struct symbol *
 585 search_symbol_list (const char *name, int num,
 586                     struct symbol **syms)
 587 {
 588   int i;
 589
 590   /* Maybe we should store a dictionary in here instead.  */
 591   for (i = 0; i < num; ++i)
 592     {
 593       if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
 594         return syms[i];
 595     }
 596   return NULL;
 597 }
 598
 599 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
 600    searches through the template parameters of the function and the
 601    function's type.  */
 602
 603 struct symbol *
 604 cp_lookup_symbol_imports_or_template (const char *scope,
 605                                       const char *name,
 606                                       const struct block *block,
 607                                       const domain_enum domain)
 608 {
 609   struct symbol *function = BLOCK_FUNCTION (block);
 610   struct symbol *result;
 611
 612   if (symbol_lookup_debug)
 613     {
 614       fprintf_unfiltered (gdb_stdlog,
 615                           "cp_lookup_symbol_imports_or_template"
 616                           " (%s, %s, %s, %s)\n",
 617                           scope, name, host_address_to_string (block),
 618                           domain_name (domain));
 619     }
 620
 621   if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
 622     {
 623       /* Search the function's template parameters.  */
 624       if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
 625         {
 626           struct template_symbol *templ
 627             = (struct template_symbol *) function;
 628
 629           result = search_symbol_list (name,
 630                                        templ->n_template_arguments,
 631                                        templ->template_arguments);
 632           if (result != NULL)
 633             {
 634               if (symbol_lookup_debug)
 635                 {
 636                   fprintf_unfiltered (gdb_stdlog,
 637                                       "cp_lookup_symbol_imports_or_template"
 638                                       " (...) = %s\n",
 639                                       host_address_to_string (result));
 640                 }
 641               return result;
 642             }
 643         }
 644
 645       /* Search the template parameters of the function's defining
 646          context.  */
 647       if (SYMBOL_NATURAL_NAME (function))
 648         {
 649           struct type *context;
 650           char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
 651           struct cleanup *cleanups = make_cleanup (xfree, name_copy);
 652           const struct language_defn *lang = language_def (language_cplus);
 653           struct gdbarch *arch = symbol_arch (function);
 654           const struct block *parent = BLOCK_SUPERBLOCK (block);
 655
 656           while (1)
 657             {
 658               unsigned int prefix_len = cp_entire_prefix_len (name_copy);
 659
 660               if (prefix_len == 0)
 661                 context = NULL;
 662               else
 663                 {
 664                   name_copy[prefix_len] = '\0';
 665                   context = lookup_typename (lang, arch,
 666                                              name_copy,
 667                                              parent, 1);
 668                 }
 669
 670               if (context == NULL)
 671                 break;
 672
 673               result
 674                 = search_symbol_list (name,
 675                                       TYPE_N_TEMPLATE_ARGUMENTS (context),
 676                                       TYPE_TEMPLATE_ARGUMENTS (context));
 677               if (result != NULL)
 678                 {
 679                   do_cleanups (cleanups);
 680                   if (symbol_lookup_debug)
 681                     {
 682                       fprintf_unfiltered (gdb_stdlog,
 683                                           "cp_lookup_symbol_imports_or_template"
 684                                           " (...) = %s\n",
 685                                           host_address_to_string (result));
 686                     }
 687                   return result;
 688                 }
 689             }
 690
 691           do_cleanups (cleanups);
 692         }
 693     }
 694
 695   result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
 696   if (symbol_lookup_debug)
 697     {
 698       fprintf_unfiltered (gdb_stdlog,
 699                           "cp_lookup_symbol_imports_or_template (...) = %s\n",
 700                           result != NULL
 701                           ? host_address_to_string (result) : "NULL");
 702     }
 703   return result;
 704 }
 705
 706 /* Search for NAME by applying relevant import statements belonging to BLOCK
 707    and its parents.  SCOPE is the namespace scope of the context in which the
 708    search is being evaluated.  */
 709
 710 static struct symbol *
 711 cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
 712                                   const struct block *block,
 713                                   const domain_enum domain)
 714 {
 715   struct symbol *sym;
 716
 717   while (block != NULL)
 718     {
 719       sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
 720       if (sym)
 721         return sym;
 722
 723       block = BLOCK_SUPERBLOCK (block);
 724     }
 725
 726   return NULL;
 727 }
 728
 729 /* Searches for NAME in the current namespace, and by applying
 730    relevant import statements belonging to BLOCK and its parents.
 731    SCOPE is the namespace scope of the context in which the search is
 732    being evaluated.  */
 733
 734 struct symbol *
 735 cp_lookup_symbol_namespace (const char *scope,
 736                             const char *name,
 737                             const struct block *block,
 738                             const domain_enum domain)
 739 {
 740   struct symbol *sym;
 741
 742   if (symbol_lookup_debug)
 743     {
 744       fprintf_unfiltered (gdb_stdlog,
 745                           "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
 746                           scope, name, host_address_to_string (block),
 747                           domain_name (domain));
 748     }
 749
 750   /* First, try to find the symbol in the given namespace.  */
 751   sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
 752
 753   /* Search for name in namespaces imported to this and parent blocks.  */
 754   if (sym == NULL)
 755     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 756
 757   if (symbol_lookup_debug)
 758     {
 759       fprintf_unfiltered (gdb_stdlog,
 760                           "cp_lookup_symbol_namespace (...) = %s\n",
 761                           sym != NULL ? host_address_to_string (sym) : "NULL");
 762     }
 763   return sym;
 764 }
 765
 766 /* Lookup NAME at namespace scope (or, in C terms, in static and
 767    global variables).  SCOPE is the namespace that the current
 768    function is defined within; only consider namespaces whose length
 769    is at least SCOPE_LEN.  Other arguments are as in
 770    cp_lookup_symbol_nonlocal.
 771
 772    For example, if we're within a function A::B::f and looking for a
 773    symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
 774    SCOPE_LEN = 0.  It then calls itself with NAME and SCOPE the same,
 775    but with SCOPE_LEN = 1.  And then it calls itself with NAME and
 776    SCOPE the same, but with SCOPE_LEN = 4.  This third call looks for
 777    "A::B::x"; if it doesn't find it, then the second call looks for
 778    "A::x", and if that call fails, then the first call looks for
 779    "x".  */
 780
 781 static struct symbol *
 782 lookup_namespace_scope (const struct language_defn *langdef,
 783                         const char *name,
 784                         const struct block *block,
 785                         const domain_enum domain,
 786                         const char *scope,
 787                         int scope_len)
 788 {
 789   char *namespace;
 790
 791   if (scope[scope_len] != '\0')
 792     {
 793       /* Recursively search for names in child namespaces first.  */
 794
 795       struct symbol *sym;
 796       int new_scope_len = scope_len;
 797
 798       /* If the current scope is followed by "::", skip past that.  */
 799       if (new_scope_len != 0)
 800         {
 801           gdb_assert (scope[new_scope_len] == ':');
 802           new_scope_len += 2;
 803         }
 804       new_scope_len += cp_find_first_component (scope + new_scope_len);
 805       sym = lookup_namespace_scope (langdef, name, block, domain,
 806                                     scope, new_scope_len);
 807       if (sym != NULL)
 808         return sym;
 809     }
 810
 811   /* Okay, we didn't find a match in our children, so look for the
 812      name in the current namespace.
 813
 814      If we there is no scope and we know we have a bare symbol, then short
 815      circuit everything and call cp_lookup_bare_symbol directly.
 816      This isn't an optimization, rather it allows us to pass LANGDEF which
 817      is needed for primitive type lookup.  The test doesn't have to be
 818      perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
 819      template symbol with "::" in the argument list) then
 820      cp_lookup_symbol_in_namespace will catch it.  */
 821
 822   if (scope_len == 0 && strchr (name, ':') == NULL)
 823     return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
 824
 825   namespace = alloca (scope_len + 1);
 826   strncpy (namespace, scope, scope_len);
 827   namespace[scope_len] = '\0';
 828   return cp_lookup_symbol_in_namespace (namespace, name,
 829                                         block, domain, 1);
 830 }
 831
 832 /* The C++-specific version of name lookup for static and global
 833    names.  This makes sure that names get looked for in all namespaces
 834    that are in scope.  NAME is the natural name of the symbol that
 835    we're looking for, BLOCK is the block that we're searching within,
 836    DOMAIN says what kind of symbols we're looking for.  */
 837
 838 struct symbol *
 839 cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
 840                            const char *name,
 841                            const struct block *block,
 842                            const domain_enum domain)
 843 {
 844   struct symbol *sym;
 845   const char *scope = block_scope (block);
 846
 847   if (symbol_lookup_debug)
 848     {
 849       fprintf_unfiltered (gdb_stdlog,
 850                           "cp_lookup_symbol_non_local"
 851                           " (%s, %s (scope %s), %s)\n",
 852                           name, host_address_to_string (block), scope,
 853                           domain_name (domain));
 854     }
 855
 856   /* First, try to find the symbol in the given namespace, and all
 857      containing namespaces.  */
 858   sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
 859
 860   /* Search for name in namespaces imported to this and parent blocks.  */
 861   if (sym == NULL)
 862     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 863
 864   if (symbol_lookup_debug)
 865     {
 866       fprintf_unfiltered (gdb_stdlog,
 867                           "cp_lookup_symbol_nonlocal (...) = %s\n",
 868                           sym != NULL ? host_address_to_string (sym) : "NULL");
 869     }
 870   return sym;
 871 }
 872
 873 /* Search through the base classes of PARENT_TYPE for a base class
 874    named NAME and return its type.  If not found, return NULL.  */
 875
 876 struct type *
 877 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
 878 {
 879   int i;
 880
 881   CHECK_TYPEDEF (parent_type);
 882   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 883     {
 884       struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
 885       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 886
 887       if (base_name == NULL)
 888         continue;
 889
 890       if (streq (base_name, name))
 891         return type;
 892
 893       type = cp_find_type_baseclass_by_name (type, name);
 894       if (type != NULL)
 895         return type;
 896     }
 897
 898   return NULL;
 899 }
 900
 901 /* Search through the base classes of PARENT_TYPE for a symbol named
 902    NAME in block BLOCK.  */
 903
 904 static struct symbol *
 905 find_symbol_in_baseclass (struct type *parent_type, const char *name,
 906                           const struct block *block, int is_in_anonymous)
 907 {
 908   int i;
 909   struct symbol *sym;
 910   struct cleanup *cleanup;
 911   char *concatenated_name;
 912
 913   sym = NULL;
 914   concatenated_name = NULL;
 915   cleanup = make_cleanup (free_current_contents, &concatenated_name);
 916
 917   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 918     {
 919       size_t len;
 920       struct type *base_type = TYPE_BASECLASS (parent_type, i);
 921       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 922
 923       if (base_name == NULL)
 924         continue;
 925
 926       len = strlen (base_name) + 2 + strlen (name) + 1;
 927       concatenated_name = xrealloc (concatenated_name, len);
 928       xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
 929
 930       sym = cp_lookup_nested_symbol_1 (base_type, name, concatenated_name,
 931                                        block, 1, is_in_anonymous);
 932       if (sym != NULL)
 933         break;
 934     }
 935
 936   do_cleanups (cleanup);
 937   return sym;
 938 }
 939
 940 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE within the
 941    context of BLOCK.
 942    NESTED_NAME may have scope ("::").
 943    CONTAINER_TYPE needn't have been "check_typedef'd" yet.
 944    CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
 945    passed as an argument so that callers can control how space for it is
 946    allocated.
 947    If BASIC_LOOKUP is non-zero then perform a basic lookup of
 948    CONCATENATED_NAME.  See cp_basic_lookup_symbol for details.
 949    If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
 950    namespace.  */
 951
 952 static struct symbol *
 953 cp_lookup_nested_symbol_1 (struct type *container_type,
 954                            const char *nested_name,
 955                            const char *concatenated_name,
 956                            const struct block *block,
 957                            int basic_lookup, int is_in_anonymous)
 958 {
 959   struct symbol *sym;
 960
 961   /* NOTE: carlton/2003-11-10: We don't treat C++ class members
 962      of classes like, say, data or function members.  Instead,
 963      they're just represented by symbols whose names are
 964      qualified by the name of the surrounding class.  This is
 965      just like members of namespaces; in particular,
 966      cp_basic_lookup_symbol works when looking them up.  */
 967
 968   if (basic_lookup)
 969     {
 970       sym = cp_basic_lookup_symbol (concatenated_name, block, VAR_DOMAIN,
 971                                     is_in_anonymous);
 972       if (sym != NULL)
 973         return sym;
 974     }
 975
 976   /* Now search all static file-level symbols.  We have to do this for things
 977      like typedefs in the class.  We do not try to guess any imported
 978      namespace as even the fully specified namespace search is already not
 979      C++ compliant and more assumptions could make it too magic.  */
 980
 981   /* First search in this symtab, what we want is possibly there.  */
 982   sym = lookup_symbol_in_static_block (concatenated_name, block, VAR_DOMAIN);
 983   if (sym != NULL)
 984     return sym;
 985
 986   /* Nope.  We now have to search all static blocks in all objfiles,
 987      even if block != NULL, because there's no guarantees as to which
 988      symtab the symbol we want is in.  Except for symbols defined in
 989      anonymous namespaces should be treated as local to a single file,
 990      which we just searched.  */
 991   if (!is_in_anonymous)
 992     {
 993       sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
 994       if (sym != NULL)
 995         return sym;
 996     }
 997
 998   /* If this is a class with baseclasses, search them next.  */
 999   CHECK_TYPEDEF (container_type);
1000   if (TYPE_N_BASECLASSES (container_type) > 0)
1001     {
1002       sym = find_symbol_in_baseclass (container_type, nested_name, block,
1003                                       is_in_anonymous);
1004       if (sym != NULL)
1005         return sym;
1006     }
1007
1008   return NULL;
1009 }
1010
1011 /* Look up a symbol named NESTED_NAME that is nested inside the C++
1012    class or namespace given by PARENT_TYPE, from within the context
1013    given by BLOCK.  Return NULL if there is no such nested symbol.  */
1014
1015 struct symbol *
1016 cp_lookup_nested_symbol (struct type *parent_type,
1017                          const char *nested_name,
1018                          const struct block *block)
1019 {
1020   /* type_name_no_tag_or_error provides better error reporting using the
1021      original type.  */
1022   struct type *saved_parent_type = parent_type;
1023
1024   CHECK_TYPEDEF (parent_type);
1025
1026   if (symbol_lookup_debug)
1027     {
1028       const char *type_name = type_name_no_tag (saved_parent_type);
1029
1030       fprintf_unfiltered (gdb_stdlog,
1031                           "cp_lookup_nested_symbol (%s, %s, %s)\n",
1032                           type_name != NULL ? type_name : "unnamed",
1033                           nested_name, host_address_to_string (block));
1034     }
1035
1036   switch (TYPE_CODE (parent_type))
1037     {
1038     case TYPE_CODE_STRUCT:
1039     case TYPE_CODE_NAMESPACE:
1040     case TYPE_CODE_UNION:
1041     case TYPE_CODE_ENUM:
1042     /* NOTE: Handle modules here as well, because Fortran is re-using the C++
1043        specific code to lookup nested symbols in modules, by calling the
1044        function pointer la_lookup_symbol_nonlocal, which ends up here.  */
1045     case TYPE_CODE_MODULE:
1046       {
1047         int size;
1048         const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
1049         struct symbol *sym;
1050         char *concatenated_name;
1051         int is_in_anonymous;
1052
1053         size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
1054         concatenated_name = alloca (size);
1055         xsnprintf (concatenated_name, size, "%s::%s",
1056                    parent_name, nested_name);
1057         is_in_anonymous = cp_is_in_anonymous (concatenated_name);
1058
1059         sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
1060                                          concatenated_name, block, 1,
1061                                          is_in_anonymous);
1062
1063         if (symbol_lookup_debug)
1064           {
1065             fprintf_unfiltered (gdb_stdlog,
1066                                 "cp_lookup_nested_symbol (...) = %s\n",
1067                                 sym != NULL
1068                                 ? host_address_to_string (sym) : "NULL");
1069           }
1070         return sym;
1071       }
1072
1073     case TYPE_CODE_FUNC:
1074     case TYPE_CODE_METHOD:
1075       if (symbol_lookup_debug)
1076         {
1077           fprintf_unfiltered (gdb_stdlog,
1078                               "cp_lookup_nested_symbol (...) = NULL"
1079                               " (func/method)\n");
1080         }
1081       return NULL;
1082
1083     default:
1084       internal_error (__FILE__, __LINE__,
1085                       _("cp_lookup_nested_symbol called "
1086                         "on a non-aggregate type."));
1087     }
1088 }
1089
1090 /* The C++-version of lookup_transparent_type.  */
1091
1092 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1093    address is that, unfortunately, sometimes NAME is wrong: it may not
1094    include the name of namespaces enclosing the type in question.
1095    lookup_transparent_type gets called when the type in question
1096    is a declaration, and we're trying to find its definition; but, for
1097    declarations, our type name deduction mechanism doesn't work.
1098    There's nothing we can do to fix this in general, I think, in the
1099    absence of debug information about namespaces (I've filed PR
1100    gdb/1511 about this); until such debug information becomes more
1101    prevalent, one heuristic which sometimes looks is to search for the
1102    definition in namespaces containing the current namespace.
1103
1104    We should delete this functions once the appropriate debug
1105    information becomes more widespread.  (GCC 3.4 will be the first
1106    released version of GCC with such information.)  */
1107
1108 struct type *
1109 cp_lookup_transparent_type (const char *name)
1110 {
1111   /* First, try the honest way of looking up the definition.  */
1112   struct type *t = basic_lookup_transparent_type (name);
1113   const char *scope;
1114
1115   if (t != NULL)
1116     return t;
1117
1118   /* If that doesn't work and we're within a namespace, look there
1119      instead.  */
1120   scope = block_scope (get_selected_block (0));
1121
1122   if (scope[0] == '\0')
1123     return NULL;
1124
1125   return cp_lookup_transparent_type_loop (name, scope, 0);
1126 }
1127
1128 /* Lookup the type definition associated to NAME in namespaces/classes
1129    containing SCOPE whose name is strictly longer than LENGTH.  LENGTH
1130    must be the index of the start of a component of SCOPE.  */
1131
1132 static struct type *
1133 cp_lookup_transparent_type_loop (const char *name,
1134                                  const char *scope,
1135                                  int length)
1136 {
1137   int scope_length = length + cp_find_first_component (scope + length);
1138   char *full_name;
1139
1140   /* If the current scope is followed by "::", look in the next
1141      component.  */
1142   if (scope[scope_length] == ':')
1143     {
1144       struct type *retval
1145         = cp_lookup_transparent_type_loop (name, scope,
1146                                            scope_length + 2);
1147
1148       if (retval != NULL)
1149         return retval;
1150     }
1151
1152   full_name = alloca (scope_length + 2 + strlen (name) + 1);
1153   strncpy (full_name, scope, scope_length);
1154   strncpy (full_name + scope_length, "::", 2);
1155   strcpy (full_name + scope_length + 2, name);
1156
1157   return basic_lookup_transparent_type (full_name);
1158 }
1159
1160 /* This used to do something but was removed when it became
1161    obsolete.  */
1162
1163 static void
1164 maintenance_cplus_namespace (char *args, int from_tty)
1165 {
1166   printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1167 }
1168
1169 /* Provide a prototype to silence -Wmissing-prototypes.  */
1170 extern initialize_file_ftype _initialize_cp_namespace;
1171
1172 void
1173 _initialize_cp_namespace (void)
1174 {
1175   struct cmd_list_element *cmd;
1176
1177   cmd = add_cmd ("namespace", class_maintenance,
1178                  maintenance_cplus_namespace,
1179                  _("Deprecated placeholder for removed functionality."),
1180                  &maint_cplus_cmd_list);
1181   deprecate_cmd (cmd, NULL);
1182 }