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