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