1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC 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, or (at your option)
13 GCC 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.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
31 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
37 /* The bindings for a particular name in a particular scope. */
39 struct scope_binding {
43 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
45 static cxx_scope *innermost_nonclass_level (void);
46 static cxx_binding *binding_for_name (cxx_scope *, tree);
47 static tree push_overloaded_decl (tree, int, bool);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
54 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
56 /* The :: namespace. */
58 tree global_namespace;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name;
64 /* Initialize anonymous_namespace_name if necessary, and return it. */
67 get_anonymous_namespace_name (void)
69 if (!anonymous_namespace_name)
71 /* The anonymous namespace has to have a unique name
72 if typeinfo objects are being compared by name. */
73 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
74 anonymous_namespace_name = get_file_function_name ("N");
76 /* The demangler expects anonymous namespaces to be called
77 something starting with '_GLOBAL__N_'. */
78 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
80 return anonymous_namespace_name;
83 /* Compute the chain index of a binding_entry given the HASH value of its
84 name and the total COUNT of chains. COUNT is assumed to be a power
87 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
89 /* A free list of "binding_entry"s awaiting for re-use. */
91 static GTY((deletable)) binding_entry free_binding_entry = NULL;
93 /* Create a binding_entry object for (NAME, TYPE). */
95 static inline binding_entry
96 binding_entry_make (tree name, tree type)
100 if (free_binding_entry)
102 entry = free_binding_entry;
103 free_binding_entry = entry->chain;
106 entry = ggc_alloc_binding_entry_s ();
115 /* Put ENTRY back on the free list. */
118 binding_entry_free (binding_entry entry)
122 entry->chain = free_binding_entry;
123 free_binding_entry = entry;
127 /* The datatype used to implement the mapping from names to types at
129 struct GTY(()) binding_table_s {
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = ggc_alloc_binding_table_s ();
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = ggc_alloc_cxx_binding ();
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 if (VEC_length (cp_class_binding, scope->class_shadowed))
324 cp_class_binding *old_base;
325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
328 /* Fixup the current bindings, as they might have moved. */
331 FOR_EACH_VEC_ELT (cp_class_binding, scope->class_shadowed, i, cb)
334 b = &IDENTIFIER_BINDING (cb->identifier);
335 while (*b != &old_base[i].base)
336 b = &((*b)->previous);
340 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
343 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
345 cb->identifier = name;
347 binding->scope = scope;
348 cxx_binding_init (binding, value, type);
352 /* Make DECL the innermost binding for ID. The LEVEL is the binding
353 level at which this declaration is being bound. */
356 push_binding (tree id, tree decl, cxx_scope* level)
358 cxx_binding *binding;
360 if (level != class_binding_level)
362 binding = cxx_binding_make (decl, NULL_TREE);
363 binding->scope = level;
366 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
368 /* Now, fill in the binding information. */
369 binding->previous = IDENTIFIER_BINDING (id);
370 INHERITED_VALUE_BINDING_P (binding) = 0;
371 LOCAL_BINDING_P (binding) = (level != class_binding_level);
373 /* And put it on the front of the list of bindings for ID. */
374 IDENTIFIER_BINDING (id) = binding;
377 /* Remove the binding for DECL which should be the innermost binding
381 pop_binding (tree id, tree decl)
383 cxx_binding *binding;
386 /* It's easiest to write the loops that call this function without
387 checking whether or not the entities involved have names. We
388 get here for such an entity. */
391 /* Get the innermost binding for ID. */
392 binding = IDENTIFIER_BINDING (id);
394 /* The name should be bound. */
395 gcc_assert (binding != NULL);
397 /* The DECL will be either the ordinary binding or the type
398 binding for this identifier. Remove that binding. */
399 if (binding->value == decl)
400 binding->value = NULL_TREE;
403 gcc_assert (binding->type == decl);
404 binding->type = NULL_TREE;
407 if (!binding->value && !binding->type)
409 /* We're completely done with the innermost binding for this
410 identifier. Unhook it from the list of bindings. */
411 IDENTIFIER_BINDING (id) = binding->previous;
413 /* Add it to the free list. */
414 cxx_binding_free (binding);
418 /* BINDING records an existing declaration for a name in the current scope.
419 But, DECL is another declaration for that same identifier in the
420 same scope. This is the `struct stat' hack whereby a non-typedef
421 class name or enum-name can be bound at the same level as some other
425 A class name (9.1) or enumeration name (7.2) can be hidden by the
426 name of an object, function, or enumerator declared in the same scope.
427 If a class or enumeration name and an object, function, or enumerator
428 are declared in the same scope (in any order) with the same name, the
429 class or enumeration name is hidden wherever the object, function, or
430 enumerator name is visible.
432 It's the responsibility of the caller to check that
433 inserting this name is valid here. Returns nonzero if the new binding
437 supplement_binding (cxx_binding *binding, tree decl)
439 tree bval = binding->value;
442 timevar_push (TV_NAME_LOOKUP);
443 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
444 /* The new name is the type name. */
445 binding->type = decl;
446 else if (/* BVAL is null when push_class_level_binding moves an
447 inherited type-binding out of the way to make room for a
448 new value binding. */
450 /* BVAL is error_mark_node when DECL's name has been used
451 in a non-class scope prior declaration. In that case,
452 we should have already issued a diagnostic; for graceful
453 error recovery purpose, pretend this was the intended
454 declaration for that name. */
455 || bval == error_mark_node
456 /* If BVAL is anticipated but has not yet been declared,
457 pretend it is not there at all. */
458 || (TREE_CODE (bval) == FUNCTION_DECL
459 && DECL_ANTICIPATED (bval)
460 && !DECL_HIDDEN_FRIEND_P (bval)))
461 binding->value = decl;
462 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
464 /* The old binding was a type name. It was placed in
465 VALUE field because it was thought, at the point it was
466 declared, to be the only entity with such a name. Move the
467 type name into the type slot; it is now hidden by the new
469 binding->type = bval;
470 binding->value = decl;
471 binding->value_is_inherited = false;
473 else if (TREE_CODE (bval) == TYPE_DECL
474 && TREE_CODE (decl) == TYPE_DECL
475 && DECL_NAME (decl) == DECL_NAME (bval)
476 && binding->scope->kind != sk_class
477 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
478 /* If either type involves template parameters, we must
479 wait until instantiation. */
480 || uses_template_parms (TREE_TYPE (decl))
481 || uses_template_parms (TREE_TYPE (bval))))
482 /* We have two typedef-names, both naming the same type to have
483 the same name. In general, this is OK because of:
487 In a given scope, a typedef specifier can be used to redefine
488 the name of any type declared in that scope to refer to the
489 type to which it already refers.
491 However, in class scopes, this rule does not apply due to the
492 stricter language in [class.mem] prohibiting redeclarations of
495 /* There can be two block-scope declarations of the same variable,
496 so long as they are `extern' declarations. However, there cannot
497 be two declarations of the same static data member:
501 A member shall not be declared twice in the
502 member-specification. */
503 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
504 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
505 && !DECL_CLASS_SCOPE_P (decl))
507 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
510 else if (TREE_CODE (decl) == NAMESPACE_DECL
511 && TREE_CODE (bval) == NAMESPACE_DECL
512 && DECL_NAMESPACE_ALIAS (decl)
513 && DECL_NAMESPACE_ALIAS (bval)
514 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
517 In a declarative region, a namespace-alias-definition can be
518 used to redefine a namespace-alias declared in that declarative
519 region to refer only to the namespace to which it already
524 error ("declaration of %q#D", decl);
525 error ("conflicts with previous declaration %q+#D", bval);
529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
532 /* Add DECL to the list of things declared in B. */
535 add_decl_to_level (tree decl, cxx_scope *b)
537 /* We used to record virtual tables as if they were ordinary
538 variables, but no longer do so. */
539 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
541 if (TREE_CODE (decl) == NAMESPACE_DECL
542 && !DECL_NAMESPACE_ALIAS (decl))
544 DECL_CHAIN (decl) = b->namespaces;
545 b->namespaces = decl;
549 /* We build up the list in reverse order, and reverse it later if
551 TREE_CHAIN (decl) = b->names;
555 /* If appropriate, add decl to separate list of statics. We
556 include extern variables because they might turn out to be
557 static later. It's OK for this list to contain a few false
559 if (b->kind == sk_namespace)
560 if ((TREE_CODE (decl) == VAR_DECL
561 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
562 || (TREE_CODE (decl) == FUNCTION_DECL
563 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
564 VEC_safe_push (tree, gc, b->static_decls, decl);
568 /* Record a decl-node X as belonging to the current lexical scope.
569 Check for errors (such as an incompatible declaration for the same
570 name already seen in the same scope). IS_FRIEND is true if X is
571 declared as a friend.
573 Returns either X or an old decl for the same name.
574 If an old decl is returned, it may have been smashed
575 to agree with what X says. */
578 pushdecl_maybe_friend (tree x, bool is_friend)
582 int need_new_binding;
584 timevar_push (TV_NAME_LOOKUP);
586 if (x == error_mark_node)
587 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
589 need_new_binding = 1;
591 if (DECL_TEMPLATE_PARM_P (x))
592 /* Template parameters have no context; they are not X::T even
593 when declared within a class or namespace. */
597 if (current_function_decl && x != current_function_decl
598 /* A local declaration for a function doesn't constitute
600 && TREE_CODE (x) != FUNCTION_DECL
601 /* A local declaration for an `extern' variable is in the
602 scope of the current namespace, not the current
604 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
605 /* When parsing the parameter list of a function declarator,
606 don't set DECL_CONTEXT to an enclosing function. When we
607 push the PARM_DECLs in order to process the function body,
608 current_binding_level->this_entity will be set. */
609 && !(TREE_CODE (x) == PARM_DECL
610 && current_binding_level->kind == sk_function_parms
611 && current_binding_level->this_entity == NULL)
612 && !DECL_CONTEXT (x))
613 DECL_CONTEXT (x) = current_function_decl;
615 /* If this is the declaration for a namespace-scope function,
616 but the declaration itself is in a local scope, mark the
618 if (TREE_CODE (x) == FUNCTION_DECL
619 && DECL_NAMESPACE_SCOPE_P (x)
620 && current_function_decl
621 && x != current_function_decl)
622 DECL_LOCAL_FUNCTION_P (x) = 1;
625 name = DECL_NAME (x);
628 int different_binding_level = 0;
630 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
631 name = TREE_OPERAND (name, 0);
633 /* In case this decl was explicitly namespace-qualified, look it
634 up in its namespace context. */
635 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
636 t = namespace_binding (name, DECL_CONTEXT (x));
638 t = lookup_name_innermost_nonclass_level (name);
640 /* [basic.link] If there is a visible declaration of an entity
641 with linkage having the same name and type, ignoring entities
642 declared outside the innermost enclosing namespace scope, the
643 block scope declaration declares that same entity and
644 receives the linkage of the previous declaration. */
645 if (! t && current_function_decl && x != current_function_decl
646 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
647 && DECL_EXTERNAL (x))
649 /* Look in block scope. */
650 t = innermost_non_namespace_value (name);
651 /* Or in the innermost namespace. */
653 t = namespace_binding (name, DECL_CONTEXT (x));
654 /* Does it have linkage? Note that if this isn't a DECL, it's an
655 OVERLOAD, which is OK. */
656 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
659 different_binding_level = 1;
662 /* If we are declaring a function, and the result of name-lookup
663 was an OVERLOAD, look for an overloaded instance that is
664 actually the same as the function we are declaring. (If
665 there is one, we have to merge our declaration with the
666 previous declaration.) */
667 if (t && TREE_CODE (t) == OVERLOAD)
671 if (TREE_CODE (x) == FUNCTION_DECL)
672 for (match = t; match; match = OVL_NEXT (match))
674 if (decls_match (OVL_CURRENT (match), x))
678 /* Just choose one. */
682 t = OVL_CURRENT (match);
687 if (t && t != error_mark_node)
689 if (different_binding_level)
691 if (decls_match (x, t))
692 /* The standard only says that the local extern
693 inherits linkage from the previous decl; in
694 particular, default args are not shared. Add
695 the decl into a hash table to make sure only
696 the previous decl in this case is seen by the
699 struct cxx_int_tree_map *h;
702 TREE_PUBLIC (x) = TREE_PUBLIC (t);
704 if (cp_function_chain->extern_decl_map == NULL)
705 cp_function_chain->extern_decl_map
706 = htab_create_ggc (20, cxx_int_tree_map_hash,
707 cxx_int_tree_map_eq, NULL);
709 h = ggc_alloc_cxx_int_tree_map ();
710 h->uid = DECL_UID (x);
712 loc = htab_find_slot_with_hash
713 (cp_function_chain->extern_decl_map, h,
715 *(struct cxx_int_tree_map **) loc = h;
718 else if (TREE_CODE (t) == PARM_DECL)
720 /* Check for duplicate params. */
721 tree d = duplicate_decls (x, t, is_friend);
723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
725 else if ((DECL_EXTERN_C_FUNCTION_P (x)
726 || DECL_FUNCTION_TEMPLATE_P (x))
727 && is_overloaded_fn (t))
728 /* Don't do anything just yet. */;
729 else if (t == wchar_decl_node)
731 if (! DECL_IN_SYSTEM_HEADER (x))
732 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
735 /* Throw away the redeclaration. */
736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
740 tree olddecl = duplicate_decls (x, t, is_friend);
742 /* If the redeclaration failed, we can stop at this
744 if (olddecl == error_mark_node)
745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
749 if (TREE_CODE (t) == TYPE_DECL)
750 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
752 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
754 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
756 /* A redeclaration of main, but not a duplicate of the
761 This function shall not be overloaded. */
762 error ("invalid redeclaration of %q+D", t);
764 /* We don't try to push this declaration since that
766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
771 /* If x has C linkage-specification, (extern "C"),
772 lookup its binding, in case it's already bound to an object.
773 The lookup is done in all namespaces.
774 If we find an existing binding, make sure it has the same
775 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
776 if ((TREE_CODE (x) == FUNCTION_DECL)
777 && DECL_EXTERN_C_P (x)
778 /* We should ignore declarations happening in system headers. */
779 && !DECL_ARTIFICIAL (x)
780 && !DECL_IN_SYSTEM_HEADER (x))
782 cxx_binding *function_binding =
783 lookup_extern_c_fun_binding_in_all_ns (x);
784 tree previous = (function_binding
785 ? function_binding->value
788 && !DECL_ARTIFICIAL (previous)
789 && !DECL_IN_SYSTEM_HEADER (previous)
790 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
792 tree previous = function_binding->value;
794 /* In case either x or previous is declared to throw an exception,
795 make sure both exception specifications are equal. */
796 if (decls_match (x, previous))
798 tree x_exception_spec = NULL_TREE;
799 tree previous_exception_spec = NULL_TREE;
802 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
803 previous_exception_spec =
804 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
805 if (!comp_except_specs (previous_exception_spec,
809 pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
811 pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
813 pedwarn (input_location, 0, "due to different exception specifications");
814 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
819 pedwarn (input_location, 0,
820 "declaration of %q#D with C language linkage", x);
821 pedwarn (input_location, 0,
822 "conflicts with previous declaration %q+#D",
828 check_template_shadow (x);
830 /* If this is a function conjured up by the back end, massage it
831 so it looks friendly. */
832 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
834 retrofit_lang_decl (x);
835 SET_DECL_LANGUAGE (x, lang_c);
839 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
841 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
842 if (!namespace_bindings_p ())
843 /* We do not need to create a binding for this name;
844 push_overloaded_decl will have already done so if
846 need_new_binding = 0;
848 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
850 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
852 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
855 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
856 check_default_args (t);
858 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
859 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
861 /* If declaring a type as a typedef, copy the type (unless we're
862 at line 0), and install this TYPE_DECL as the new type's typedef
863 name. See the extensive comment of set_underlying_type (). */
864 if (TREE_CODE (x) == TYPE_DECL)
866 tree type = TREE_TYPE (x);
868 if (DECL_IS_BUILTIN (x)
869 || (TREE_TYPE (x) != error_mark_node
870 && TYPE_NAME (type) != x
871 /* We don't want to copy the type when all we're
872 doing is making a TYPE_DECL for the purposes of
874 && (!TYPE_NAME (type)
875 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
876 set_underlying_type (x);
878 if (type != error_mark_node
880 && TYPE_IDENTIFIER (type))
881 set_identifier_type_value (DECL_NAME (x), x);
884 /* Multiple external decls of the same identifier ought to match.
886 We get warnings about inline functions where they are defined.
887 We get warnings about other functions from push_overloaded_decl.
889 Avoid duplicate warnings where they are used. */
890 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
894 decl = IDENTIFIER_NAMESPACE_VALUE (name);
895 if (decl && TREE_CODE (decl) == OVERLOAD)
896 decl = OVL_FUNCTION (decl);
898 if (decl && decl != error_mark_node
899 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
900 /* If different sort of thing, we already gave an error. */
901 && TREE_CODE (decl) == TREE_CODE (x)
902 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
904 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
905 permerror (input_location, "previous external decl of %q+#D", decl);
909 if (TREE_CODE (x) == FUNCTION_DECL
911 && !flag_friend_injection)
913 /* This is a new declaration of a friend function, so hide
914 it from ordinary function lookup. */
915 DECL_ANTICIPATED (x) = 1;
916 DECL_HIDDEN_FRIEND_P (x) = 1;
919 /* This name is new in its binding level.
920 Install the new declaration and return it. */
921 if (namespace_bindings_p ())
923 /* Install a global value. */
925 /* If the first global decl has external linkage,
926 warn if we later see static one. */
927 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
928 TREE_PUBLIC (name) = 1;
930 /* Bind the name for the entity. */
931 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
933 && (TREE_CODE (x) == TYPE_DECL
934 || TREE_CODE (x) == VAR_DECL
935 || TREE_CODE (x) == NAMESPACE_DECL
936 || TREE_CODE (x) == CONST_DECL
937 || TREE_CODE (x) == TEMPLATE_DECL))
938 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
940 /* If new decl is `static' and an `extern' was seen previously,
942 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
943 warn_extern_redeclared_static (x, t);
947 /* Here to install a non-global value. */
948 tree oldlocal = innermost_non_namespace_value (name);
949 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
951 if (need_new_binding)
953 push_local_binding (name, x, 0);
954 /* Because push_local_binding will hook X on to the
955 current_binding_level's name list, we don't want to
956 do that again below. */
957 need_new_binding = 0;
960 /* If this is a TYPE_DECL, push it into the type value slot. */
961 if (TREE_CODE (x) == TYPE_DECL)
962 set_identifier_type_value (name, x);
964 /* Clear out any TYPE_DECL shadowed by a namespace so that
965 we won't think this is a type. The C struct hack doesn't
966 go through namespaces. */
967 if (TREE_CODE (x) == NAMESPACE_DECL)
968 set_identifier_type_value (name, NULL_TREE);
975 && TREE_CODE (oldlocal) == VAR_DECL
976 && DECL_DEAD_FOR_LOCAL (oldlocal))
977 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
979 if (oldlocal == NULL_TREE)
980 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
983 /* If this is an extern function declaration, see if we
984 have a global definition or declaration for the function. */
985 if (oldlocal == NULL_TREE
987 && oldglobal != NULL_TREE
988 && TREE_CODE (x) == FUNCTION_DECL
989 && TREE_CODE (oldglobal) == FUNCTION_DECL)
991 /* We have one. Their types must agree. */
992 if (decls_match (x, oldglobal))
996 warning (0, "extern declaration of %q#D doesn%'t match", x);
997 warning (0, "global declaration %q+#D", oldglobal);
1000 /* If we have a local external declaration,
1001 and no file-scope declaration has yet been seen,
1002 then if we later have a file-scope decl it must not be static. */
1003 if (oldlocal == NULL_TREE
1004 && oldglobal == NULL_TREE
1005 && DECL_EXTERNAL (x)
1007 TREE_PUBLIC (name) = 1;
1009 /* Don't complain about the parms we push and then pop
1010 while tentatively parsing a function declarator. */
1011 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1014 /* Warn if shadowing an argument at the top level of the body. */
1015 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1016 /* Inline decls shadow nothing. */
1017 && !DECL_FROM_INLINE (x)
1018 && (TREE_CODE (oldlocal) == PARM_DECL
1019 || TREE_CODE (oldlocal) == VAR_DECL
1020 /* If the old decl is a type decl, only warn if the
1021 old decl is an explicit typedef or if both the old
1022 and new decls are type decls. */
1023 || (TREE_CODE (oldlocal) == TYPE_DECL
1024 && (!DECL_ARTIFICIAL (oldlocal)
1025 || TREE_CODE (x) == TYPE_DECL)))
1026 /* Don't check the `this' parameter or internally generated
1027 vars unless it's an implicit typedef (see
1028 create_implicit_typedef in decl.c). */
1029 && (!DECL_ARTIFICIAL (oldlocal)
1030 || DECL_IMPLICIT_TYPEDEF_P (oldlocal))
1031 /* Don't check for internally generated vars unless
1032 it's an implicit typedef (see create_implicit_typedef
1034 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1036 bool nowarn = false;
1038 /* Don't complain if it's from an enclosing function. */
1039 if (DECL_CONTEXT (oldlocal) == current_function_decl
1040 && TREE_CODE (x) != PARM_DECL
1041 && TREE_CODE (oldlocal) == PARM_DECL)
1043 /* Go to where the parms should be and see if we find
1045 struct cp_binding_level *b = current_binding_level->level_chain;
1047 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1048 /* Skip the ctor/dtor cleanup level. */
1052 if (b->kind == sk_function_parms)
1054 error ("declaration of %q#D shadows a parameter", x);
1059 /* The local structure or class can't use parameters of
1060 the containing function anyway. */
1061 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1063 cxx_scope *scope = current_binding_level;
1064 tree context = DECL_CONTEXT (oldlocal);
1065 for (; scope; scope = scope->level_chain)
1067 if (scope->kind == sk_function_parms
1068 && scope->this_entity == context)
1070 if (scope->kind == sk_class
1071 && !LAMBDA_TYPE_P (scope->this_entity))
1079 if (warn_shadow && !nowarn)
1081 if (TREE_CODE (oldlocal) == PARM_DECL)
1082 warning_at (input_location, OPT_Wshadow,
1083 "declaration of %q#D shadows a parameter", x);
1085 warning_at (input_location, OPT_Wshadow,
1086 "declaration of %qD shadows a previous local",
1088 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1089 "shadowed declaration is here");
1093 /* Maybe warn if shadowing something else. */
1094 else if (warn_shadow && !DECL_EXTERNAL (x)
1095 /* No shadow warnings for internally generated vars unless
1096 it's an implicit typedef (see create_implicit_typedef
1098 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1099 /* No shadow warnings for vars made for inlining. */
1100 && ! DECL_FROM_INLINE (x))
1104 if (current_class_ptr)
1105 member = lookup_member (current_class_type,
1108 /*want_type=*/false);
1112 if (member && !TREE_STATIC (member))
1114 /* Location of previous decl is not useful in this case. */
1115 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1118 else if (oldglobal != NULL_TREE
1119 && (TREE_CODE (oldglobal) == VAR_DECL
1120 /* If the old decl is a type decl, only warn if the
1121 old decl is an explicit typedef or if both the
1122 old and new decls are type decls. */
1123 || (TREE_CODE (oldglobal) == TYPE_DECL
1124 && (!DECL_ARTIFICIAL (oldglobal)
1125 || TREE_CODE (x) == TYPE_DECL))))
1126 /* XXX shadow warnings in outer-more namespaces */
1128 warning_at (input_location, OPT_Wshadow,
1129 "declaration of %qD shadows a global declaration", x);
1130 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1131 "shadowed declaration is here");
1136 if (TREE_CODE (x) == VAR_DECL)
1137 maybe_register_incomplete_var (x);
1140 if (need_new_binding)
1141 add_decl_to_level (x,
1142 DECL_NAMESPACE_SCOPE_P (x)
1143 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1144 : current_binding_level);
1146 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1149 /* Record a decl-node X as belonging to the current lexical scope. */
1154 return pushdecl_maybe_friend (x, false);
1157 /* Enter DECL into the symbol table, if that's appropriate. Returns
1158 DECL, or a modified version thereof. */
1161 maybe_push_decl (tree decl)
1163 tree type = TREE_TYPE (decl);
1165 /* Add this decl to the current binding level, but not if it comes
1166 from another scope, e.g. a static member variable. TEM may equal
1167 DECL or it may be a previous decl of the same name. */
1168 if (decl == error_mark_node
1169 || (TREE_CODE (decl) != PARM_DECL
1170 && DECL_CONTEXT (decl) != NULL_TREE
1171 /* Definitions of namespace members outside their namespace are
1173 && !DECL_NAMESPACE_SCOPE_P (decl))
1174 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1175 || type == unknown_type_node
1176 /* The declaration of a template specialization does not affect
1177 the functions available for overload resolution, so we do not
1179 || (TREE_CODE (decl) == FUNCTION_DECL
1180 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1183 return pushdecl (decl);
1186 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1187 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1188 doesn't really belong to this binding level, that it got here
1189 through a using-declaration. */
1192 push_local_binding (tree id, tree decl, int flags)
1194 struct cp_binding_level *b;
1196 /* Skip over any local classes. This makes sense if we call
1197 push_local_binding with a friend decl of a local class. */
1198 b = innermost_nonclass_level ();
1200 if (lookup_name_innermost_nonclass_level (id))
1202 /* Supplement the existing binding. */
1203 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1204 /* It didn't work. Something else must be bound at this
1205 level. Do not add DECL to the list of things to pop
1210 /* Create a new binding. */
1211 push_binding (id, decl, b);
1213 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1214 /* We must put the OVERLOAD into a TREE_LIST since the
1215 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1216 decls that got here through a using-declaration. */
1217 decl = build_tree_list (NULL_TREE, decl);
1219 /* And put DECL on the list of things declared by the current
1221 add_decl_to_level (decl, b);
1224 /* Check to see whether or not DECL is a variable that would have been
1225 in scope under the ARM, but is not in scope under the ANSI/ISO
1226 standard. If so, issue an error message. If name lookup would
1227 work in both cases, but return a different result, this function
1228 returns the result of ANSI/ISO lookup. Otherwise, it returns
1232 check_for_out_of_scope_variable (tree decl)
1236 /* We only care about out of scope variables. */
1237 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1240 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1241 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1242 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1243 && DECL_DEAD_FOR_LOCAL (shadowed))
1244 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1245 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1247 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1250 if (!DECL_ERROR_REPORTED (decl))
1252 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1253 warning (0, " matches this %q+D under ISO standard rules",
1255 warning (0, " matches this %q+D under old rules", decl);
1256 DECL_ERROR_REPORTED (decl) = 1;
1261 /* If we have already complained about this declaration, there's no
1262 need to do it again. */
1263 if (DECL_ERROR_REPORTED (decl))
1266 DECL_ERROR_REPORTED (decl) = 1;
1268 if (TREE_TYPE (decl) == error_mark_node)
1271 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1273 error ("name lookup of %qD changed for ISO %<for%> scoping",
1275 error (" cannot use obsolete binding at %q+D because "
1276 "it has a destructor", decl);
1277 return error_mark_node;
1281 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1283 if (flag_permissive)
1284 permerror (input_location, " using obsolete binding at %q+D", decl);
1290 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1299 /* true means unconditionally make a BLOCK for the next level pushed. */
1301 static bool keep_next_level_flag;
1303 static int binding_depth = 0;
1310 for (i = 0; i < depth * 2; i++)
1314 /* Return a string describing the kind of SCOPE we have. */
1316 cxx_scope_descriptor (cxx_scope *scope)
1318 /* The order of this table must match the "scope_kind"
1320 static const char* scope_kind_names[] = {
1326 "function-parameter-scope",
1329 "template-parameter-scope",
1330 "template-explicit-spec-scope"
1332 const scope_kind kind = scope->explicit_spec_p
1333 ? sk_template_spec : scope->kind;
1335 return scope_kind_names[kind];
1338 /* Output a debugging information about SCOPE when performing
1341 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1343 const char *desc = cxx_scope_descriptor (scope);
1344 if (scope->this_entity)
1345 verbatim ("%s %s(%E) %p %d\n", action, desc,
1346 scope->this_entity, (void *) scope, line);
1348 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1351 /* Return the estimated initial size of the hashtable of a NAMESPACE
1354 static inline size_t
1355 namespace_scope_ht_size (tree ns)
1357 tree name = DECL_NAME (ns);
1359 return name == std_identifier
1360 ? NAMESPACE_STD_HT_SIZE
1361 : (name == global_scope_name
1362 ? GLOBAL_SCOPE_HT_SIZE
1363 : NAMESPACE_ORDINARY_HT_SIZE);
1366 /* A chain of binding_level structures awaiting reuse. */
1368 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1370 /* Insert SCOPE as the innermost binding level. */
1373 push_binding_level (struct cp_binding_level *scope)
1375 /* Add it to the front of currently active scopes stack. */
1376 scope->level_chain = current_binding_level;
1377 current_binding_level = scope;
1378 keep_next_level_flag = false;
1380 if (ENABLE_SCOPE_CHECKING)
1382 scope->binding_depth = binding_depth;
1383 indent (binding_depth);
1384 cxx_scope_debug (scope, input_line, "push");
1389 /* Create a new KIND scope and make it the top of the active scopes stack.
1390 ENTITY is the scope of the associated C++ entity (namespace, class,
1391 function, C++0x enumeration); it is NULL otherwise. */
1394 begin_scope (scope_kind kind, tree entity)
1398 /* Reuse or create a struct for this binding level. */
1399 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1401 scope = free_binding_level;
1402 memset (scope, 0, sizeof (cxx_scope));
1403 free_binding_level = scope->level_chain;
1406 scope = ggc_alloc_cleared_cxx_scope ();
1408 scope->this_entity = entity;
1409 scope->more_cleanups_ok = true;
1416 case sk_template_spec:
1417 scope->explicit_spec_p = true;
1418 kind = sk_template_parms;
1420 case sk_template_parms:
1426 case sk_scoped_enum:
1427 case sk_function_parms:
1429 scope->keep = keep_next_level_flag;
1433 NAMESPACE_LEVEL (entity) = scope;
1434 scope->static_decls =
1435 VEC_alloc (tree, gc,
1436 DECL_NAME (entity) == std_identifier
1437 || DECL_NAME (entity) == global_scope_name
1442 /* Should not happen. */
1448 push_binding_level (scope);
1453 /* We're about to leave current scope. Pop the top of the stack of
1454 currently active scopes. Return the enclosing scope, now active. */
1459 cxx_scope *scope = current_binding_level;
1461 if (scope->kind == sk_namespace && class_binding_level)
1462 current_binding_level = class_binding_level;
1464 /* We cannot leave a scope, if there are none left. */
1465 if (NAMESPACE_LEVEL (global_namespace))
1466 gcc_assert (!global_scope_p (scope));
1468 if (ENABLE_SCOPE_CHECKING)
1470 indent (--binding_depth);
1471 cxx_scope_debug (scope, input_line, "leave");
1474 /* Move one nesting level up. */
1475 current_binding_level = scope->level_chain;
1477 /* Namespace-scopes are left most probably temporarily, not
1478 completely; they can be reopened later, e.g. in namespace-extension
1479 or any name binding activity that requires us to resume a
1480 namespace. For classes, we cache some binding levels. For other
1481 scopes, we just make the structure available for reuse. */
1482 if (scope->kind != sk_namespace
1483 && scope->kind != sk_class)
1485 scope->level_chain = free_binding_level;
1486 gcc_assert (!ENABLE_SCOPE_CHECKING
1487 || scope->binding_depth == binding_depth);
1488 free_binding_level = scope;
1491 /* Find the innermost enclosing class scope, and reset
1492 CLASS_BINDING_LEVEL appropriately. */
1493 if (scope->kind == sk_class)
1495 class_binding_level = NULL;
1496 for (scope = current_binding_level; scope; scope = scope->level_chain)
1497 if (scope->kind == sk_class)
1499 class_binding_level = scope;
1504 return current_binding_level;
1508 resume_scope (struct cp_binding_level* b)
1510 /* Resuming binding levels is meant only for namespaces,
1511 and those cannot nest into classes. */
1512 gcc_assert (!class_binding_level);
1513 /* Also, resuming a non-directly nested namespace is a no-no. */
1514 gcc_assert (b->level_chain == current_binding_level);
1515 current_binding_level = b;
1516 if (ENABLE_SCOPE_CHECKING)
1518 b->binding_depth = binding_depth;
1519 indent (binding_depth);
1520 cxx_scope_debug (b, input_line, "resume");
1525 /* Return the innermost binding level that is not for a class scope. */
1528 innermost_nonclass_level (void)
1532 b = current_binding_level;
1533 while (b->kind == sk_class)
1539 /* We're defining an object of type TYPE. If it needs a cleanup, but
1540 we're not allowed to add any more objects with cleanups to the current
1541 scope, create a new binding level. */
1544 maybe_push_cleanup_level (tree type)
1546 if (type != error_mark_node
1547 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1548 && current_binding_level->more_cleanups_ok == 0)
1550 begin_scope (sk_cleanup, NULL);
1551 current_binding_level->statement_list = push_stmt_list ();
1555 /* Nonzero if we are currently in the global binding level. */
1558 global_bindings_p (void)
1560 return global_scope_p (current_binding_level);
1563 /* True if we are currently in a toplevel binding level. This
1564 means either the global binding level or a namespace in a toplevel
1565 binding level. Since there are no non-toplevel namespace levels,
1566 this really means any namespace or template parameter level. We
1567 also include a class whose context is toplevel. */
1570 toplevel_bindings_p (void)
1572 struct cp_binding_level *b = innermost_nonclass_level ();
1574 return b->kind == sk_namespace || b->kind == sk_template_parms;
1577 /* True if this is a namespace scope, or if we are defining a class
1578 which is itself at namespace scope, or whose enclosing class is
1579 such a class, etc. */
1582 namespace_bindings_p (void)
1584 struct cp_binding_level *b = innermost_nonclass_level ();
1586 return b->kind == sk_namespace;
1589 /* True if the current level needs to have a BLOCK made. */
1594 return (current_binding_level->blocks != NULL_TREE
1595 || current_binding_level->keep
1596 || current_binding_level->kind == sk_cleanup
1597 || current_binding_level->names != NULL_TREE
1598 || current_binding_level->using_directives);
1601 /* Returns the kind of the innermost scope. */
1604 innermost_scope_kind (void)
1606 return current_binding_level->kind;
1609 /* Returns true if this scope was created to store template parameters. */
1612 template_parm_scope_p (void)
1614 return innermost_scope_kind () == sk_template_parms;
1617 /* If KEEP is true, make a BLOCK node for the next binding level,
1618 unconditionally. Otherwise, use the normal logic to decide whether
1619 or not to create a BLOCK. */
1622 keep_next_level (bool keep)
1624 keep_next_level_flag = keep;
1627 /* Return the list of declarations of the current level.
1628 Note that this list is in reverse order unless/until
1629 you nreverse it; and when you do nreverse it, you must
1630 store the result back using `storedecls' or you will lose. */
1635 return current_binding_level->names;
1638 /* Return how many function prototypes we are currently nested inside. */
1641 function_parm_depth (void)
1644 struct cp_binding_level *b;
1646 for (b = current_binding_level;
1647 b->kind == sk_function_parms;
1654 /* For debugging. */
1655 static int no_print_functions = 0;
1656 static int no_print_builtins = 0;
1659 print_binding_level (struct cp_binding_level* lvl)
1663 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1664 if (lvl->more_cleanups_ok)
1665 fprintf (stderr, " more-cleanups-ok");
1666 if (lvl->have_cleanups)
1667 fprintf (stderr, " have-cleanups");
1668 fprintf (stderr, "\n");
1671 fprintf (stderr, " names:\t");
1672 /* We can probably fit 3 names to a line? */
1673 for (t = lvl->names; t; t = TREE_CHAIN (t))
1675 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1677 if (no_print_builtins
1678 && (TREE_CODE (t) == TYPE_DECL)
1679 && DECL_IS_BUILTIN (t))
1682 /* Function decls tend to have longer names. */
1683 if (TREE_CODE (t) == FUNCTION_DECL)
1690 fprintf (stderr, "\n\t");
1693 print_node_brief (stderr, "", t, 0);
1694 if (t == error_mark_node)
1698 fprintf (stderr, "\n");
1700 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1703 cp_class_binding *b;
1704 fprintf (stderr, " class-shadowed:");
1705 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1706 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1707 fprintf (stderr, "\n");
1709 if (lvl->type_shadowed)
1711 fprintf (stderr, " type-shadowed:");
1712 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1714 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1716 fprintf (stderr, "\n");
1721 print_other_binding_stack (struct cp_binding_level *stack)
1723 struct cp_binding_level *level;
1724 for (level = stack; !global_scope_p (level); level = level->level_chain)
1726 fprintf (stderr, "binding level %p\n", (void *) level);
1727 print_binding_level (level);
1732 print_binding_stack (void)
1734 struct cp_binding_level *b;
1735 fprintf (stderr, "current_binding_level=%p\n"
1736 "class_binding_level=%p\n"
1737 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1738 (void *) current_binding_level, (void *) class_binding_level,
1739 (void *) NAMESPACE_LEVEL (global_namespace));
1740 if (class_binding_level)
1742 for (b = class_binding_level; b; b = b->level_chain)
1743 if (b == current_binding_level)
1746 b = class_binding_level;
1748 b = current_binding_level;
1751 b = current_binding_level;
1752 print_other_binding_stack (b);
1753 fprintf (stderr, "global:\n");
1754 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1757 /* Return the type associated with id. */
1760 identifier_type_value (tree id)
1762 timevar_push (TV_NAME_LOOKUP);
1763 /* There is no type with that name, anywhere. */
1764 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1766 /* This is not the type marker, but the real thing. */
1767 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1769 /* Have to search for it. It must be on the global level, now.
1770 Ask lookup_name not to return non-types. */
1771 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1773 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1774 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1777 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1778 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1781 identifier_global_value (tree t)
1783 return IDENTIFIER_GLOBAL_VALUE (t);
1786 /* Push a definition of struct, union or enum tag named ID. into
1787 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1788 the tag ID is not already defined. */
1791 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1795 if (b->kind != sk_namespace)
1797 /* Shadow the marker, not the real thing, so that the marker
1798 gets restored later. */
1799 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1801 = tree_cons (id, old_type_value, b->type_shadowed);
1802 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1803 TREE_TYPE (b->type_shadowed) = type;
1807 cxx_binding *binding =
1808 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1811 supplement_binding (binding, decl);
1813 binding->value = decl;
1815 /* Store marker instead of real type. */
1816 type = global_type_node;
1818 SET_IDENTIFIER_TYPE_VALUE (id, type);
1821 /* As set_identifier_type_value_with_scope, but using
1822 current_binding_level. */
1825 set_identifier_type_value (tree id, tree decl)
1827 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1830 /* Return the name for the constructor (or destructor) for the
1831 specified class TYPE. When given a template, this routine doesn't
1832 lose the specialization. */
1835 constructor_name_full (tree type)
1837 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1840 /* Return the name for the constructor (or destructor) for the
1841 specified class. When given a template, return the plain
1842 unspecialized name. */
1845 constructor_name (tree type)
1848 name = constructor_name_full (type);
1849 if (IDENTIFIER_TEMPLATE (name))
1850 name = IDENTIFIER_TEMPLATE (name);
1854 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1855 which must be a class type. */
1858 constructor_name_p (tree name, tree type)
1862 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1867 if (TREE_CODE (name) != IDENTIFIER_NODE)
1870 ctor_name = constructor_name_full (type);
1871 if (name == ctor_name)
1873 if (IDENTIFIER_TEMPLATE (ctor_name)
1874 && name == IDENTIFIER_TEMPLATE (ctor_name))
1879 /* Counter used to create anonymous type names. */
1881 static GTY(()) int anon_cnt;
1883 /* Return an IDENTIFIER which can be used as a name for
1884 anonymous structs and unions. */
1887 make_anon_name (void)
1891 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1892 return get_identifier (buf);
1895 /* This code is practically identical to that for creating
1896 anonymous names, but is just used for lambdas instead. This is necessary
1897 because anonymous names are recognized and cannot be passed to template
1899 /* FIXME is this still necessary? */
1901 static GTY(()) int lambda_cnt = 0;
1904 make_lambda_name (void)
1908 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1909 return get_identifier (buf);
1912 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1914 static inline cxx_binding *
1915 find_binding (cxx_scope *scope, cxx_binding *binding)
1917 timevar_push (TV_NAME_LOOKUP);
1919 for (; binding != NULL; binding = binding->previous)
1920 if (binding->scope == scope)
1921 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1923 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1926 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1928 static inline cxx_binding *
1929 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1931 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1934 /* Fold-in case where NAME is used only once. */
1935 if (scope == b->scope && b->previous == NULL)
1937 return find_binding (scope, b);
1942 /* Always returns a binding for name in scope. If no binding is
1943 found, make a new one. */
1945 static cxx_binding *
1946 binding_for_name (cxx_scope *scope, tree name)
1948 cxx_binding *result;
1950 result = cxx_scope_find_binding_for_name (scope, name);
1953 /* Not found, make a new one. */
1954 result = cxx_binding_make (NULL, NULL);
1955 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1956 result->scope = scope;
1957 result->is_local = false;
1958 result->value_is_inherited = false;
1959 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1963 /* Walk through the bindings associated to the name of FUNCTION,
1964 and return the first binding that declares a function with a
1965 "C" linkage specification, a.k.a 'extern "C"'.
1966 This function looks for the binding, regardless of which scope it
1967 has been defined in. It basically looks in all the known scopes.
1968 Note that this function does not lookup for bindings of builtin functions
1969 or for functions declared in system headers. */
1971 lookup_extern_c_fun_binding_in_all_ns (tree function)
1976 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1978 name = DECL_NAME (function);
1979 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1981 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1983 iter = iter->previous)
1986 && TREE_CODE (iter->value) == FUNCTION_DECL
1987 && DECL_EXTERN_C_P (iter->value)
1988 && !DECL_ARTIFICIAL (iter->value))
1996 /* Insert another USING_DECL into the current binding level, returning
1997 this declaration. If this is a redeclaration, do nothing, and
1998 return NULL_TREE if this not in namespace scope (in namespace
1999 scope, a using decl might extend any previous bindings). */
2002 push_using_decl (tree scope, tree name)
2006 timevar_push (TV_NAME_LOOKUP);
2007 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2008 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2009 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2010 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2013 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
2014 namespace_bindings_p () ? decl : NULL_TREE);
2015 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2016 USING_DECL_SCOPE (decl) = scope;
2017 DECL_CHAIN (decl) = current_binding_level->usings;
2018 current_binding_level->usings = decl;
2019 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2022 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2023 caller to set DECL_CONTEXT properly. */
2026 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
2028 struct cp_binding_level *b;
2029 tree function_decl = current_function_decl;
2031 timevar_push (TV_NAME_LOOKUP);
2032 current_function_decl = NULL_TREE;
2033 if (level->kind == sk_class)
2035 b = class_binding_level;
2036 class_binding_level = level;
2037 pushdecl_class_level (x);
2038 class_binding_level = b;
2042 b = current_binding_level;
2043 current_binding_level = level;
2044 x = pushdecl_maybe_friend (x, is_friend);
2045 current_binding_level = b;
2047 current_function_decl = function_decl;
2048 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
2051 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2052 other definitions already in place. We get around this by making
2053 the value of the identifier point to a list of all the things that
2054 want to be referenced by that name. It is then up to the users of
2055 that name to decide what to do with that list.
2057 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2058 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2060 FLAGS is a bitwise-or of the following values:
2061 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2063 PUSH_USING: DECL is being pushed as the result of a using
2066 IS_FRIEND is true if this is a friend declaration.
2068 The value returned may be a previous declaration if we guessed wrong
2069 about what language DECL should belong to (C or C++). Otherwise,
2070 it's always DECL (and never something that's not a _DECL). */
2073 push_overloaded_decl (tree decl, int flags, bool is_friend)
2075 tree name = DECL_NAME (decl);
2078 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2080 timevar_push (TV_NAME_LOOKUP);
2082 old = namespace_binding (name, DECL_CONTEXT (decl));
2084 old = lookup_name_innermost_nonclass_level (name);
2088 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2090 tree t = TREE_TYPE (old);
2091 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2092 && (! DECL_IN_SYSTEM_HEADER (decl)
2093 || ! DECL_IN_SYSTEM_HEADER (old)))
2094 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2097 else if (is_overloaded_fn (old))
2101 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2103 tree fn = OVL_CURRENT (tmp);
2106 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2107 && !(flags & PUSH_USING)
2108 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2109 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2110 && ! decls_match (fn, decl))
2111 error ("%q#D conflicts with previous using declaration %q#D",
2114 dup = duplicate_decls (decl, fn, is_friend);
2115 /* If DECL was a redeclaration of FN -- even an invalid
2116 one -- pass that information along to our caller. */
2117 if (dup == fn || dup == error_mark_node)
2118 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2121 /* We don't overload implicit built-ins. duplicate_decls()
2122 may fail to merge the decls if the new decl is e.g. a
2123 template function. */
2124 if (TREE_CODE (old) == FUNCTION_DECL
2125 && DECL_ANTICIPATED (old)
2126 && !DECL_HIDDEN_FRIEND_P (old))
2129 else if (old == error_mark_node)
2130 /* Ignore the undefined symbol marker. */
2134 error ("previous non-function declaration %q+#D", old);
2135 error ("conflicts with function declaration %q#D", decl);
2136 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2140 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2141 /* If it's a using declaration, we always need to build an OVERLOAD,
2142 because it's the only way to remember that the declaration comes
2143 from 'using', and have the lookup behave correctly. */
2144 || (flags & PUSH_USING))
2146 if (old && TREE_CODE (old) != OVERLOAD)
2147 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2149 new_binding = ovl_cons (decl, old);
2150 if (flags & PUSH_USING)
2151 OVL_USED (new_binding) = 1;
2154 /* NAME is not ambiguous. */
2158 set_namespace_binding (name, current_namespace, new_binding);
2161 /* We only create an OVERLOAD if there was a previous binding at
2162 this level, or if decl is a template. In the former case, we
2163 need to remove the old binding and replace it with the new
2164 binding. We must also run through the NAMES on the binding
2165 level where the name was bound to update the chain. */
2167 if (TREE_CODE (new_binding) == OVERLOAD && old)
2171 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2173 d = &TREE_CHAIN (*d))
2175 || (TREE_CODE (*d) == TREE_LIST
2176 && TREE_VALUE (*d) == old))
2178 if (TREE_CODE (*d) == TREE_LIST)
2179 /* Just replace the old binding with the new. */
2180 TREE_VALUE (*d) = new_binding;
2182 /* Build a TREE_LIST to wrap the OVERLOAD. */
2183 *d = tree_cons (NULL_TREE, new_binding,
2186 /* And update the cxx_binding node. */
2187 IDENTIFIER_BINDING (name)->value = new_binding;
2188 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2191 /* We should always find a previous binding in this case. */
2195 /* Install the new binding. */
2196 push_local_binding (name, new_binding, flags);
2199 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2202 /* Check a non-member using-declaration. Return the name and scope
2203 being used, and the USING_DECL, or NULL_TREE on failure. */
2206 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2208 /* [namespace.udecl]
2209 A using-declaration for a class member shall be a
2210 member-declaration. */
2213 error ("%qT is not a namespace", scope);
2216 else if (scope == error_mark_node)
2219 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2222 A using-declaration shall not name a template-id. */
2223 error ("a using-declaration cannot specify a template-id. "
2224 "Try %<using %D%>", name);
2228 if (TREE_CODE (decl) == NAMESPACE_DECL)
2230 error ("namespace %qD not allowed in using-declaration", decl);
2234 if (TREE_CODE (decl) == SCOPE_REF)
2236 /* It's a nested name with template parameter dependent scope.
2237 This can only be using-declaration for class member. */
2238 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2242 if (is_overloaded_fn (decl))
2243 decl = get_first_fn (decl);
2245 gcc_assert (DECL_P (decl));
2247 /* Make a USING_DECL. */
2248 return push_using_decl (scope, name);
2251 /* Process local and global using-declarations. */
2254 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2255 tree *newval, tree *newtype)
2257 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2259 *newval = *newtype = NULL_TREE;
2260 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2264 if (!decls.value && !decls.type)
2266 error ("%qD not declared", name);
2270 /* Shift the old and new bindings around so we're comparing class and
2271 enumeration names to each other. */
2272 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2278 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2280 decls.type = decls.value;
2281 decls.value = NULL_TREE;
2284 /* It is impossible to overload a built-in function; any explicit
2285 declaration eliminates the built-in declaration. So, if OLDVAL
2286 is a built-in, then we can just pretend it isn't there. */
2288 && TREE_CODE (oldval) == FUNCTION_DECL
2289 && DECL_ANTICIPATED (oldval)
2290 && !DECL_HIDDEN_FRIEND_P (oldval))
2295 /* Check for using functions. */
2296 if (is_overloaded_fn (decls.value))
2300 if (oldval && !is_overloaded_fn (oldval))
2302 error ("%qD is already declared in this scope", name);
2307 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2309 tree new_fn = OVL_CURRENT (tmp);
2311 /* [namespace.udecl]
2313 If a function declaration in namespace scope or block
2314 scope has the same name and the same parameter types as a
2315 function introduced by a using declaration the program is
2317 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2319 tree old_fn = OVL_CURRENT (tmp1);
2321 if (new_fn == old_fn)
2322 /* The function already exists in the current namespace. */
2324 else if (OVL_USED (tmp1))
2325 continue; /* this is a using decl */
2326 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2327 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2329 gcc_assert (!DECL_ANTICIPATED (old_fn)
2330 || DECL_HIDDEN_FRIEND_P (old_fn));
2332 /* There was already a non-using declaration in
2333 this scope with the same parameter types. If both
2334 are the same extern "C" functions, that's ok. */
2335 if (decls_match (new_fn, old_fn))
2339 error ("%qD is already declared in this scope", name);
2345 /* If we broke out of the loop, there's no reason to add
2346 this function to the using declarations for this
2351 /* If we are adding to an existing OVERLOAD, then we no
2352 longer know the type of the set of functions. */
2353 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2354 TREE_TYPE (*newval) = unknown_type_node;
2355 /* Add this new function to the set. */
2356 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2357 /* If there is only one function, then we use its type. (A
2358 using-declaration naming a single function can be used in
2359 contexts where overload resolution cannot be
2361 if (TREE_CODE (*newval) != OVERLOAD)
2363 *newval = ovl_cons (*newval, NULL_TREE);
2364 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2366 OVL_USED (*newval) = 1;
2371 *newval = decls.value;
2372 if (oldval && !decls_match (*newval, oldval))
2373 error ("%qD is already declared in this scope", name);
2379 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2381 error ("reference to %qD is ambiguous", name);
2382 print_candidates (decls.type);
2386 *newtype = decls.type;
2387 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2388 error ("%qD is already declared in this scope", name);
2391 /* If *newval is empty, shift any class or enumeration name down. */
2395 *newtype = NULL_TREE;
2399 /* Process a using-declaration at function scope. */
2402 do_local_using_decl (tree decl, tree scope, tree name)
2404 tree oldval, oldtype, newval, newtype;
2405 tree orig_decl = decl;
2407 decl = validate_nonmember_using_decl (decl, scope, name);
2408 if (decl == NULL_TREE)
2411 if (building_stmt_tree ()
2412 && at_function_scope_p ())
2413 add_decl_expr (decl);
2415 oldval = lookup_name_innermost_nonclass_level (name);
2416 oldtype = lookup_type_current_level (name);
2418 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2422 if (is_overloaded_fn (newval))
2426 /* We only need to push declarations for those functions
2427 that were not already bound in the current level.
2428 The old value might be NULL_TREE, it might be a single
2429 function, or an OVERLOAD. */
2430 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2431 term = OVL_FUNCTION (oldval);
2434 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2436 push_overloaded_decl (OVL_CURRENT (fn),
2437 PUSH_LOCAL | PUSH_USING,
2441 push_local_binding (name, newval, PUSH_USING);
2445 push_local_binding (name, newtype, PUSH_USING);
2446 set_identifier_type_value (name, newtype);
2449 /* Emit debug info. */
2450 if (!processing_template_decl)
2451 cp_emit_debug_info_for_using (orig_decl, current_scope());
2454 /* Returns true if ROOT (a namespace, class, or function) encloses
2455 CHILD. CHILD may be either a class type or a namespace. */
2458 is_ancestor (tree root, tree child)
2460 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2461 || TREE_CODE (root) == FUNCTION_DECL
2462 || CLASS_TYPE_P (root)));
2463 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2464 || CLASS_TYPE_P (child)));
2466 /* The global namespace encloses everything. */
2467 if (root == global_namespace)
2472 /* If we've run out of scopes, stop. */
2475 /* If we've reached the ROOT, it encloses CHILD. */
2478 /* Go out one level. */
2480 child = TYPE_NAME (child);
2481 child = DECL_CONTEXT (child);
2485 /* Enter the class or namespace scope indicated by T suitable for name
2486 lookup. T can be arbitrary scope, not necessary nested inside the
2487 current scope. Returns a non-null scope to pop iff pop_scope
2488 should be called later to exit this scope. */
2493 if (TREE_CODE (t) == NAMESPACE_DECL)
2494 push_decl_namespace (t);
2495 else if (CLASS_TYPE_P (t))
2497 if (!at_class_scope_p ()
2498 || !same_type_p (current_class_type, t))
2499 push_nested_class (t);
2501 /* T is the same as the current scope. There is therefore no
2502 need to re-enter the scope. Since we are not actually
2503 pushing a new scope, our caller should not call
2511 /* Leave scope pushed by push_scope. */
2518 if (TREE_CODE (t) == NAMESPACE_DECL)
2519 pop_decl_namespace ();
2520 else if CLASS_TYPE_P (t)
2521 pop_nested_class ();
2524 /* Subroutine of push_inner_scope. */
2527 push_inner_scope_r (tree outer, tree inner)
2532 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2535 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2537 push_inner_scope_r (outer, prev);
2538 if (TREE_CODE (inner) == NAMESPACE_DECL)
2540 struct cp_binding_level *save_template_parm = 0;
2541 /* Temporary take out template parameter scopes. They are saved
2542 in reversed order in save_template_parm. */
2543 while (current_binding_level->kind == sk_template_parms)
2545 struct cp_binding_level *b = current_binding_level;
2546 current_binding_level = b->level_chain;
2547 b->level_chain = save_template_parm;
2548 save_template_parm = b;
2551 resume_scope (NAMESPACE_LEVEL (inner));
2552 current_namespace = inner;
2554 /* Restore template parameter scopes. */
2555 while (save_template_parm)
2557 struct cp_binding_level *b = save_template_parm;
2558 save_template_parm = b->level_chain;
2559 b->level_chain = current_binding_level;
2560 current_binding_level = b;
2567 /* Enter the scope INNER from current scope. INNER must be a scope
2568 nested inside current scope. This works with both name lookup and
2569 pushing name into scope. In case a template parameter scope is present,
2570 namespace is pushed under the template parameter scope according to
2571 name lookup rule in 14.6.1/6.
2573 Return the former current scope suitable for pop_inner_scope. */
2576 push_inner_scope (tree inner)
2578 tree outer = current_scope ();
2580 outer = current_namespace;
2582 push_inner_scope_r (outer, inner);
2586 /* Exit the current scope INNER back to scope OUTER. */
2589 pop_inner_scope (tree outer, tree inner)
2592 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2595 while (outer != inner)
2597 if (TREE_CODE (inner) == NAMESPACE_DECL)
2599 struct cp_binding_level *save_template_parm = 0;
2600 /* Temporary take out template parameter scopes. They are saved
2601 in reversed order in save_template_parm. */
2602 while (current_binding_level->kind == sk_template_parms)
2604 struct cp_binding_level *b = current_binding_level;
2605 current_binding_level = b->level_chain;
2606 b->level_chain = save_template_parm;
2607 save_template_parm = b;
2612 /* Restore template parameter scopes. */
2613 while (save_template_parm)
2615 struct cp_binding_level *b = save_template_parm;
2616 save_template_parm = b->level_chain;
2617 b->level_chain = current_binding_level;
2618 current_binding_level = b;
2624 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2628 /* Do a pushlevel for class declarations. */
2631 pushlevel_class (void)
2633 class_binding_level = begin_scope (sk_class, current_class_type);
2636 /* ...and a poplevel for class declarations. */
2639 poplevel_class (void)
2641 struct cp_binding_level *level = class_binding_level;
2642 cp_class_binding *cb;
2646 timevar_push (TV_NAME_LOOKUP);
2647 gcc_assert (level != 0);
2649 /* If we're leaving a toplevel class, cache its binding level. */
2650 if (current_class_depth == 1)
2651 previous_class_level = level;
2652 for (shadowed = level->type_shadowed;
2654 shadowed = TREE_CHAIN (shadowed))
2655 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2657 /* Remove the bindings for all of the class-level declarations. */
2658 if (level->class_shadowed)
2660 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2661 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2662 ggc_free (level->class_shadowed);
2663 level->class_shadowed = NULL;
2666 /* Now, pop out of the binding level which we created up in the
2667 `pushlevel_class' routine. */
2668 gcc_assert (current_binding_level == level);
2670 timevar_pop (TV_NAME_LOOKUP);
2673 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2674 appropriate. DECL is the value to which a name has just been
2675 bound. CLASS_TYPE is the class in which the lookup occurred. */
2678 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2681 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2685 if (TREE_CODE (decl) == OVERLOAD)
2686 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2689 gcc_assert (DECL_P (decl));
2690 context = context_for_name_lookup (decl);
2693 if (is_properly_derived_from (class_type, context))
2694 INHERITED_VALUE_BINDING_P (binding) = 1;
2696 INHERITED_VALUE_BINDING_P (binding) = 0;
2698 else if (binding->value == decl)
2699 /* We only encounter a TREE_LIST when there is an ambiguity in the
2700 base classes. Such an ambiguity can be overridden by a
2701 definition in this class. */
2702 INHERITED_VALUE_BINDING_P (binding) = 1;
2704 INHERITED_VALUE_BINDING_P (binding) = 0;
2707 /* Make the declaration of X appear in CLASS scope. */
2710 pushdecl_class_level (tree x)
2713 bool is_valid = true;
2715 /* Do nothing if we're adding to an outer lambda closure type,
2716 outer_binding will add it later if it's needed. */
2717 if (current_class_type != class_binding_level->this_entity)
2720 timevar_push (TV_NAME_LOOKUP);
2721 /* Get the name of X. */
2722 if (TREE_CODE (x) == OVERLOAD)
2723 name = DECL_NAME (get_first_fn (x));
2725 name = DECL_NAME (x);
2729 is_valid = push_class_level_binding (name, x);
2730 if (TREE_CODE (x) == TYPE_DECL)
2731 set_identifier_type_value (name, x);
2733 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2735 /* If X is an anonymous aggregate, all of its members are
2736 treated as if they were members of the class containing the
2737 aggregate, for naming purposes. */
2740 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2742 location_t save_location = input_location;
2743 input_location = DECL_SOURCE_LOCATION (f);
2744 if (!pushdecl_class_level (f))
2746 input_location = save_location;
2749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2752 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2753 scope. If the value returned is non-NULL, and the PREVIOUS field
2754 is not set, callers must set the PREVIOUS field explicitly. */
2756 static cxx_binding *
2757 get_class_binding (tree name, cxx_scope *scope)
2762 cxx_binding *binding;
2764 class_type = scope->this_entity;
2766 /* Get the type binding. */
2767 type_binding = lookup_member (class_type, name,
2768 /*protect=*/2, /*want_type=*/true);
2769 /* Get the value binding. */
2770 value_binding = lookup_member (class_type, name,
2771 /*protect=*/2, /*want_type=*/false);
2774 && (TREE_CODE (value_binding) == TYPE_DECL
2775 || DECL_CLASS_TEMPLATE_P (value_binding)
2776 || (TREE_CODE (value_binding) == TREE_LIST
2777 && TREE_TYPE (value_binding) == error_mark_node
2778 && (TREE_CODE (TREE_VALUE (value_binding))
2780 /* We found a type binding, even when looking for a non-type
2781 binding. This means that we already processed this binding
2784 else if (value_binding)
2786 if (TREE_CODE (value_binding) == TREE_LIST
2787 && TREE_TYPE (value_binding) == error_mark_node)
2788 /* NAME is ambiguous. */
2790 else if (BASELINK_P (value_binding))
2791 /* NAME is some overloaded functions. */
2792 value_binding = BASELINK_FUNCTIONS (value_binding);
2795 /* If we found either a type binding or a value binding, create a
2796 new binding object. */
2797 if (type_binding || value_binding)
2799 binding = new_class_binding (name,
2803 /* This is a class-scope binding, not a block-scope binding. */
2804 LOCAL_BINDING_P (binding) = 0;
2805 set_inherited_value_binding_p (binding, value_binding, class_type);
2813 /* Make the declaration(s) of X appear in CLASS scope under the name
2814 NAME. Returns true if the binding is valid. */
2817 push_class_level_binding (tree name, tree x)
2819 cxx_binding *binding;
2823 timevar_push (TV_NAME_LOOKUP);
2824 /* The class_binding_level will be NULL if x is a template
2825 parameter name in a member template. */
2826 if (!class_binding_level)
2827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2829 if (name == error_mark_node)
2830 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2832 /* Check for invalid member names. */
2833 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2834 /* Check that we're pushing into the right binding level. */
2835 gcc_assert (current_class_type == class_binding_level->this_entity);
2837 /* We could have been passed a tree list if this is an ambiguous
2838 declaration. If so, pull the declaration out because
2839 check_template_shadow will not handle a TREE_LIST. */
2840 if (TREE_CODE (decl) == TREE_LIST
2841 && TREE_TYPE (decl) == error_mark_node)
2842 decl = TREE_VALUE (decl);
2844 if (!check_template_shadow (decl))
2845 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2849 If T is the name of a class, then each of the following shall
2850 have a name different from T:
2852 -- every static data member of class T;
2854 -- every member of class T that is itself a type;
2856 -- every enumerator of every member of class T that is an
2859 -- every member of every anonymous union that is a member of
2862 (Non-static data members were also forbidden to have the same
2863 name as T until TC1.) */
2864 if ((TREE_CODE (x) == VAR_DECL
2865 || TREE_CODE (x) == CONST_DECL
2866 || (TREE_CODE (x) == TYPE_DECL
2867 && !DECL_SELF_REFERENCE_P (x))
2868 /* A data member of an anonymous union. */
2869 || (TREE_CODE (x) == FIELD_DECL
2870 && DECL_CONTEXT (x) != current_class_type))
2871 && DECL_NAME (x) == constructor_name (current_class_type))
2873 tree scope = context_for_name_lookup (x);
2874 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2876 error ("%qD has the same name as the class in which it is "
2879 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2883 /* Get the current binding for NAME in this class, if any. */
2884 binding = IDENTIFIER_BINDING (name);
2885 if (!binding || binding->scope != class_binding_level)
2887 binding = get_class_binding (name, class_binding_level);
2888 /* If a new binding was created, put it at the front of the
2889 IDENTIFIER_BINDING list. */
2892 binding->previous = IDENTIFIER_BINDING (name);
2893 IDENTIFIER_BINDING (name) = binding;
2897 /* If there is already a binding, then we may need to update the
2899 if (binding && binding->value)
2901 tree bval = binding->value;
2902 tree old_decl = NULL_TREE;
2904 if (INHERITED_VALUE_BINDING_P (binding))
2906 /* If the old binding was from a base class, and was for a
2907 tag name, slide it over to make room for the new binding.
2908 The old binding is still visible if explicitly qualified
2909 with a class-key. */
2910 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2911 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2913 old_decl = binding->type;
2914 binding->type = bval;
2915 binding->value = NULL_TREE;
2916 INHERITED_VALUE_BINDING_P (binding) = 0;
2921 /* Any inherited type declaration is hidden by the type
2922 declaration in the derived class. */
2923 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2924 binding->type = NULL_TREE;
2927 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2929 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2930 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2931 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2933 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2936 if (old_decl && binding->scope == class_binding_level)
2939 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2940 here. This function is only used to register bindings
2941 from with the class definition itself. */
2942 INHERITED_VALUE_BINDING_P (binding) = 0;
2943 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2947 /* Note that we declared this value so that we can issue an error if
2948 this is an invalid redeclaration of a name already used for some
2950 note_name_declared_in_class (name, decl);
2952 /* If we didn't replace an existing binding, put the binding on the
2953 stack of bindings for the identifier, and update the shadowed
2955 if (binding && binding->scope == class_binding_level)
2956 /* Supplement the existing binding. */
2957 ok = supplement_binding (binding, decl);
2960 /* Create a new binding. */
2961 push_binding (name, decl, class_binding_level);
2965 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2968 /* Process "using SCOPE::NAME" in a class scope. Return the
2969 USING_DECL created. */
2972 do_class_using_decl (tree scope, tree name)
2974 /* The USING_DECL returned by this function. */
2976 /* The declaration (or declarations) name by this using
2977 declaration. NULL if we are in a template and cannot figure out
2978 what has been named. */
2980 /* True if SCOPE is a dependent type. */
2981 bool scope_dependent_p;
2982 /* True if SCOPE::NAME is dependent. */
2983 bool name_dependent_p;
2984 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2985 bool bases_dependent_p;
2990 if (name == error_mark_node)
2993 if (!scope || !TYPE_P (scope))
2995 error ("using-declaration for non-member at class scope");
2999 /* Make sure the name is not invalid */
3000 if (TREE_CODE (name) == BIT_NOT_EXPR)
3002 error ("%<%T::%D%> names destructor", scope, name);
3005 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3007 error ("%<%T::%D%> names constructor", scope, name);
3010 if (constructor_name_p (name, current_class_type))
3012 error ("%<%T::%D%> names constructor in %qT",
3013 scope, name, current_class_type);
3017 scope_dependent_p = dependent_type_p (scope);
3018 name_dependent_p = (scope_dependent_p
3019 || (IDENTIFIER_TYPENAME_P (name)
3020 && dependent_type_p (TREE_TYPE (name))));
3022 bases_dependent_p = false;
3023 if (processing_template_decl)
3024 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3025 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3027 if (dependent_type_p (TREE_TYPE (base_binfo)))
3029 bases_dependent_p = true;
3035 /* From [namespace.udecl]:
3037 A using-declaration used as a member-declaration shall refer to a
3038 member of a base class of the class being defined.
3040 In general, we cannot check this constraint in a template because
3041 we do not know the entire set of base classes of the current
3042 class type. However, if all of the base classes are
3043 non-dependent, then we can avoid delaying the check until
3045 if (!scope_dependent_p)
3048 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3049 if (b_kind < bk_proper_base)
3051 if (!bases_dependent_p)
3053 error_not_base_type (scope, current_class_type);
3057 else if (!name_dependent_p)
3059 decl = lookup_member (binfo, name, 0, false);
3062 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3066 /* The binfo from which the functions came does not matter. */
3067 if (BASELINK_P (decl))
3068 decl = BASELINK_FUNCTIONS (decl);
3072 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3073 USING_DECL_DECLS (value) = decl;
3074 USING_DECL_SCOPE (value) = scope;
3075 DECL_DEPENDENT_P (value) = !decl;
3081 /* Return the binding value for name in scope. */
3084 namespace_binding (tree name, tree scope)
3086 cxx_binding *binding;
3088 if (SCOPE_FILE_SCOPE_P (scope))
3089 scope = global_namespace;
3091 /* Unnecessary for the global namespace because it can't be an alias. */
3092 scope = ORIGINAL_NAMESPACE (scope);
3094 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3096 return binding ? binding->value : NULL_TREE;
3099 /* Set the binding value for name in scope. */
3102 set_namespace_binding (tree name, tree scope, tree val)
3106 timevar_push (TV_NAME_LOOKUP);
3107 if (scope == NULL_TREE)
3108 scope = global_namespace;
3109 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3110 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3113 supplement_binding (b, val);
3114 timevar_pop (TV_NAME_LOOKUP);
3117 /* Set the context of a declaration to scope. Complain if we are not
3121 set_decl_namespace (tree decl, tree scope, bool friendp)
3125 /* Get rid of namespace aliases. */
3126 scope = ORIGINAL_NAMESPACE (scope);
3128 /* It is ok for friends to be qualified in parallel space. */
3129 if (!friendp && !is_ancestor (current_namespace, scope))
3130 error ("declaration of %qD not in a namespace surrounding %qD",
3132 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3134 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3135 if (scope == current_namespace)
3137 if (at_namespace_scope_p ())
3138 error ("explicit qualification in declaration of %qD",
3143 /* See whether this has been declared in the namespace. */
3144 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3145 if (old == error_mark_node)
3146 /* No old declaration at all. */
3148 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3149 if (TREE_CODE (old) == TREE_LIST)
3151 error ("reference to %qD is ambiguous", decl);
3152 print_candidates (old);
3155 if (!is_overloaded_fn (decl))
3157 /* We might have found OLD in an inline namespace inside SCOPE. */
3158 if (TREE_CODE (decl) == TREE_CODE (old))
3159 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3160 /* Don't compare non-function decls with decls_match here, since
3161 it can't check for the correct constness at this
3162 point. pushdecl will find those errors later. */
3165 /* Since decl is a function, old should contain a function decl. */
3166 if (!is_overloaded_fn (old))
3168 /* A template can be explicitly specialized in any namespace. */
3169 if (processing_explicit_instantiation)
3171 if (processing_template_decl || processing_specialization)
3172 /* We have not yet called push_template_decl to turn a
3173 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3174 match. But, we'll check later, when we construct the
3177 /* Instantiations or specializations of templates may be declared as
3178 friends in any namespace. */
3179 if (friendp && DECL_USE_TEMPLATE (decl))
3181 if (is_overloaded_fn (old))
3183 tree found = NULL_TREE;
3185 for (; elt; elt = OVL_NEXT (elt))
3187 tree ofn = OVL_CURRENT (elt);
3188 /* Adjust DECL_CONTEXT first so decls_match will return true
3189 if DECL will match a declaration in an inline namespace. */
3190 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3191 if (decls_match (decl, ofn))
3193 if (found && !decls_match (found, ofn))
3195 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3196 error ("reference to %qD is ambiguous", decl);
3197 print_candidates (old);
3205 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3207 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3213 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3214 if (decls_match (decl, old))
3218 /* It didn't work, go back to the explicit scope. */
3219 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3221 error ("%qD should have been declared inside %qD", decl, scope);
3224 /* Return the namespace where the current declaration is declared. */
3227 current_decl_namespace (void)
3230 /* If we have been pushed into a different namespace, use it. */
3231 if (!VEC_empty (tree, decl_namespace_list))
3232 return VEC_last (tree, decl_namespace_list);
3234 if (current_class_type)
3235 result = decl_namespace_context (current_class_type);
3236 else if (current_function_decl)
3237 result = decl_namespace_context (current_function_decl);
3239 result = current_namespace;
3243 /* Process any ATTRIBUTES on a namespace definition. Currently only
3244 attribute visibility is meaningful, which is a property of the syntactic
3245 block rather than the namespace as a whole, so we don't touch the
3246 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3249 handle_namespace_attrs (tree ns, tree attributes)
3252 bool saw_vis = false;
3254 for (d = attributes; d; d = TREE_CHAIN (d))
3256 tree name = TREE_PURPOSE (d);
3257 tree args = TREE_VALUE (d);
3259 if (is_attribute_p ("visibility", name))
3261 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3262 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3264 warning (OPT_Wattributes,
3265 "%qD attribute requires a single NTBS argument",
3270 if (!TREE_PUBLIC (ns))
3271 warning (OPT_Wattributes,
3272 "%qD attribute is meaningless since members of the "
3273 "anonymous namespace get local symbols", name);
3275 push_visibility (TREE_STRING_POINTER (x), 1);
3280 warning (OPT_Wattributes, "%qD attribute directive ignored",
3289 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3290 select a name that is unique to this compilation unit. */
3293 push_namespace (tree name)
3297 int implicit_use = 0;
3300 timevar_push (TV_NAME_LOOKUP);
3302 /* We should not get here if the global_namespace is not yet constructed
3303 nor if NAME designates the global namespace: The global scope is
3304 constructed elsewhere. */
3305 gcc_assert (global_namespace != NULL && name != global_scope_name);
3309 name = get_anonymous_namespace_name();
3310 d = IDENTIFIER_NAMESPACE_VALUE (name);
3312 /* Reopening anonymous namespace. */
3318 /* Check whether this is an extended namespace definition. */
3319 d = IDENTIFIER_NAMESPACE_VALUE (name);
3320 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3323 if (DECL_NAMESPACE_ALIAS (d))
3325 error ("namespace alias %qD not allowed here, assuming %qD",
3326 d, DECL_NAMESPACE_ALIAS (d));
3327 d = DECL_NAMESPACE_ALIAS (d);
3334 /* Make a new namespace, binding the name to it. */
3335 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3336 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3337 /* The name of this namespace is not visible to other translation
3338 units if it is an anonymous namespace or member thereof. */
3339 if (anon || decl_anon_ns_mem_p (current_namespace))
3340 TREE_PUBLIC (d) = 0;
3342 TREE_PUBLIC (d) = 1;
3346 /* Clear DECL_NAME for the benefit of debugging back ends. */
3347 SET_DECL_ASSEMBLER_NAME (d, name);
3348 DECL_NAME (d) = NULL_TREE;
3350 begin_scope (sk_namespace, d);
3353 resume_scope (NAMESPACE_LEVEL (d));
3356 do_using_directive (d);
3357 /* Enter the name space. */
3358 current_namespace = d;
3360 timevar_pop (TV_NAME_LOOKUP);
3363 /* Pop from the scope of the current namespace. */
3366 pop_namespace (void)
3368 gcc_assert (current_namespace != global_namespace);
3369 current_namespace = CP_DECL_CONTEXT (current_namespace);
3370 /* The binding level is not popped, as it might be re-opened later. */
3374 /* Push into the scope of the namespace NS, even if it is deeply
3375 nested within another namespace. */
3378 push_nested_namespace (tree ns)
3380 if (ns == global_namespace)
3381 push_to_top_level ();
3384 push_nested_namespace (CP_DECL_CONTEXT (ns));
3385 push_namespace (DECL_NAME (ns));
3389 /* Pop back from the scope of the namespace NS, which was previously
3390 entered with push_nested_namespace. */
3393 pop_nested_namespace (tree ns)
3395 timevar_push (TV_NAME_LOOKUP);
3396 gcc_assert (current_namespace == ns);
3397 while (ns != global_namespace)
3400 ns = CP_DECL_CONTEXT (ns);
3403 pop_from_top_level ();
3404 timevar_pop (TV_NAME_LOOKUP);
3407 /* Temporarily set the namespace for the current declaration. */
3410 push_decl_namespace (tree decl)
3412 if (TREE_CODE (decl) != NAMESPACE_DECL)
3413 decl = decl_namespace_context (decl);
3414 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3417 /* [namespace.memdef]/2 */
3420 pop_decl_namespace (void)
3422 VEC_pop (tree, decl_namespace_list);
3425 /* Return the namespace that is the common ancestor
3426 of two given namespaces. */
3429 namespace_ancestor (tree ns1, tree ns2)
3431 timevar_push (TV_NAME_LOOKUP);
3432 if (is_ancestor (ns1, ns2))
3433 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3434 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3435 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3438 /* Process a namespace-alias declaration. */
3441 do_namespace_alias (tree alias, tree name_space)
3443 if (name_space == error_mark_node)
3446 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3448 name_space = ORIGINAL_NAMESPACE (name_space);
3450 /* Build the alias. */
3451 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3452 DECL_NAMESPACE_ALIAS (alias) = name_space;
3453 DECL_EXTERNAL (alias) = 1;
3454 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3457 /* Emit debug info for namespace alias. */
3458 if (!building_stmt_tree ())
3459 (*debug_hooks->global_decl) (alias);
3462 /* Like pushdecl, only it places X in the current namespace,
3466 pushdecl_namespace_level (tree x, bool is_friend)
3468 struct cp_binding_level *b = current_binding_level;
3471 timevar_push (TV_NAME_LOOKUP);
3472 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3474 /* Now, the type_shadowed stack may screw us. Munge it so it does
3476 if (TREE_CODE (t) == TYPE_DECL)
3478 tree name = DECL_NAME (t);
3480 tree *ptr = (tree *)0;
3481 for (; !global_scope_p (b); b = b->level_chain)
3483 tree shadowed = b->type_shadowed;
3484 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3485 if (TREE_PURPOSE (shadowed) == name)
3487 ptr = &TREE_VALUE (shadowed);
3488 /* Can't break out of the loop here because sometimes
3489 a binding level will have duplicate bindings for
3490 PT names. It's gross, but I haven't time to fix it. */
3493 newval = TREE_TYPE (t);
3494 if (ptr == (tree *)0)
3496 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3497 up here if this is changed to an assertion. --KR */
3498 SET_IDENTIFIER_TYPE_VALUE (name, t);
3505 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3508 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3509 directive is not directly from the source. Also find the common
3510 ancestor and let our users know about the new namespace */
3512 add_using_namespace (tree user, tree used, bool indirect)
3515 timevar_push (TV_NAME_LOOKUP);
3516 /* Using oneself is a no-op. */
3519 timevar_pop (TV_NAME_LOOKUP);
3522 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3523 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3524 /* Check if we already have this. */
3525 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3529 /* Promote to direct usage. */
3530 TREE_INDIRECT_USING (t) = 0;
3531 timevar_pop (TV_NAME_LOOKUP);
3535 /* Add used to the user's using list. */
3536 DECL_NAMESPACE_USING (user)
3537 = tree_cons (used, namespace_ancestor (user, used),
3538 DECL_NAMESPACE_USING (user));
3540 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3542 /* Add user to the used's users list. */
3543 DECL_NAMESPACE_USERS (used)
3544 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3546 /* Recursively add all namespaces used. */
3547 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3548 /* indirect usage */
3549 add_using_namespace (user, TREE_PURPOSE (t), 1);
3551 /* Tell everyone using us about the new used namespaces. */
3552 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3553 add_using_namespace (TREE_PURPOSE (t), used, 1);
3554 timevar_pop (TV_NAME_LOOKUP);
3557 /* Process a using-declaration not appearing in class or local scope. */
3560 do_toplevel_using_decl (tree decl, tree scope, tree name)
3562 tree oldval, oldtype, newval, newtype;
3563 tree orig_decl = decl;
3564 cxx_binding *binding;
3566 decl = validate_nonmember_using_decl (decl, scope, name);
3567 if (decl == NULL_TREE)
3570 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3572 oldval = binding->value;
3573 oldtype = binding->type;
3575 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3577 /* Emit debug info. */
3578 if (!processing_template_decl)
3579 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3581 /* Copy declarations found. */
3583 binding->value = newval;
3585 binding->type = newtype;
3588 /* Process a using-directive. */
3591 do_using_directive (tree name_space)
3593 tree context = NULL_TREE;
3595 if (name_space == error_mark_node)
3598 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3600 if (building_stmt_tree ())
3601 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3602 name_space = ORIGINAL_NAMESPACE (name_space);
3604 if (!toplevel_bindings_p ())
3606 push_using_directive (name_space);
3611 add_using_namespace (current_namespace, name_space, 0);
3612 if (current_namespace != global_namespace)
3613 context = current_namespace;
3615 /* Emit debugging info. */
3616 if (!processing_template_decl)
3617 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3622 /* Deal with a using-directive seen by the parser. Currently we only
3623 handle attributes here, since they cannot appear inside a template. */
3626 parse_using_directive (tree name_space, tree attribs)
3630 do_using_directive (name_space);
3632 for (a = attribs; a; a = TREE_CHAIN (a))
3634 tree name = TREE_PURPOSE (a);
3635 if (is_attribute_p ("strong", name))
3637 if (!toplevel_bindings_p ())
3638 error ("strong using only meaningful at namespace scope");
3639 else if (name_space != error_mark_node)
3641 if (!is_ancestor (current_namespace, name_space))
3642 error ("current namespace %qD does not enclose strongly used namespace %qD",
3643 current_namespace, name_space);
3644 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3645 = tree_cons (current_namespace, 0,
3646 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3650 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3654 /* Like pushdecl, only it places X in the global scope if appropriate.
3655 Calls cp_finish_decl to register the variable, initializing it with
3656 *INIT, if INIT is non-NULL. */
3659 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3661 timevar_push (TV_NAME_LOOKUP);
3662 push_to_top_level ();
3663 x = pushdecl_namespace_level (x, is_friend);
3665 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3666 pop_from_top_level ();
3667 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3670 /* Like pushdecl, only it places X in the global scope if appropriate. */
3673 pushdecl_top_level (tree x)
3675 return pushdecl_top_level_1 (x, NULL, false);
3678 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3681 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3683 return pushdecl_top_level_1 (x, NULL, is_friend);
3686 /* Like pushdecl, only it places X in the global scope if
3687 appropriate. Calls cp_finish_decl to register the variable,
3688 initializing it with INIT. */
3691 pushdecl_top_level_and_finish (tree x, tree init)
3693 return pushdecl_top_level_1 (x, &init, false);
3696 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3697 duplicates. The first list becomes the tail of the result.
3699 The algorithm is O(n^2). We could get this down to O(n log n) by
3700 doing a sort on the addresses of the functions, if that becomes
3704 merge_functions (tree s1, tree s2)
3706 for (; s2; s2 = OVL_NEXT (s2))
3708 tree fn2 = OVL_CURRENT (s2);
3711 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3713 tree fn1 = OVL_CURRENT (fns1);
3715 /* If the function from S2 is already in S1, there is no
3716 need to add it again. For `extern "C"' functions, we
3717 might have two FUNCTION_DECLs for the same function, in
3718 different namespaces, but let's leave them in in case
3719 they have different default arguments. */
3724 /* If we exhausted all of the functions in S1, FN2 is new. */
3726 s1 = build_overload (fn2, s1);
3731 /* Returns TRUE iff OLD and NEW are the same entity.
3733 3 [basic]/3: An entity is a value, object, reference, function,
3734 enumerator, type, class member, template, template specialization,
3735 namespace, parameter pack, or this.
3737 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3738 in two different namespaces, and the declarations do not declare the
3739 same entity and do not declare functions, the use of the name is
3743 same_entity_p (tree one, tree two)
3749 if (TREE_CODE (one) == TYPE_DECL
3750 && TREE_CODE (two) == TYPE_DECL
3751 && same_type_p (TREE_TYPE (one), TREE_TYPE (two)))
3756 /* This should return an error not all definitions define functions.
3757 It is not an error if we find two functions with exactly the
3758 same signature, only if these are selected in overload resolution.
3759 old is the current set of bindings, new_binding the freshly-found binding.
3760 XXX Do we want to give *all* candidates in case of ambiguity?
3761 XXX In what way should I treat extern declarations?
3762 XXX I don't want to repeat the entire duplicate_decls here */
3765 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3768 gcc_assert (old != NULL);
3770 /* Copy the type. */
3771 type = new_binding->type;
3772 if (LOOKUP_NAMESPACES_ONLY (flags)
3773 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3776 /* Copy the value. */
3777 val = new_binding->value;
3780 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3783 switch (TREE_CODE (val))
3786 /* If we expect types or namespaces, and not templates,
3787 or this is not a template class. */
3788 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3789 && !DECL_CLASS_TEMPLATE_P (val)))
3793 if (LOOKUP_NAMESPACES_ONLY (flags)
3794 || (type && (flags & LOOKUP_PREFER_TYPES)))
3797 case NAMESPACE_DECL:
3798 if (LOOKUP_TYPES_ONLY (flags))
3802 /* Ignore built-in functions that are still anticipated. */
3803 if (LOOKUP_QUALIFIERS_ONLY (flags))
3807 if (LOOKUP_QUALIFIERS_ONLY (flags))
3812 /* If val is hidden, shift down any class or enumeration name. */
3821 else if (val && !same_entity_p (val, old->value))
3823 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3824 old->value = merge_functions (old->value, val);
3827 old->value = tree_cons (NULL_TREE, old->value,
3828 build_tree_list (NULL_TREE, val));
3829 TREE_TYPE (old->value) = error_mark_node;
3835 else if (type && old->type != type)
3837 old->type = tree_cons (NULL_TREE, old->type,
3838 build_tree_list (NULL_TREE, type));
3839 TREE_TYPE (old->type) = error_mark_node;
3843 /* Return the declarations that are members of the namespace NS. */
3846 cp_namespace_decls (tree ns)
3848 return NAMESPACE_LEVEL (ns)->names;
3851 /* Combine prefer_type and namespaces_only into flags. */
3854 lookup_flags (int prefer_type, int namespaces_only)
3856 if (namespaces_only)
3857 return LOOKUP_PREFER_NAMESPACES;
3858 if (prefer_type > 1)
3859 return LOOKUP_PREFER_TYPES;
3860 if (prefer_type > 0)
3861 return LOOKUP_PREFER_BOTH;
3865 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3866 ignore it or not. Subroutine of lookup_name_real and
3867 lookup_type_scope. */
3870 qualify_lookup (tree val, int flags)
3872 if (val == NULL_TREE)
3874 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3876 if ((flags & LOOKUP_PREFER_TYPES)
3877 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3879 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3881 /* In unevaluated context, look past normal capture fields. */
3882 if (cp_unevaluated_operand && TREE_CODE (val) == FIELD_DECL
3883 && DECL_NORMAL_CAPTURE_P (val))
3885 /* None of the lookups that use qualify_lookup want the op() from the
3886 lambda; they want the one from the enclosing class. */
3887 if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
3892 /* Given a lookup that returned VAL, decide if we want to ignore it or
3893 not based on DECL_ANTICIPATED. */
3896 hidden_name_p (tree val)
3899 && DECL_LANG_SPECIFIC (val)
3900 && DECL_ANTICIPATED (val))
3905 /* Remove any hidden friend functions from a possibly overloaded set
3909 remove_hidden_names (tree fns)
3914 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3916 else if (TREE_CODE (fns) == OVERLOAD)
3920 for (o = fns; o; o = OVL_NEXT (o))
3921 if (hidden_name_p (OVL_CURRENT (o)))
3927 for (o = fns; o; o = OVL_NEXT (o))
3928 if (!hidden_name_p (OVL_CURRENT (o)))
3929 n = build_overload (OVL_CURRENT (o), n);
3937 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
3938 lookup failed. Search through all available namespaces and print out
3939 possible candidates. */
3942 suggest_alternatives_for (location_t location, tree name)
3944 VEC(tree,heap) *candidates = NULL;
3945 VEC(tree,heap) *namespaces_to_search = NULL;
3946 int max_to_search = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
3951 VEC_safe_push (tree, heap, namespaces_to_search, global_namespace);
3953 while (!VEC_empty (tree, namespaces_to_search)
3954 && n_searched < max_to_search)
3956 tree scope = VEC_pop (tree, namespaces_to_search);
3957 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3958 struct cp_binding_level *level = NAMESPACE_LEVEL (scope);
3960 /* Look in this namespace. */
3961 qualified_lookup_using_namespace (name, scope, &binding, 0);
3966 VEC_safe_push (tree, heap, candidates, binding.value);
3968 /* Add child namespaces. */
3969 for (t = level->namespaces; t; t = DECL_CHAIN (t))
3970 VEC_safe_push (tree, heap, namespaces_to_search, t);
3973 /* If we stopped before we could examine all namespaces, inform the
3974 user. Do this even if we don't have any candidates, since there
3975 might be more candidates further down that we weren't able to
3977 if (n_searched >= max_to_search
3978 && !VEC_empty (tree, namespaces_to_search))
3980 "maximum limit of %d namespaces searched for %qE",
3981 max_to_search, name);
3983 VEC_free (tree, heap, namespaces_to_search);
3985 /* Nothing useful to report. */
3986 if (VEC_empty (tree, candidates))
3989 inform_n (location, VEC_length (tree, candidates),
3990 "suggested alternative:",
3991 "suggested alternatives:");
3993 FOR_EACH_VEC_ELT (tree, candidates, ix, t)
3994 inform (location_of (t), " %qE", t);
3996 VEC_free (tree, heap, candidates);
3999 /* Unscoped lookup of a global: iterate over current namespaces,
4000 considering using-directives. */
4003 unqualified_namespace_lookup (tree name, int flags)
4005 tree initial = current_decl_namespace ();
4006 tree scope = initial;
4008 struct cp_binding_level *level;
4009 tree val = NULL_TREE;
4011 timevar_push (TV_NAME_LOOKUP);
4013 for (; !val; scope = CP_DECL_CONTEXT (scope))
4015 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4017 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4020 ambiguous_decl (&binding, b, flags);
4022 /* Add all _DECLs seen through local using-directives. */
4023 for (level = current_binding_level;
4024 level->kind != sk_namespace;
4025 level = level->level_chain)
4026 if (!lookup_using_namespace (name, &binding, level->using_directives,
4028 /* Give up because of error. */
4029 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4031 /* Add all _DECLs seen through global using-directives. */
4032 /* XXX local and global using lists should work equally. */
4036 if (!lookup_using_namespace (name, &binding,
4037 DECL_NAMESPACE_USING (siter),
4039 /* Give up because of error. */
4040 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4041 if (siter == scope) break;
4042 siter = CP_DECL_CONTEXT (siter);
4045 val = binding.value;
4046 if (scope == global_namespace)
4049 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4052 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4053 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4056 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4057 declaration found. If no suitable declaration can be found,
4058 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4059 neither a class-type nor a namespace a diagnostic is issued. */
4062 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
4067 if (TREE_CODE (scope) == NAMESPACE_DECL)
4069 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4071 flags |= LOOKUP_COMPLAIN;
4073 flags |= LOOKUP_PREFER_TYPES;
4074 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
4077 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
4078 t = lookup_enumerator (scope, name);
4079 else if (is_class_type (scope, complain))
4080 t = lookup_member (scope, name, 2, is_type_p);
4083 return error_mark_node;
4087 /* Subroutine of unqualified_namespace_lookup:
4088 Add the bindings of NAME in used namespaces to VAL.
4089 We are currently looking for names in namespace SCOPE, so we
4090 look through USINGS for using-directives of namespaces
4091 which have SCOPE as a common ancestor with the current scope.
4092 Returns false on errors. */
4095 lookup_using_namespace (tree name, struct scope_binding *val,
4096 tree usings, tree scope, int flags)
4099 timevar_push (TV_NAME_LOOKUP);
4100 /* Iterate over all used namespaces in current, searching for using
4101 directives of scope. */
4102 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4103 if (TREE_VALUE (iter) == scope)
4105 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
4107 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
4108 /* Resolve ambiguities. */
4110 ambiguous_decl (val, val1, flags);
4112 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
4115 /* Returns true iff VEC contains TARGET. */
4118 tree_vec_contains (VEC(tree,gc)* vec, tree target)
4122 FOR_EACH_VEC_ELT (tree,vec,i,elt)
4129 Accepts the NAME to lookup and its qualifying SCOPE.
4130 Returns the name/type pair found into the cxx_binding *RESULT,
4131 or false on error. */
4134 qualified_lookup_using_namespace (tree name, tree scope,
4135 struct scope_binding *result, int flags)
4137 /* Maintain a list of namespaces visited... */
4138 VEC(tree,gc) *seen = NULL;
4139 VEC(tree,gc) *seen_inline = NULL;
4140 /* ... and a list of namespace yet to see. */
4141 VEC(tree,gc) *todo = NULL;
4142 VEC(tree,gc) *todo_maybe = NULL;
4143 VEC(tree,gc) *todo_inline = NULL;
4145 timevar_push (TV_NAME_LOOKUP);
4146 /* Look through namespace aliases. */
4147 scope = ORIGINAL_NAMESPACE (scope);
4149 /* Algorithm: Starting with SCOPE, walk through the the set of used
4150 namespaces. For each used namespace, look through its inline
4151 namespace set for any bindings and usings. If no bindings are found,
4152 add any usings seen to the set of used namespaces. */
4153 VEC_safe_push (tree, gc, todo, scope);
4155 while (VEC_length (tree, todo))
4158 scope = VEC_pop (tree, todo);
4159 if (tree_vec_contains (seen, scope))
4161 VEC_safe_push (tree, gc, seen, scope);
4162 VEC_safe_push (tree, gc, todo_inline, scope);
4165 while (VEC_length (tree, todo_inline))
4167 cxx_binding *binding;
4169 scope = VEC_pop (tree, todo_inline);
4170 if (tree_vec_contains (seen_inline, scope))
4172 VEC_safe_push (tree, gc, seen_inline, scope);
4175 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4179 ambiguous_decl (result, binding, flags);
4182 for (usings = DECL_NAMESPACE_USING (scope); usings;
4183 usings = TREE_CHAIN (usings))
4184 if (!TREE_INDIRECT_USING (usings))
4186 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4187 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4189 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4194 VEC_truncate (tree, todo_maybe, 0);
4196 while (VEC_length (tree, todo_maybe))
4197 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4199 VEC_free (tree,gc,todo);
4200 VEC_free (tree,gc,todo_maybe);
4201 VEC_free (tree,gc,todo_inline);
4202 VEC_free (tree,gc,seen);
4203 VEC_free (tree,gc,seen_inline);
4204 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
4207 /* Subroutine of outer_binding.
4209 Returns TRUE if BINDING is a binding to a template parameter of
4210 SCOPE. In that case SCOPE is the scope of a primary template
4211 parameter -- in the sense of G++, i.e, a template that has its own
4214 Returns FALSE otherwise. */
4217 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4222 if (!binding || !scope)
4225 binding_value = binding->value ? binding->value : binding->type;
4228 && scope->this_entity
4229 && get_template_info (scope->this_entity)
4230 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4231 (get_template_info (scope->this_entity)))
4232 && parameter_of_template_p (binding_value,
4233 TI_TEMPLATE (get_template_info \
4234 (scope->this_entity))));
4237 /* Return the innermost non-namespace binding for NAME from a scope
4238 containing BINDING, or, if BINDING is NULL, the current scope.
4239 Please note that for a given template, the template parameters are
4240 considered to be in the scope containing the current scope.
4241 If CLASS_P is false, then class bindings are ignored. */
4244 outer_binding (tree name,
4245 cxx_binding *binding,
4250 cxx_scope *outer_scope;
4254 scope = binding->scope->level_chain;
4255 outer = binding->previous;
4259 scope = current_binding_level;
4260 outer = IDENTIFIER_BINDING (name);
4262 outer_scope = outer ? outer->scope : NULL;
4264 /* Because we create class bindings lazily, we might be missing a
4265 class binding for NAME. If there are any class binding levels
4266 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4267 declared, we must lookup NAME in those class scopes. */
4269 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4271 if (scope->kind == sk_class)
4273 cxx_binding *class_binding;
4275 class_binding = get_class_binding (name, scope);
4278 /* Thread this new class-scope binding onto the
4279 IDENTIFIER_BINDING list so that future lookups
4281 class_binding->previous = outer;
4283 binding->previous = class_binding;
4285 IDENTIFIER_BINDING (name) = class_binding;
4286 return class_binding;
4289 /* If we are in a member template, the template parms of the member
4290 template are considered to be inside the scope of the containing
4291 class, but within G++ the class bindings are all pushed between the
4292 template parms and the function body. So if the outer binding is
4293 a template parm for the current scope, return it now rather than
4294 look for a class binding. */
4295 if (outer_scope && outer_scope->kind == sk_template_parms
4296 && binding_to_template_parms_of_scope_p (outer, scope))
4299 scope = scope->level_chain;
4305 /* Return the innermost block-scope or class-scope value binding for
4306 NAME, or NULL_TREE if there is no such binding. */
4309 innermost_non_namespace_value (tree name)
4311 cxx_binding *binding;
4312 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4313 return binding ? binding->value : NULL_TREE;
4316 /* Look up NAME in the current binding level and its superiors in the
4317 namespace of variables, functions and typedefs. Return a ..._DECL
4318 node of some kind representing its definition if there is only one
4319 such declaration, or return a TREE_LIST with all the overloaded
4320 definitions if there are many, or return 0 if it is undefined.
4321 Hidden name, either friend declaration or built-in function, are
4324 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4325 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4326 Otherwise we prefer non-TYPE_DECLs.
4328 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4329 BLOCK_P is false, bindings in block scopes are ignored. */
4332 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4333 int namespaces_only, int flags)
4336 tree val = NULL_TREE;
4338 timevar_push (TV_NAME_LOOKUP);
4339 /* Conversion operators are handled specially because ordinary
4340 unqualified name lookup will not find template conversion
4342 if (IDENTIFIER_TYPENAME_P (name))
4344 struct cp_binding_level *level;
4346 for (level = current_binding_level;
4347 level && level->kind != sk_namespace;
4348 level = level->level_chain)
4353 /* A conversion operator can only be declared in a class
4355 if (level->kind != sk_class)
4358 /* Lookup the conversion operator in the class. */
4359 class_type = level->this_entity;
4360 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4362 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4365 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4368 flags |= lookup_flags (prefer_type, namespaces_only);
4370 /* First, look in non-namespace scopes. */
4372 if (current_class_type == NULL_TREE)
4375 if (block_p || !nonclass)
4376 for (iter = outer_binding (name, NULL, !nonclass);
4378 iter = outer_binding (name, iter, !nonclass))
4382 /* Skip entities we don't want. */
4383 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4386 /* If this is the kind of thing we're looking for, we're done. */
4387 if (qualify_lookup (iter->value, flags))
4388 binding = iter->value;
4389 else if ((flags & LOOKUP_PREFER_TYPES)
4390 && qualify_lookup (iter->type, flags))
4391 binding = iter->type;
4393 binding = NULL_TREE;
4397 if (hidden_name_p (binding))
4399 /* A non namespace-scope binding can only be hidden in the
4400 presence of a local class, due to friend declarations.
4402 In particular, consider:
4410 B* b; // error: B is hidden
4411 C* c; // OK, finds ::C
4414 B *b; // error: B is hidden
4415 C *c; // OK, finds ::C
4420 The standard says that "B" is a local class in "f"
4421 (but not nested within "A") -- but that name lookup
4422 for "B" does not find this declaration until it is
4423 declared directly with "f".
4429 If a friend declaration appears in a local class and
4430 the name specified is an unqualified name, a prior
4431 declaration is looked up without considering scopes
4432 that are outside the innermost enclosing non-class
4433 scope. For a friend function declaration, if there is
4434 no prior declaration, the program is ill-formed. For a
4435 friend class declaration, if there is no prior
4436 declaration, the class that is specified belongs to the
4437 innermost enclosing non-class scope, but if it is
4438 subsequently referenced, its name is not found by name
4439 lookup until a matching declaration is provided in the
4440 innermost enclosing nonclass scope.
4442 So just keep looking for a non-hidden binding.
4444 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4452 /* Now lookup in namespace scopes. */
4454 val = unqualified_namespace_lookup (name, flags);
4456 /* If we have a single function from a using decl, pull it out. */
4457 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4458 val = OVL_FUNCTION (val);
4460 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4464 lookup_name_nonclass (tree name)
4466 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4470 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4473 lookup_arg_dependent (name,
4474 lookup_name_real (name, 0, 1, block_p, 0,
4480 lookup_name (tree name)
4482 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4486 lookup_name_prefer_type (tree name, int prefer_type)
4488 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4489 0, LOOKUP_COMPLAIN);
4492 /* Look up NAME for type used in elaborated name specifier in
4493 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4494 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4495 name, more scopes are checked if cleanup or template parameter
4496 scope is encountered.
4498 Unlike lookup_name_real, we make sure that NAME is actually
4499 declared in the desired scope, not from inheritance, nor using
4500 directive. For using declaration, there is DR138 still waiting
4501 to be resolved. Hidden name coming from an earlier friend
4502 declaration is also returned.
4504 A TYPE_DECL best matching the NAME is returned. Catching error
4505 and issuing diagnostics are caller's responsibility. */
4508 lookup_type_scope (tree name, tag_scope scope)
4510 cxx_binding *iter = NULL;
4511 tree val = NULL_TREE;
4513 timevar_push (TV_NAME_LOOKUP);
4515 /* Look in non-namespace scope first. */
4516 if (current_binding_level->kind != sk_namespace)
4517 iter = outer_binding (name, NULL, /*class_p=*/ true);
4518 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4520 /* Check if this is the kind of thing we're looking for.
4521 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4522 base class. For ITER->VALUE, we can simply use
4523 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4526 We check ITER->TYPE before ITER->VALUE in order to handle
4527 typedef struct C {} C;
4530 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4531 && (scope != ts_current
4532 || LOCAL_BINDING_P (iter)
4533 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4535 else if ((scope != ts_current
4536 || !INHERITED_VALUE_BINDING_P (iter))
4537 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4544 /* Look in namespace scope. */
4547 iter = cxx_scope_find_binding_for_name
4548 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4552 /* If this is the kind of thing we're looking for, we're done. */
4553 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4555 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4561 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4562 and template parameter scopes. */
4565 struct cp_binding_level *b = current_binding_level;
4568 if (iter->scope == b)
4569 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4571 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4572 || b->kind == sk_function_parms)
4574 else if (b->kind == sk_class
4575 && scope == ts_within_enclosing_non_class)
4582 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4585 /* Similar to `lookup_name' but look only in the innermost non-class
4589 lookup_name_innermost_nonclass_level (tree name)
4591 struct cp_binding_level *b;
4594 timevar_push (TV_NAME_LOOKUP);
4595 b = innermost_nonclass_level ();
4597 if (b->kind == sk_namespace)
4599 t = IDENTIFIER_NAMESPACE_VALUE (name);
4601 /* extern "C" function() */
4602 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4605 else if (IDENTIFIER_BINDING (name)
4606 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4608 cxx_binding *binding;
4609 binding = IDENTIFIER_BINDING (name);
4612 if (binding->scope == b
4613 && !(TREE_CODE (binding->value) == VAR_DECL
4614 && DECL_DEAD_FOR_LOCAL (binding->value)))
4615 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4617 if (b->kind == sk_cleanup)
4624 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4627 /* Returns true iff DECL is a block-scope extern declaration of a function
4631 is_local_extern (tree decl)
4633 cxx_binding *binding;
4635 /* For functions, this is easy. */
4636 if (TREE_CODE (decl) == FUNCTION_DECL)
4637 return DECL_LOCAL_FUNCTION_P (decl);
4639 if (TREE_CODE (decl) != VAR_DECL)
4641 if (!current_function_decl)
4644 /* For variables, this is not easy. We need to look at the binding stack
4645 for the identifier to see whether the decl we have is a local. */
4646 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4647 binding && binding->scope->kind != sk_namespace;
4648 binding = binding->previous)
4649 if (binding->value == decl)
4650 return LOCAL_BINDING_P (binding);
4655 /* Like lookup_name_innermost_nonclass_level, but for types. */
4658 lookup_type_current_level (tree name)
4662 timevar_push (TV_NAME_LOOKUP);
4663 gcc_assert (current_binding_level->kind != sk_namespace);
4665 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4666 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4668 struct cp_binding_level *b = current_binding_level;
4671 if (purpose_member (name, b->type_shadowed))
4672 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4673 REAL_IDENTIFIER_TYPE_VALUE (name));
4674 if (b->kind == sk_cleanup)
4681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4684 /* [basic.lookup.koenig] */
4685 /* A nonzero return value in the functions below indicates an error. */
4691 VEC(tree,gc) *namespaces;
4692 VEC(tree,gc) *classes;
4696 static bool arg_assoc (struct arg_lookup*, tree);
4697 static bool arg_assoc_args (struct arg_lookup*, tree);
4698 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4699 static bool arg_assoc_type (struct arg_lookup*, tree);
4700 static bool add_function (struct arg_lookup *, tree);
4701 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4702 static bool arg_assoc_class_only (struct arg_lookup *, tree);
4703 static bool arg_assoc_bases (struct arg_lookup *, tree);
4704 static bool arg_assoc_class (struct arg_lookup *, tree);
4705 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4707 /* Add a function to the lookup structure.
4708 Returns true on error. */
4711 add_function (struct arg_lookup *k, tree fn)
4713 /* We used to check here to see if the function was already in the list,
4714 but that's O(n^2), which is just too expensive for function lookup.
4715 Now we deal with the occasional duplicate in joust. In doing this, we
4716 assume that the number of duplicates will be small compared to the
4717 total number of functions being compared, which should usually be the
4720 if (!is_overloaded_fn (fn))
4721 /* All names except those of (possibly overloaded) functions and
4722 function templates are ignored. */;
4723 else if (!k->functions)
4725 else if (fn == k->functions)
4729 k->functions = build_overload (fn, k->functions);
4730 if (TREE_CODE (k->functions) == OVERLOAD)
4731 OVL_ARG_DEPENDENT (k->functions) = true;
4737 /* Returns true iff CURRENT has declared itself to be an associated
4738 namespace of SCOPE via a strong using-directive (or transitive chain
4739 thereof). Both are namespaces. */
4742 is_associated_namespace (tree current, tree scope)
4744 VEC(tree,gc) *seen = make_tree_vector ();
4745 VEC(tree,gc) *todo = make_tree_vector ();
4751 if (scope == current)
4756 VEC_safe_push (tree, gc, seen, scope);
4757 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4758 if (!vec_member (TREE_PURPOSE (t), seen))
4759 VEC_safe_push (tree, gc, todo, TREE_PURPOSE (t));
4760 if (!VEC_empty (tree, todo))
4762 scope = VEC_last (tree, todo);
4763 VEC_pop (tree, todo);
4772 release_tree_vector (seen);
4773 release_tree_vector (todo);
4778 /* Add functions of a namespace to the lookup structure.
4779 Returns true on error. */
4782 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4786 if (vec_member (scope, k->namespaces))
4788 VEC_safe_push (tree, gc, k->namespaces, scope);
4790 /* Check out our super-users. */
4791 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4792 value = TREE_CHAIN (value))
4793 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4796 /* Also look down into inline namespaces. */
4797 for (value = DECL_NAMESPACE_USING (scope); value;
4798 value = TREE_CHAIN (value))
4799 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4800 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4803 value = namespace_binding (k->name, scope);
4807 for (; value; value = OVL_NEXT (value))
4809 /* We don't want to find arbitrary hidden functions via argument
4810 dependent lookup. We only want to find friends of associated
4811 classes, which we'll do via arg_assoc_class. */
4812 if (hidden_name_p (OVL_CURRENT (value)))
4815 if (add_function (k, OVL_CURRENT (value)))
4822 /* Adds everything associated with a template argument to the lookup
4823 structure. Returns true on error. */
4826 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4828 /* [basic.lookup.koenig]
4830 If T is a template-id, its associated namespaces and classes are
4831 ... the namespaces and classes associated with the types of the
4832 template arguments provided for template type parameters
4833 (excluding template template parameters); the namespaces in which
4834 any template template arguments are defined; and the classes in
4835 which any member templates used as template template arguments
4836 are defined. [Note: non-type template arguments do not
4837 contribute to the set of associated namespaces. ] */
4839 /* Consider first template template arguments. */
4840 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4841 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4843 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4845 tree ctx = CP_DECL_CONTEXT (arg);
4847 /* It's not a member template. */
4848 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4849 return arg_assoc_namespace (k, ctx);
4850 /* Otherwise, it must be member template. */
4852 return arg_assoc_class_only (k, ctx);
4854 /* It's an argument pack; handle it recursively. */
4855 else if (ARGUMENT_PACK_P (arg))
4857 tree args = ARGUMENT_PACK_ARGS (arg);
4858 int i, len = TREE_VEC_LENGTH (args);
4859 for (i = 0; i < len; ++i)
4860 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4865 /* It's not a template template argument, but it is a type template
4867 else if (TYPE_P (arg))
4868 return arg_assoc_type (k, arg);
4869 /* It's a non-type template argument. */
4874 /* Adds the class and its friends to the lookup structure.
4875 Returns true on error. */
4878 arg_assoc_class_only (struct arg_lookup *k, tree type)
4880 tree list, friends, context;
4882 /* Backend-built structures, such as __builtin_va_list, aren't
4883 affected by all this. */
4884 if (!CLASS_TYPE_P (type))
4887 context = decl_namespace_context (type);
4888 if (arg_assoc_namespace (k, context))
4891 complete_type (type);
4893 /* Process friends. */
4894 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4895 list = TREE_CHAIN (list))
4896 if (k->name == FRIEND_NAME (list))
4897 for (friends = FRIEND_DECLS (list); friends;
4898 friends = TREE_CHAIN (friends))
4900 tree fn = TREE_VALUE (friends);
4902 /* Only interested in global functions with potentially hidden
4903 (i.e. unqualified) declarations. */
4904 if (CP_DECL_CONTEXT (fn) != context)
4906 /* Template specializations are never found by name lookup.
4907 (Templates themselves can be found, but not template
4908 specializations.) */
4909 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4911 if (add_function (k, fn))
4918 /* Adds the class and its bases to the lookup structure.
4919 Returns true on error. */
4922 arg_assoc_bases (struct arg_lookup *k, tree type)
4924 if (arg_assoc_class_only (k, type))
4927 if (TYPE_BINFO (type))
4929 /* Process baseclasses. */
4930 tree binfo, base_binfo;
4933 for (binfo = TYPE_BINFO (type), i = 0;
4934 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4935 if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
4942 /* Adds everything associated with a class argument type to the lookup
4943 structure. Returns true on error.
4945 If T is a class type (including unions), its associated classes are: the
4946 class itself; the class of which it is a member, if any; and its direct
4947 and indirect base classes. Its associated namespaces are the namespaces
4948 of which its associated classes are members. Furthermore, if T is a
4949 class template specialization, its associated namespaces and classes
4950 also include: the namespaces and classes associated with the types of
4951 the template arguments provided for template type parameters (excluding
4952 template template parameters); the namespaces of which any template
4953 template arguments are members; and the classes of which any member
4954 templates used as template template arguments are members. [ Note:
4955 non-type template arguments do not contribute to the set of associated
4956 namespaces. --end note] */
4959 arg_assoc_class (struct arg_lookup *k, tree type)
4964 /* Backend build structures, such as __builtin_va_list, aren't
4965 affected by all this. */
4966 if (!CLASS_TYPE_P (type))
4969 if (vec_member (type, k->classes))
4971 VEC_safe_push (tree, gc, k->classes, type);
4973 if (TYPE_CLASS_SCOPE_P (type)
4974 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
4977 if (arg_assoc_bases (k, type))
4980 /* Process template arguments. */
4981 if (CLASSTYPE_TEMPLATE_INFO (type)
4982 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4984 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4985 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4986 if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
4993 /* Adds everything associated with a given type.
4994 Returns 1 on error. */
4997 arg_assoc_type (struct arg_lookup *k, tree type)
4999 /* As we do not get the type of non-type dependent expressions
5000 right, we can end up with such things without a type. */
5004 if (TYPE_PTRMEM_P (type))
5006 /* Pointer to member: associate class type and value type. */
5007 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
5009 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
5011 else switch (TREE_CODE (type))
5021 case FIXED_POINT_TYPE:
5026 if (TYPE_PTRMEMFUNC_P (type))
5027 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
5029 return arg_assoc_class (k, type);
5031 case REFERENCE_TYPE:
5033 return arg_assoc_type (k, TREE_TYPE (type));
5035 if (TYPE_CLASS_SCOPE_P (type)
5036 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5038 return arg_assoc_namespace (k, decl_namespace_context (type));
5040 /* The basetype is referenced in the first arg type, so just
5043 /* Associate the parameter types. */
5044 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
5046 /* Associate the return type. */
5047 return arg_assoc_type (k, TREE_TYPE (type));
5048 case TEMPLATE_TYPE_PARM:
5049 case BOUND_TEMPLATE_TEMPLATE_PARM:
5054 gcc_assert (type == unknown_type_node
5055 || type == init_list_type_node);
5057 case TYPE_PACK_EXPANSION:
5058 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
5066 /* Adds everything associated with arguments. Returns true on error. */
5069 arg_assoc_args (struct arg_lookup *k, tree args)
5071 for (; args; args = TREE_CHAIN (args))
5072 if (arg_assoc (k, TREE_VALUE (args)))
5077 /* Adds everything associated with an argument vector. Returns true
5081 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
5086 FOR_EACH_VEC_ELT (tree, args, ix, arg)
5087 if (arg_assoc (k, arg))
5092 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5095 arg_assoc (struct arg_lookup *k, tree n)
5097 if (n == error_mark_node)
5101 return arg_assoc_type (k, n);
5103 if (! type_unknown_p (n))
5104 return arg_assoc_type (k, TREE_TYPE (n));
5106 if (TREE_CODE (n) == ADDR_EXPR)
5107 n = TREE_OPERAND (n, 0);
5108 if (TREE_CODE (n) == COMPONENT_REF)
5109 n = TREE_OPERAND (n, 1);
5110 if (TREE_CODE (n) == OFFSET_REF)
5111 n = TREE_OPERAND (n, 1);
5112 while (TREE_CODE (n) == TREE_LIST)
5114 if (TREE_CODE (n) == BASELINK)
5115 n = BASELINK_FUNCTIONS (n);
5117 if (TREE_CODE (n) == FUNCTION_DECL)
5118 return arg_assoc_type (k, TREE_TYPE (n));
5119 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
5121 /* The working paper doesn't currently say how to handle template-id
5122 arguments. The sensible thing would seem to be to handle the list
5123 of template candidates like a normal overload set, and handle the
5124 template arguments like we do for class template
5126 tree templ = TREE_OPERAND (n, 0);
5127 tree args = TREE_OPERAND (n, 1);
5130 /* First the templates. */
5131 if (arg_assoc (k, templ))
5134 /* Now the arguments. */
5136 for (ix = TREE_VEC_LENGTH (args); ix--;)
5137 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
5140 else if (TREE_CODE (n) == OVERLOAD)
5142 for (; n; n = OVL_NEXT (n))
5143 if (arg_assoc_type (k, TREE_TYPE (OVL_CURRENT (n))))
5150 /* Performs Koenig lookup depending on arguments, where fns
5151 are the functions found in normal lookup. */
5154 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
5157 struct arg_lookup k;
5159 timevar_push (TV_NAME_LOOKUP);
5161 /* Remove any hidden friend functions from the list of functions
5162 found so far. They will be added back by arg_assoc_class as
5164 fns = remove_hidden_names (fns);
5169 k.classes = make_tree_vector ();
5171 /* We previously performed an optimization here by setting
5172 NAMESPACES to the current namespace when it was safe. However, DR
5173 164 says that namespaces that were already searched in the first
5174 stage of template processing are searched again (potentially
5175 picking up later definitions) in the second stage. */
5176 k.namespaces = make_tree_vector ();
5179 arg_assoc_namespace (&k, std_node);
5180 arg_assoc_args_vec (&k, args);
5185 && TREE_CODE (fns) != VAR_DECL
5186 && !is_overloaded_fn (fns))
5188 error ("argument dependent lookup finds %q+D", fns);
5189 error (" in call to %qD", name);
5190 fns = error_mark_node;
5193 release_tree_vector (k.classes);
5194 release_tree_vector (k.namespaces);
5196 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
5199 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5200 changed (i.e. there was already a directive), or the fresh
5201 TREE_LIST otherwise. */
5204 push_using_directive (tree used)
5206 tree ud = current_binding_level->using_directives;
5207 tree iter, ancestor;
5209 timevar_push (TV_NAME_LOOKUP);
5210 /* Check if we already have this. */
5211 if (purpose_member (used, ud) != NULL_TREE)
5212 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5214 ancestor = namespace_ancestor (current_decl_namespace (), used);
5215 ud = current_binding_level->using_directives;
5216 ud = tree_cons (used, ancestor, ud);
5217 current_binding_level->using_directives = ud;
5219 /* Recursively add all namespaces used. */
5220 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5221 push_using_directive (TREE_PURPOSE (iter));
5223 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
5226 /* The type TYPE is being declared. If it is a class template, or a
5227 specialization of a class template, do any processing required and
5228 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5229 being declared a friend. B is the binding level at which this TYPE
5232 Returns the TYPE_DECL for TYPE, which may have been altered by this
5236 maybe_process_template_type_declaration (tree type, int is_friend,
5239 tree decl = TYPE_NAME (type);
5241 if (processing_template_parmlist)
5242 /* You can't declare a new template type in a template parameter
5243 list. But, you can declare a non-template type:
5245 template <class A*> struct S;
5247 is a forward-declaration of `A'. */
5249 else if (b->kind == sk_namespace
5250 && current_binding_level->kind != sk_namespace)
5251 /* If this new type is being injected into a containing scope,
5252 then it's not a template type. */
5256 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5257 || TREE_CODE (type) == ENUMERAL_TYPE);
5259 if (processing_template_decl)
5261 /* This may change after the call to
5262 push_template_decl_real, but we want the original value. */
5263 tree name = DECL_NAME (decl);
5265 decl = push_template_decl_real (decl, is_friend);
5266 if (decl == error_mark_node)
5267 return error_mark_node;
5269 /* If the current binding level is the binding level for the
5270 template parameters (see the comment in
5271 begin_template_parm_list) and the enclosing level is a class
5272 scope, and we're not looking at a friend, push the
5273 declaration of the member class into the class scope. In the
5274 friend case, push_template_decl will already have put the
5275 friend into global scope, if appropriate. */
5276 if (TREE_CODE (type) != ENUMERAL_TYPE
5277 && !is_friend && b->kind == sk_template_parms
5278 && b->level_chain->kind == sk_class)
5280 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5282 if (!COMPLETE_TYPE_P (current_class_type))
5284 maybe_add_class_template_decl_list (current_class_type,
5285 type, /*friend_p=*/0);
5286 /* Put this UTD in the table of UTDs for the class. */
5287 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5288 CLASSTYPE_NESTED_UTDS (current_class_type) =
5289 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5291 binding_table_insert
5292 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5301 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5302 that the NAME is a class template, the tag is processed but not pushed.
5304 The pushed scope depend on the SCOPE parameter:
5305 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5307 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5308 non-template-parameter scope. This case is needed for forward
5310 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5311 TS_GLOBAL case except that names within template-parameter scopes
5312 are not pushed at all.
5314 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5317 pushtag (tree name, tree type, tag_scope scope)
5319 struct cp_binding_level *b;
5322 timevar_push (TV_NAME_LOOKUP);
5323 b = current_binding_level;
5324 while (/* Cleanup scopes are not scopes from the point of view of
5326 b->kind == sk_cleanup
5327 /* Neither are function parameter scopes. */
5328 || b->kind == sk_function_parms
5329 /* Neither are the scopes used to hold template parameters
5330 for an explicit specialization. For an ordinary template
5331 declaration, these scopes are not scopes from the point of
5332 view of the language. */
5333 || (b->kind == sk_template_parms
5334 && (b->explicit_spec_p || scope == ts_global))
5335 || (b->kind == sk_class
5336 && (scope != ts_current
5337 /* We may be defining a new type in the initializer
5338 of a static member variable. We allow this when
5339 not pedantic, and it is particularly useful for
5340 type punning via an anonymous union. */
5341 || COMPLETE_TYPE_P (b->this_entity))))
5344 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5346 /* Do C++ gratuitous typedefing. */
5347 if (IDENTIFIER_TYPE_VALUE (name) != type)
5351 tree context = TYPE_CONTEXT (type);
5355 tree cs = current_scope ();
5357 if (scope == ts_current
5358 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5360 else if (cs != NULL_TREE && TYPE_P (cs))
5361 /* When declaring a friend class of a local class, we want
5362 to inject the newly named class into the scope
5363 containing the local class, not the namespace
5365 context = decl_function_context (get_type_decl (cs));
5368 context = current_namespace;
5370 if (b->kind == sk_class
5371 || (b->kind == sk_template_parms
5372 && b->level_chain->kind == sk_class))
5375 if (current_lang_name == lang_name_java)
5376 TYPE_FOR_JAVA (type) = 1;
5378 tdef = create_implicit_typedef (name, type);
5379 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5380 if (scope == ts_within_enclosing_non_class)
5382 /* This is a friend. Make this TYPE_DECL node hidden from
5383 ordinary name lookup. Its corresponding TEMPLATE_DECL
5384 will be marked in push_template_decl_real. */
5385 retrofit_lang_decl (tdef);
5386 DECL_ANTICIPATED (tdef) = 1;
5387 DECL_FRIEND_P (tdef) = 1;
5390 decl = maybe_process_template_type_declaration
5391 (type, scope == ts_within_enclosing_non_class, b);
5392 if (decl == error_mark_node)
5393 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5395 if (b->kind == sk_class)
5397 if (!TYPE_BEING_DEFINED (current_class_type))
5398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5400 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5401 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5402 class. But if it's a member template class, we want
5403 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5405 finish_member_declaration (decl);
5407 pushdecl_class_level (decl);
5409 else if (b->kind != sk_template_parms)
5411 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5412 if (decl == error_mark_node)
5413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5417 set_identifier_type_value_with_scope (name, tdef, b);
5419 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5421 /* If this is a local class, keep track of it. We need this
5422 information for name-mangling, and so that it is possible to
5423 find all function definitions in a translation unit in a
5424 convenient way. (It's otherwise tricky to find a member
5425 function definition it's only pointed to from within a local
5427 if (TYPE_CONTEXT (type)
5428 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5429 VEC_safe_push (tree, gc, local_classes, type);
5431 if (b->kind == sk_class
5432 && !COMPLETE_TYPE_P (current_class_type))
5434 maybe_add_class_template_decl_list (current_class_type,
5435 type, /*friend_p=*/0);
5437 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5438 CLASSTYPE_NESTED_UTDS (current_class_type)
5439 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5441 binding_table_insert
5442 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5445 decl = TYPE_NAME (type);
5446 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5448 /* Set type visibility now if this is a forward declaration. */
5449 TREE_PUBLIC (decl) = 1;
5450 determine_visibility (decl);
5452 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5455 /* Subroutines for reverting temporarily to top-level for instantiation
5456 of templates and such. We actually need to clear out the class- and
5457 local-value slots of all identifiers, so that only the global values
5458 are at all visible. Simply setting current_binding_level to the global
5459 scope isn't enough, because more binding levels may be pushed. */
5460 struct saved_scope *scope_chain;
5462 /* If ID has not already been marked, add an appropriate binding to
5466 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5468 cxx_saved_binding *saved;
5470 if (!id || !IDENTIFIER_BINDING (id))
5473 if (IDENTIFIER_MARKED (id))
5476 IDENTIFIER_MARKED (id) = 1;
5478 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5479 saved->identifier = id;
5480 saved->binding = IDENTIFIER_BINDING (id);
5481 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5482 IDENTIFIER_BINDING (id) = NULL;
5486 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5490 timevar_push (TV_NAME_LOOKUP);
5491 for (t = names; t; t = TREE_CHAIN (t))
5495 if (TREE_CODE (t) == TREE_LIST)
5496 id = TREE_PURPOSE (t);
5500 store_binding (id, old_bindings);
5502 timevar_pop (TV_NAME_LOOKUP);
5505 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5506 objects, rather than a TREE_LIST. */
5509 store_class_bindings (VEC(cp_class_binding,gc) *names,
5510 VEC(cxx_saved_binding,gc) **old_bindings)
5513 cp_class_binding *cb;
5515 timevar_push (TV_NAME_LOOKUP);
5516 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5517 store_binding (cb->identifier, old_bindings);
5518 timevar_pop (TV_NAME_LOOKUP);
5522 push_to_top_level (void)
5524 struct saved_scope *s;
5525 struct cp_binding_level *b;
5526 cxx_saved_binding *sb;
5530 timevar_push (TV_NAME_LOOKUP);
5531 s = ggc_alloc_cleared_saved_scope ();
5533 b = scope_chain ? current_binding_level : 0;
5535 /* If we're in the middle of some function, save our state. */
5539 push_function_context ();
5544 if (scope_chain && previous_class_level)
5545 store_class_bindings (previous_class_level->class_shadowed,
5548 /* Have to include the global scope, because class-scope decls
5549 aren't listed anywhere useful. */
5550 for (; b; b = b->level_chain)
5554 /* Template IDs are inserted into the global level. If they were
5555 inserted into namespace level, finish_file wouldn't find them
5556 when doing pending instantiations. Therefore, don't stop at
5557 namespace level, but continue until :: . */
5558 if (global_scope_p (b))
5561 store_bindings (b->names, &s->old_bindings);
5562 /* We also need to check class_shadowed to save class-level type
5563 bindings, since pushclass doesn't fill in b->names. */
5564 if (b->kind == sk_class)
5565 store_class_bindings (b->class_shadowed, &s->old_bindings);
5567 /* Unwind type-value slots back to top level. */
5568 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5569 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5572 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, sb)
5573 IDENTIFIER_MARKED (sb->identifier) = 0;
5575 s->prev = scope_chain;
5577 s->need_pop_function_context = need_pop;
5578 s->function_decl = current_function_decl;
5579 s->unevaluated_operand = cp_unevaluated_operand;
5580 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5583 current_function_decl = NULL_TREE;
5584 current_lang_base = VEC_alloc (tree, gc, 10);
5585 current_lang_name = lang_name_cplusplus;
5586 current_namespace = global_namespace;
5587 push_class_stack ();
5588 cp_unevaluated_operand = 0;
5589 c_inhibit_evaluation_warnings = 0;
5590 timevar_pop (TV_NAME_LOOKUP);
5594 pop_from_top_level (void)
5596 struct saved_scope *s = scope_chain;
5597 cxx_saved_binding *saved;
5600 timevar_push (TV_NAME_LOOKUP);
5601 /* Clear out class-level bindings cache. */
5602 if (previous_class_level)
5603 invalidate_class_lookup_cache ();
5606 current_lang_base = 0;
5608 scope_chain = s->prev;
5609 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, saved)
5611 tree id = saved->identifier;
5613 IDENTIFIER_BINDING (id) = saved->binding;
5614 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5617 /* If we were in the middle of compiling a function, restore our
5619 if (s->need_pop_function_context)
5620 pop_function_context ();
5621 current_function_decl = s->function_decl;
5622 cp_unevaluated_operand = s->unevaluated_operand;
5623 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5624 timevar_pop (TV_NAME_LOOKUP);
5627 /* Pop off extraneous binding levels left over due to syntax errors.
5629 We don't pop past namespaces, as they might be valid. */
5632 pop_everything (void)
5634 if (ENABLE_SCOPE_CHECKING)
5635 verbatim ("XXX entering pop_everything ()\n");
5636 while (!toplevel_bindings_p ())
5638 if (current_binding_level->kind == sk_class)
5639 pop_nested_class ();
5643 if (ENABLE_SCOPE_CHECKING)
5644 verbatim ("XXX leaving pop_everything ()\n");
5647 /* Emit debugging information for using declarations and directives.
5648 If input tree is overloaded fn then emit debug info for all
5652 cp_emit_debug_info_for_using (tree t, tree context)
5654 /* Don't try to emit any debug information if we have errors. */
5658 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5659 of a builtin function. */
5660 if (TREE_CODE (t) == FUNCTION_DECL
5661 && DECL_EXTERNAL (t)
5662 && DECL_BUILT_IN (t))
5665 /* Do not supply context to imported_module_or_decl, if
5666 it is a global namespace. */
5667 if (context == global_namespace)
5668 context = NULL_TREE;
5671 t = BASELINK_FUNCTIONS (t);
5673 /* FIXME: Handle TEMPLATE_DECLs. */
5674 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5675 if (TREE_CODE (t) != TEMPLATE_DECL)
5677 if (building_stmt_tree ())
5678 add_stmt (build_stmt (input_location, USING_STMT, t));
5680 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5684 #include "gt-cp-name-lookup.h"