gdb/cp-namespace.c

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