gdb/cp-namespace.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4
   5    Contributed by David Carlton and by Kealia, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "cp-support.h"
  24 #include "gdb_obstack.h"
  25 #include "symtab.h"
  26 #include "symfile.h"
  27 #include "gdb_assert.h"
  28 #include "block.h"
  29 #include "objfiles.h"
  30 #include "gdbtypes.h"
  31 #include "dictionary.h"
  32 #include "command.h"
  33 #include "frame.h"
  34 #include "buildsym.h"
  35 #include "language.h"
  36
  37 static struct symbol *lookup_namespace_scope (const char *name,
  38                                               const struct block *block,
  39                                               const domain_enum domain,
  40                                               const char *scope,
  41                                               int scope_len);
  42
  43 static struct symbol *lookup_symbol_file (const char *name,
  44                                           const struct block *block,
  45                                           const domain_enum domain,
  46                                           int anonymous_namespace);
  47
  48 static struct type *cp_lookup_transparent_type_loop (const char *name,
  49                                                      const char *scope,
  50                                                      int scope_len);
  51
  52 static void initialize_namespace_symtab (struct objfile *objfile);
  53
  54 static struct block *get_possible_namespace_block (struct objfile *objfile);
  55
  56 static void free_namespace_block (struct symtab *symtab);
  57
  58 static int check_possible_namespace_symbols_loop (const char *name,
  59                                                   int len,
  60                                                   struct objfile *objfile);
  61
  62 static int check_one_possible_namespace_symbol (const char *name,
  63                                                 int len,
  64                                                 struct objfile *objfile);
  65
  66 static struct symbol *lookup_possible_namespace_symbol (const char *name);
  67
  68 static void maintenance_cplus_namespace (char *args, int from_tty);
  69
  70 /* Check to see if SYMBOL refers to an object contained within an
  71    anonymous namespace; if so, add an appropriate using directive.  */
  72
  73 /* Optimize away strlen ("(anonymous namespace)").  */
  74
  75 #define ANONYMOUS_NAMESPACE_LEN 21
  76
  77 void
  78 cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
  79 {
  80   if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
  81     {
  82       const char *name = SYMBOL_DEMANGLED_NAME (symbol);
  83       unsigned int previous_component;
  84       unsigned int next_component;
  85
  86       /* Start with a quick-and-dirty check for mention of "(anonymous
  87          namespace)".  */
  88
  89       if (!cp_is_anonymous (name))
  90         return;
  91
  92       previous_component = 0;
  93       next_component = cp_find_first_component (name + previous_component);
  94
  95       while (name[next_component] == ':')
  96         {
  97           if ((next_component - previous_component) == ANONYMOUS_NAMESPACE_LEN
  98               && strncmp (name + previous_component,
  99                           "(anonymous namespace)",
 100                           ANONYMOUS_NAMESPACE_LEN) == 0)
 101             {
 102               int dest_len = (previous_component == 0
 103                               ? 0 : previous_component - 2);
 104               int src_len = next_component;
 105
 106               char *dest = alloca (dest_len + 1);
 107               char *src = alloca (src_len + 1);
 108
 109               memcpy (dest, name, dest_len);
 110               memcpy (src, name, src_len);
 111
 112               dest[dest_len] = '\0';
 113               src[src_len] = '\0';
 114
 115               /* We've found a component of the name that's an
 116                  anonymous namespace.  So add symbols in it to the
 117                  namespace given by the previous component if there is
 118                  one, or to the global namespace if there isn't.  */
 119               cp_add_using_directive (dest, src, NULL, NULL,
 120                                       &SYMBOL_SYMTAB (symbol)->objfile->objfile_obstack);
 121             }
 122           /* The "+ 2" is for the "::".  */
 123           previous_component = next_component + 2;
 124           next_component = (previous_component
 125                             + cp_find_first_component (name
 126                                                        + previous_component));
 127         }
 128     }
 129 }
 130
 131
 132 /* Add a using directive to using_directives.  If the using directive
 133    in question has already been added, don't add it twice.
 134
 135    Create a new struct using_direct which imports the namespace SRC
 136    into the scope DEST.  ALIAS is the name of the imported namespace
 137    in the current scope.  If ALIAS is NULL then the namespace is known
 138    by its original name.  DECLARATION is the name if the imported
 139    varable if this is a declaration import (Eg. using A::x), otherwise
 140    it is NULL.  The arguments are copied into newly allocated memory
 141    so they can be temporaries.  */
 142
 143 void
 144 cp_add_using_directive (const char *dest,
 145                         const char *src,
 146                         const char *alias,
 147                         const char *declaration,
 148                         struct obstack *obstack)
 149 {
 150   struct using_direct *current;
 151   struct using_direct *new;
 152
 153   /* Has it already been added?  */
 154
 155   for (current = using_directives; current != NULL; current = current->next)
 156     {
 157       if (strcmp (current->import_src, src) == 0
 158           && strcmp (current->import_dest, dest) == 0
 159           && ((alias == NULL && current->alias == NULL)
 160               || (alias != NULL && current->alias != NULL
 161                   && strcmp (alias, current->alias) == 0))
 162           && ((declaration == NULL && current->declaration == NULL)
 163               || (declaration != NULL && current->declaration != NULL
 164                   && strcmp (declaration, current->declaration) == 0)))
 165         return;
 166     }
 167
 168   new = OBSTACK_ZALLOC (obstack, struct using_direct);
 169
 170   new->import_src = obsavestring (src, strlen (src), obstack);
 171   new->import_dest = obsavestring (dest, strlen (dest), obstack);
 172
 173   if (alias != NULL)
 174     new->alias = obsavestring (alias, strlen (alias), obstack);
 175
 176   if (declaration != NULL)
 177     new->declaration = obsavestring (declaration, strlen (declaration),
 178                                      obstack);
 179
 180   new->next = using_directives;
 181   using_directives = new;
 182 }
 183
 184 /* Record the namespace that the function defined by SYMBOL was
 185    defined in, if necessary.  BLOCK is the associated block; use
 186    OBSTACK for allocation.  */
 187
 188 void
 189 cp_set_block_scope (const struct symbol *symbol,
 190                     struct block *block,
 191                     struct obstack *obstack,
 192                     const char *processing_current_prefix,
 193                     int processing_has_namespace_info)
 194 {
 195   if (processing_has_namespace_info)
 196     {
 197       block_set_scope
 198         (block, obsavestring (processing_current_prefix,
 199                               strlen (processing_current_prefix),
 200                               obstack),
 201          obstack);
 202     }
 203   else if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
 204     {
 205       /* Try to figure out the appropriate namespace from the
 206          demangled name.  */
 207
 208       /* FIXME: carlton/2003-04-15: If the function in question is
 209          a method of a class, the name will actually include the
 210          name of the class as well.  This should be harmless, but
 211          is a little unfortunate.  */
 212
 213       const char *name = SYMBOL_DEMANGLED_NAME (symbol);
 214       unsigned int prefix_len = cp_entire_prefix_len (name);
 215
 216       block_set_scope (block,
 217                        obsavestring (name, prefix_len, obstack),
 218                        obstack);
 219     }
 220 }
 221
 222 /* Test whether or not NAMESPACE looks like it mentions an anonymous
 223    namespace; return nonzero if so.  */
 224
 225 int
 226 cp_is_anonymous (const char *namespace)
 227 {
 228   return (strstr (namespace, "(anonymous namespace)")
 229           != NULL);
 230 }
 231
 232 /* The C++-specific version of name lookup for static and global
 233    names.  This makes sure that names get looked for in all namespaces
 234    that are in scope.  NAME is the natural name of the symbol that
 235    we're looking for, BLOCK is the block that we're searching within,
 236    DOMAIN says what kind of symbols we're looking for, and if SYMTAB
 237    is non-NULL, we should store the symtab where we found the symbol
 238    in it.  */
 239
 240 struct symbol *
 241 cp_lookup_symbol_nonlocal (const char *name,
 242                            const struct block *block,
 243                            const domain_enum domain)
 244 {
 245   struct symbol *sym;
 246   const char *scope = block_scope (block);
 247
 248   sym = lookup_namespace_scope (name, block,
 249                                 domain, scope, 0);
 250   if (sym != NULL)
 251     return sym;
 252
 253   return cp_lookup_symbol_namespace (scope, name,
 254                                      block, domain);
 255 }
 256
 257 /* Look up NAME in the C++ namespace NAMESPACE.  Other arguments are
 258    as in cp_lookup_symbol_nonlocal.  */
 259
 260 static struct symbol *
 261 cp_lookup_symbol_in_namespace (const char *namespace,
 262                                const char *name,
 263                                const struct block *block,
 264                                const domain_enum domain)
 265 {
 266   if (namespace[0] == '\0')
 267     {
 268       return lookup_symbol_file (name, block, domain, 0);
 269     }
 270   else
 271     {
 272       char *concatenated_name = alloca (strlen (namespace) + 2
 273                                         + strlen (name) + 1);
 274
 275       strcpy (concatenated_name, namespace);
 276       strcat (concatenated_name, "::");
 277       strcat (concatenated_name, name);
 278       return lookup_symbol_file (concatenated_name, block, domain,
 279                                  cp_is_anonymous (namespace));
 280     }
 281 }
 282
 283 /* Used for cleanups to reset the "searched" flag incase
 284    of an error.  */
 285
 286 static void
 287 reset_directive_searched (void *data)
 288 {
 289   struct using_direct *direct = data;
 290   direct->searched = 0;
 291 }
 292
 293 /* Search for NAME by applying all import statements belonging to
 294    BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
 295    search is restricted to using declarations.
 296    Example:
 297
 298      namespace A {
 299        int x;
 300      }
 301      using A::x;
 302
 303    If SEARCH_PARENTS the search will include imports which are
 304    applicable in parents of SCOPE.
 305    Example:
 306
 307      namespace A {
 308        using namespace X;
 309        namespace B {
 310          using namespace Y;
 311        }
 312      }
 313
 314    If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
 315    namespaces X and Y will be considered.  If SEARCH_PARENTS is false
 316    only the import of Y is considered.  */
 317
 318 struct symbol *
 319 cp_lookup_symbol_imports (const char *scope,
 320                           const char *name,
 321                           const struct block *block,
 322                           const domain_enum domain,
 323                           const int declaration_only,
 324                           const int search_parents)
 325 {
 326   struct using_direct *current;
 327   struct symbol *sym = NULL;
 328   int len;
 329   int directive_match;
 330   struct cleanup *searched_cleanup;
 331
 332   /* First, try to find the symbol in the given namespace.  */
 333   if (!declaration_only)
 334     sym = cp_lookup_symbol_in_namespace (scope, name,
 335                                          block, domain);
 336
 337   if (sym != NULL)
 338     return sym;
 339
 340   /* Go through the using directives.  If any of them add new names to
 341      the namespace we're searching in, see if we can find a match by
 342      applying them.  */
 343
 344   for (current = block_using (block);
 345        current != NULL;
 346        current = current->next)
 347     {
 348       len = strlen (current->import_dest);
 349       directive_match = (search_parents
 350                          ? (strncmp (scope, current->import_dest,
 351                                      strlen (current->import_dest)) == 0
 352                             && (len == 0
 353                                 || scope[len] == ':'
 354                                 || scope[len] == '\0'))
 355                          : strcmp (scope, current->import_dest) == 0);
 356
 357       /* If the import destination is the current scope or one of its
 358          ancestors then it is applicable.  */
 359       if (directive_match && !current->searched)
 360         {
 361         /* Mark this import as searched so that the recursive call
 362            does not search it again.  */
 363         current->searched = 1;
 364         searched_cleanup = make_cleanup (reset_directive_searched,
 365                                          current);
 366
 367         /* If there is an import of a single declaration, compare the
 368            imported declaration (after optional renaming by its alias)
 369            with the sought out name.  If there is a match pass
 370            current->import_src as NAMESPACE to direct the search
 371            towards the imported namespace.  */
 372         if (current->declaration
 373             && strcmp (name, current->alias
 374                        ? current->alias : current->declaration) == 0)
 375           sym = cp_lookup_symbol_in_namespace (current->import_src,
 376                                                current->declaration,
 377                                                block, domain);
 378
 379         /* If this is a DECLARATION_ONLY search or a symbol was found
 380            or this import statement was an import declaration, the
 381            search of this import is complete.  */
 382         if (declaration_only || sym != NULL || current->declaration)
 383           {
 384             current->searched = 0;
 385             discard_cleanups (searched_cleanup);
 386
 387             if (sym != NULL)
 388               return sym;
 389
 390             continue;
 391           }
 392
 393         if (current->alias != NULL
 394             && strcmp (name, current->alias) == 0)
 395           /* If the import is creating an alias and the alias matches
 396              the sought name.  Pass current->import_src as the NAME to
 397              direct the search towards the aliased namespace.  */
 398           {
 399             sym = cp_lookup_symbol_in_namespace (scope,
 400                                                  current->import_src,
 401                                                  block, domain);
 402           }
 403         else if (current->alias == NULL)
 404           {
 405             /* If this import statement creates no alias, pass
 406                current->inner as NAMESPACE to direct the search
 407                towards the imported namespace.  */
 408             sym = cp_lookup_symbol_imports (current->import_src,
 409                                             name, block,
 410                                             domain, 0, 0);
 411           }
 412         current->searched = 0;
 413         discard_cleanups (searched_cleanup);
 414
 415         if (sym != NULL)
 416           return sym;
 417         }
 418     }
 419
 420   return NULL;
 421 }
 422
 423 /* Helper function that searches an array of symbols for one named
 424    NAME.  */
 425
 426 static struct symbol *
 427 search_symbol_list (const char *name, int num,
 428                     struct symbol **syms)
 429 {
 430   int i;
 431
 432   /* Maybe we should store a dictionary in here instead.  */
 433   for (i = 0; i < num; ++i)
 434     {
 435       if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
 436         return syms[i];
 437     }
 438   return NULL;
 439 }
 440
 441 /* Like cp_lookup_symbol_imports, but if BLOCK is a function, it
 442    searches through the template parameters of the function and the
 443    function's type.  */
 444
 445 struct symbol *
 446 cp_lookup_symbol_imports_or_template (const char *scope,
 447                                       const char *name,
 448                                       const struct block *block,
 449                                       const domain_enum domain)
 450 {
 451   struct symbol *function = BLOCK_FUNCTION (block);
 452
 453   if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
 454     {
 455       int i;
 456       struct cplus_specific *cps
 457         = function->ginfo.language_specific.cplus_specific;
 458
 459       /* Search the function's template parameters.  */
 460       if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
 461         {
 462           struct template_symbol *templ
 463             = (struct template_symbol *) function;
 464           struct symbol *result;
 465
 466           result = search_symbol_list (name,
 467                                        templ->n_template_arguments,
 468                                        templ->template_arguments);
 469           if (result != NULL)
 470             return result;
 471         }
 472
 473       /* Search the template parameters of the function's defining
 474          context.  */
 475       if (SYMBOL_NATURAL_NAME (function))
 476         {
 477           struct type *context;
 478           char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
 479           struct cleanup *cleanups = make_cleanup (xfree, name_copy);
 480           const struct language_defn *lang = language_def (language_cplus);
 481           struct gdbarch *arch = SYMBOL_SYMTAB (function)->objfile->gdbarch;
 482           const struct block *parent = BLOCK_SUPERBLOCK (block);
 483
 484           while (1)
 485             {
 486               struct symbol *result;
 487               unsigned int prefix_len = cp_entire_prefix_len (name_copy);
 488
 489               if (prefix_len == 0)
 490                 context = NULL;
 491               else
 492                 {
 493                   name_copy[prefix_len] = '\0';
 494                   context = lookup_typename (lang, arch,
 495                                              name_copy,
 496                                              parent, 1);
 497                 }
 498
 499               if (context == NULL)
 500                 break;
 501
 502               result
 503                 = search_symbol_list (name,
 504                                       TYPE_N_TEMPLATE_ARGUMENTS (context),
 505                                       TYPE_TEMPLATE_ARGUMENTS (context));
 506               if (result != NULL)
 507                 return result;
 508             }
 509
 510           do_cleanups (cleanups);
 511         }
 512     }
 513
 514   return cp_lookup_symbol_imports (scope, name, block, domain, 1, 1);
 515 }
 516
 517  /* Searches for NAME in the current namespace, and by applying
 518     relevant import statements belonging to BLOCK and its parents.
 519     SCOPE is the namespace scope of the context in which the search is
 520     being evaluated.  */
 521
 522 struct symbol*
 523 cp_lookup_symbol_namespace (const char *scope,
 524                             const char *name,
 525                             const struct block *block,
 526                             const domain_enum domain)
 527 {
 528   struct symbol *sym;
 529
 530   /* First, try to find the symbol in the given namespace.  */
 531   sym = cp_lookup_symbol_in_namespace (scope, name,
 532                                        block, domain);
 533   if (sym != NULL)
 534     return sym;
 535
 536   /* Search for name in namespaces imported to this and parent
 537      blocks.  */
 538   while (block != NULL)
 539     {
 540       sym = cp_lookup_symbol_imports (scope, name, block,
 541                                       domain, 0, 1);
 542
 543       if (sym)
 544         return sym;
 545
 546       block = BLOCK_SUPERBLOCK (block);
 547     }
 548
 549   return NULL;
 550 }
 551
 552 /* Lookup NAME at namespace scope (or, in C terms, in static and
 553    global variables).  SCOPE is the namespace that the current
 554    function is defined within; only consider namespaces whose length
 555    is at least SCOPE_LEN.  Other arguments are as in
 556    cp_lookup_symbol_nonlocal.
 557
 558    For example, if we're within a function A::B::f and looking for a
 559    symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
 560    SCOPE_LEN = 0.  It then calls itself with NAME and SCOPE the same,
 561    but with SCOPE_LEN = 1.  And then it calls itself with NAME and
 562    SCOPE the same, but with SCOPE_LEN = 4.  This third call looks for
 563    "A::B::x"; if it doesn't find it, then the second call looks for
 564    "A::x", and if that call fails, then the first call looks for
 565    "x".  */
 566
 567 static struct symbol *
 568 lookup_namespace_scope (const char *name,
 569                         const struct block *block,
 570                         const domain_enum domain,
 571                         const char *scope,
 572                         int scope_len)
 573 {
 574   char *namespace;
 575
 576   if (scope[scope_len] != '\0')
 577     {
 578       /* Recursively search for names in child namespaces first.  */
 579
 580       struct symbol *sym;
 581       int new_scope_len = scope_len;
 582
 583       /* If the current scope is followed by "::", skip past that.  */
 584       if (new_scope_len != 0)
 585         {
 586           gdb_assert (scope[new_scope_len] == ':');
 587           new_scope_len += 2;
 588         }
 589       new_scope_len += cp_find_first_component (scope + new_scope_len);
 590       sym = lookup_namespace_scope (name, block, domain,
 591                                     scope, new_scope_len);
 592       if (sym != NULL)
 593         return sym;
 594     }
 595
 596   /* Okay, we didn't find a match in our children, so look for the
 597      name in the current namespace.  */
 598
 599   namespace = alloca (scope_len + 1);
 600   strncpy (namespace, scope, scope_len);
 601   namespace[scope_len] = '\0';
 602   return cp_lookup_symbol_in_namespace (namespace, name,
 603                                         block, domain);
 604 }
 605
 606 /* Look up NAME in BLOCK's static block and in global blocks.  If
 607    ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
 608    within an anonymous namespace.  Other arguments are as in
 609    cp_lookup_symbol_nonlocal.  */
 610
 611 static struct symbol *
 612 lookup_symbol_file (const char *name,
 613                     const struct block *block,
 614                     const domain_enum domain,
 615                     int anonymous_namespace)
 616 {
 617   struct symbol *sym = NULL;
 618
 619   sym = lookup_symbol_static (name, block, domain);
 620   if (sym != NULL)
 621     return sym;
 622
 623   if (anonymous_namespace)
 624     {
 625       /* Symbols defined in anonymous namespaces have external linkage
 626          but should be treated as local to a single file nonetheless.
 627          So we only search the current file's global block.  */
 628
 629       const struct block *global_block = block_global_block (block);
 630
 631       if (global_block != NULL)
 632         sym = lookup_symbol_aux_block (name, global_block, domain);
 633     }
 634   else
 635     {
 636       sym = lookup_symbol_global (name, block, domain);
 637     }
 638
 639   if (sym != NULL)
 640     return sym;
 641
 642   /* Now call "lookup_possible_namespace_symbol".  Symbols in here
 643      claim to be associated to namespaces, but this claim might be
 644      incorrect: the names in question might actually correspond to
 645      classes instead of namespaces.  But if they correspond to
 646      classes, then we should have found a match for them above.  So if
 647      we find them now, they should be genuine.  */
 648
 649   /* FIXME: carlton/2003-06-12: This is a hack and should eventually
 650      be deleted: see comments below.  */
 651
 652   if (domain == VAR_DOMAIN)
 653     {
 654       sym = lookup_possible_namespace_symbol (name);
 655       if (sym != NULL)
 656         return sym;
 657     }
 658
 659   return NULL;
 660 }
 661
 662 /* Look up a type named NESTED_NAME that is nested inside the C++
 663    class or namespace given by PARENT_TYPE, from within the context
 664    given by BLOCK.  Return NULL if there is no such nested type.  */
 665
 666 struct type *
 667 cp_lookup_nested_type (struct type *parent_type,
 668                        const char *nested_name,
 669                        const struct block *block)
 670 {
 671   switch (TYPE_CODE (parent_type))
 672     {
 673     case TYPE_CODE_STRUCT:
 674     case TYPE_CODE_NAMESPACE:
 675     case TYPE_CODE_UNION:
 676       {
 677         /* NOTE: carlton/2003-11-10: We don't treat C++ class members
 678            of classes like, say, data or function members.  Instead,
 679            they're just represented by symbols whose names are
 680            qualified by the name of the surrounding class.  This is
 681            just like members of namespaces; in particular,
 682            lookup_symbol_namespace works when looking them up.  */
 683
 684         const char *parent_name = TYPE_TAG_NAME (parent_type);
 685         struct symbol *sym
 686           = cp_lookup_symbol_in_namespace (parent_name, nested_name,
 687                                            block, VAR_DOMAIN);
 688         char *concatenated_name;
 689
 690         if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 691           return SYMBOL_TYPE (sym);
 692
 693         /* Now search all static file-level symbols.  Not strictly
 694            correct, but more useful than an error.  We do not try to
 695            guess any imported namespace as even the fully specified
 696            namespace seach is is already not C++ compliant and more
 697            assumptions could make it too magic.  */
 698
 699         concatenated_name = alloca (strlen (parent_name) + 2
 700                                     + strlen (nested_name) + 1);
 701         sprintf (concatenated_name, "%s::%s",
 702                  parent_name, nested_name);
 703         sym = lookup_static_symbol_aux (concatenated_name,
 704                                         VAR_DOMAIN);
 705         if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
 706           return SYMBOL_TYPE (sym);
 707
 708         return NULL;
 709       }
 710     default:
 711       internal_error (__FILE__, __LINE__,
 712                       _("cp_lookup_nested_type called "
 713                         "on a non-aggregate type."));
 714     }
 715 }
 716
 717 /* The C++-version of lookup_transparent_type.  */
 718
 719 /* FIXME: carlton/2004-01-16: The problem that this is trying to
 720    address is that, unfortunately, sometimes NAME is wrong: it may not
 721    include the name of namespaces enclosing the type in question.
 722    lookup_transparent_type gets called when the type in question
 723    is a declaration, and we're trying to find its definition; but, for
 724    declarations, our type name deduction mechanism doesn't work.
 725    There's nothing we can do to fix this in general, I think, in the
 726    absence of debug information about namespaces (I've filed PR
 727    gdb/1511 about this); until such debug information becomes more
 728    prevalent, one heuristic which sometimes looks is to search for the
 729    definition in namespaces containing the current namespace.
 730
 731    We should delete this functions once the appropriate debug
 732    information becomes more widespread.  (GCC 3.4 will be the first
 733    released version of GCC with such information.)  */
 734
 735 struct type *
 736 cp_lookup_transparent_type (const char *name)
 737 {
 738   /* First, try the honest way of looking up the definition.  */
 739   struct type *t = basic_lookup_transparent_type (name);
 740   const char *scope;
 741
 742   if (t != NULL)
 743     return t;
 744
 745   /* If that doesn't work and we're within a namespace, look there
 746      instead.  */
 747   scope = block_scope (get_selected_block (0));
 748
 749   if (scope[0] == '\0')
 750     return NULL;
 751
 752   return cp_lookup_transparent_type_loop (name, scope, 0);
 753 }
 754
 755 /* Lookup the type definition associated to NAME in namespaces/classes
 756    containing SCOPE whose name is strictly longer than LENGTH.  LENGTH
 757    must be the index of the start of a component of SCOPE.  */
 758
 759 static struct type *
 760 cp_lookup_transparent_type_loop (const char *name,
 761                                  const char *scope,
 762                                  int length)
 763 {
 764   int scope_length = length + cp_find_first_component (scope + length);
 765   char *full_name;
 766
 767   /* If the current scope is followed by "::", look in the next
 768      component.  */
 769   if (scope[scope_length] == ':')
 770     {
 771       struct type *retval
 772         = cp_lookup_transparent_type_loop (name, scope,
 773                                            scope_length + 2);
 774
 775       if (retval != NULL)
 776         return retval;
 777     }
 778
 779   full_name = alloca (scope_length + 2 + strlen (name) + 1);
 780   strncpy (full_name, scope, scope_length);
 781   strncpy (full_name + scope_length, "::", 2);
 782   strcpy (full_name + scope_length + 2, name);
 783
 784   return basic_lookup_transparent_type (full_name);
 785 }
 786
 787 /* Now come functions for dealing with symbols associated to
 788    namespaces.  (They're used to store the namespaces themselves, not
 789    objects that live in the namespaces.)  These symbols come in two
 790    varieties: if we run into a DW_TAG_namespace DIE, then we know that
 791    we have a namespace, so dwarf2read.c creates a symbol for it just
 792    like normal.  But, unfortunately, versions of GCC through at least
 793    3.3 don't generate those DIE's.  Our solution is to try to guess
 794    their existence by looking at demangled names.  This might cause us
 795    to misidentify classes as namespaces, however.  So we put those
 796    symbols in a special block (one per objfile), and we only search
 797    that block as a last resort.  */
 798
 799 /* FIXME: carlton/2003-06-12: Once versions of GCC that generate
 800    DW_TAG_namespace have been out for a year or two, we should get rid
 801    of all of this "possible namespace" nonsense.  */
 802
 803 /* Allocate everything necessary for the possible namespace block
 804    associated to OBJFILE.  */
 805
 806 static void
 807 initialize_namespace_symtab (struct objfile *objfile)
 808 {
 809   struct symtab *namespace_symtab;
 810   struct blockvector *bv;
 811   struct block *bl;
 812
 813   namespace_symtab = allocate_symtab ("<<C++-namespaces>>", objfile);
 814   namespace_symtab->language = language_cplus;
 815   namespace_symtab->free_code = free_nothing;
 816   namespace_symtab->dirname = NULL;
 817
 818   bv = obstack_alloc (&objfile->objfile_obstack,
 819                       sizeof (struct blockvector)
 820                       + FIRST_LOCAL_BLOCK * sizeof (struct block *));
 821   BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;
 822   BLOCKVECTOR (namespace_symtab) = bv;
 823
 824   /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK.  */
 825
 826   bl = allocate_block (&objfile->objfile_obstack);
 827   BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
 828                                         NULL);
 829   BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
 830   bl = allocate_block (&objfile->objfile_obstack);
 831   BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
 832                                         NULL);
 833   BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
 834
 835   /* Allocate the possible namespace block; we put it where the first
 836      local block will live, though I don't think there's any need to
 837      pretend that it's actually a local block (e.g. by setting
 838      BLOCK_SUPERBLOCK appropriately).  We don't use the global or
 839      static block because we don't want it searched during the normal
 840      search of all global/static blocks in lookup_symbol: we only want
 841      it used as a last resort.  */
 842
 843   /* NOTE: carlton/2003-09-11: I considered not associating the fake
 844      symbols to a block/symtab at all.  But that would cause problems
 845      with lookup_symbol's SYMTAB argument and with block_found, so
 846      having a symtab/block for this purpose seems like the best
 847      solution for now.  */
 848
 849   bl = allocate_block (&objfile->objfile_obstack);
 850   BLOCK_DICT (bl) = dict_create_hashed_expandable ();
 851   BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
 852
 853   namespace_symtab->free_func = free_namespace_block;
 854
 855   objfile->cp_namespace_symtab = namespace_symtab;
 856 }
 857
 858 /* Locate the possible namespace block associated to OBJFILE,
 859    allocating it if necessary.  */
 860
 861 static struct block *
 862 get_possible_namespace_block (struct objfile *objfile)
 863 {
 864   if (objfile->cp_namespace_symtab == NULL)
 865     initialize_namespace_symtab (objfile);
 866
 867   return BLOCKVECTOR_BLOCK (BLOCKVECTOR (objfile->cp_namespace_symtab),
 868                             FIRST_LOCAL_BLOCK);
 869 }
 870
 871 /* Free the dictionary associated to the possible namespace block.  */
 872
 873 static void
 874 free_namespace_block (struct symtab *symtab)
 875 {
 876   struct block *possible_namespace_block;
 877
 878   possible_namespace_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
 879                                                 FIRST_LOCAL_BLOCK);
 880   gdb_assert (possible_namespace_block != NULL);
 881   dict_free (BLOCK_DICT (possible_namespace_block));
 882 }
 883
 884 /* Ensure that there are symbols in the possible namespace block
 885    associated to OBJFILE for all initial substrings of NAME that look
 886    like namespaces or classes.  NAME should end in a member variable:
 887    it shouldn't consist solely of namespaces.  */
 888
 889 void
 890 cp_check_possible_namespace_symbols (const char *name,
 891                                      struct objfile *objfile)
 892 {
 893   check_possible_namespace_symbols_loop (name,
 894                                          cp_find_first_component (name),
 895                                          objfile);
 896 }
 897
 898 /* This is a helper loop for cp_check_possible_namespace_symbols; it
 899    ensures that there are symbols in the possible namespace block
 900    associated to OBJFILE for all namespaces that are initial
 901    substrings of NAME of length at least LEN.  It returns 1 if a
 902    previous loop had already created the shortest such symbol and 0
 903    otherwise.
 904
 905    This function assumes that if there is already a symbol associated
 906    to a substring of NAME of a given length, then there are already
 907    symbols associated to all substrings of NAME whose length is less
 908    than that length.  So if cp_check_possible_namespace_symbols has
 909    been called once with argument "A::B::C::member", then that will
 910    create symbols "A", "A::B", and "A::B::C".  If it is then later
 911    called with argument "A::B::D::member", then the new call will
 912    generate a new symbol for "A::B::D", but once it sees that "A::B"
 913    has already been created, it doesn't bother checking to see if "A"
 914    has also been created.  */
 915
 916 static int
 917 check_possible_namespace_symbols_loop (const char *name, int len,
 918                                        struct objfile *objfile)
 919 {
 920   if (name[len] == ':')
 921     {
 922       int done;
 923       int next_len = len + 2;
 924
 925       next_len += cp_find_first_component (name + next_len);
 926       done = check_possible_namespace_symbols_loop (name, next_len,
 927                                                     objfile);
 928
 929       if (!done)
 930         done = check_one_possible_namespace_symbol (name, len,
 931                                                     objfile);
 932
 933       return done;
 934     }
 935   else
 936     return 0;
 937 }
 938
 939 /* Check to see if there's already a possible namespace symbol in
 940    OBJFILE whose name is the initial substring of NAME of length LEN.
 941    If not, create one and return 0; otherwise, return 1.  */
 942
 943 static int
 944 check_one_possible_namespace_symbol (const char *name, int len,
 945                                      struct objfile *objfile)
 946 {
 947   struct block *block = get_possible_namespace_block (objfile);
 948   char *name_copy = alloca (len + 1);
 949   struct symbol *sym;
 950
 951   memcpy (name_copy, name, len);
 952   name_copy[len] = '\0';
 953   sym = lookup_block_symbol (block, name_copy, VAR_DOMAIN);
 954
 955   if (sym == NULL)
 956     {
 957       struct type *type;
 958
 959       type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
 960                         name_copy, objfile);
 961
 962       TYPE_TAG_NAME (type) = TYPE_NAME (type);
 963
 964       sym = obstack_alloc (&objfile->objfile_obstack,
 965                            sizeof (struct symbol));
 966       memset (sym, 0, sizeof (struct symbol));
 967       SYMBOL_SET_LANGUAGE (sym, language_cplus);
 968       /* Note that init_type copied the name to the objfile's
 969          obstack.  */
 970       SYMBOL_SET_NAMES (sym, TYPE_NAME (type), len, 0, objfile);
 971       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
 972       SYMBOL_TYPE (sym) = type;
 973       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 974
 975       dict_add_symbol (BLOCK_DICT (block), sym);
 976
 977       return 0;
 978     }
 979   else
 980     return 1;
 981 }
 982
 983 /* Look for a symbol named NAME in all the possible namespace blocks.
 984    If one is found, return it.  */
 985
 986 static struct symbol *
 987 lookup_possible_namespace_symbol (const char *name)
 988 {
 989   struct objfile *objfile;
 990
 991   ALL_OBJFILES (objfile)
 992     {
 993       struct symbol *sym;
 994
 995       sym = lookup_block_symbol (get_possible_namespace_block (objfile),
 996                                  name, VAR_DOMAIN);
 997
 998       if (sym != NULL)
 999         return sym;
1000     }
1001
1002   return NULL;
1003 }
1004
1005 /* Print out all the possible namespace symbols.  */
1006
1007 static void
1008 maintenance_cplus_namespace (char *args, int from_tty)
1009 {
1010   struct objfile *objfile;
1011
1012   printf_unfiltered (_("Possible namespaces:\n"));
1013   ALL_OBJFILES (objfile)
1014     {
1015       struct dict_iterator iter;
1016       struct symbol *sym;
1017
1018       ALL_BLOCK_SYMBOLS (get_possible_namespace_block (objfile),
1019                          iter, sym)
1020         {
1021           printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
1022         }
1023     }
1024 }
1025
1026 /* Provide a prototype to silence -Wmissing-prototypes.  */
1027 extern initialize_file_ftype _initialize_cp_namespace;
1028
1029 void
1030 _initialize_cp_namespace (void)
1031 {
1032   add_cmd ("namespace", class_maintenance,
1033            maintenance_cplus_namespace,
1034            _("Print the list of possible C++ namespaces."),
1035            &maint_cplus_cmd_list);
1036 }