1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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"
32 #include "diagnostic.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding {
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope *innermost_nonclass_level (void);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree push_overloaded_decl (tree, int, bool);
47 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
49 static bool qualified_lookup_using_namespace (tree, tree,
50 struct scope_binding *, int);
51 static tree lookup_type_current_level (tree);
52 static tree push_using_directive (tree);
53 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name(void)
68 if (!anonymous_namespace_name)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73 anonymous_namespace_name = get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable)) binding_entry free_binding_entry = NULL;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name, tree type)
99 if (free_binding_entry)
101 entry = free_binding_entry;
102 free_binding_entry = entry->chain;
105 entry = GGC_NEW (struct binding_entry_s);
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry)
121 entry->chain = free_binding_entry;
122 free_binding_entry = entry;
126 /* The datatype used to implement the mapping from names to types at
128 struct binding_table_s GTY(())
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_CNEWVEC (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_NEW (struct 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_NEW (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. */
332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
336 b = &IDENTIFIER_BINDING (cb->identifier);
337 while (*b != &old_base[i].base)
338 b = &((*b)->previous);
342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
347 cb->identifier = name;
349 binding->scope = scope;
350 cxx_binding_init (binding, value, type);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id, tree decl, cxx_scope* level)
360 cxx_binding *binding;
362 if (level != class_binding_level)
364 binding = cxx_binding_make (decl, NULL_TREE);
365 binding->scope = level;
368 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
370 /* Now, fill in the binding information. */
371 binding->previous = IDENTIFIER_BINDING (id);
372 INHERITED_VALUE_BINDING_P (binding) = 0;
373 LOCAL_BINDING_P (binding) = (level != class_binding_level);
375 /* And put it on the front of the list of bindings for ID. */
376 IDENTIFIER_BINDING (id) = binding;
379 /* Remove the binding for DECL which should be the innermost binding
383 pop_binding (tree id, tree decl)
385 cxx_binding *binding;
388 /* It's easiest to write the loops that call this function without
389 checking whether or not the entities involved have names. We
390 get here for such an entity. */
393 /* Get the innermost binding for ID. */
394 binding = IDENTIFIER_BINDING (id);
396 /* The name should be bound. */
397 gcc_assert (binding != NULL);
399 /* The DECL will be either the ordinary binding or the type
400 binding for this identifier. Remove that binding. */
401 if (binding->value == decl)
402 binding->value = NULL_TREE;
405 gcc_assert (binding->type == decl);
406 binding->type = NULL_TREE;
409 if (!binding->value && !binding->type)
411 /* We're completely done with the innermost binding for this
412 identifier. Unhook it from the list of bindings. */
413 IDENTIFIER_BINDING (id) = binding->previous;
415 /* Add it to the free list. */
416 cxx_binding_free (binding);
420 /* BINDING records an existing declaration for a name in the current scope.
421 But, DECL is another declaration for that same identifier in the
422 same scope. This is the `struct stat' hack whereby a non-typedef
423 class name or enum-name can be bound at the same level as some other
427 A class name (9.1) or enumeration name (7.2) can be hidden by the
428 name of an object, function, or enumerator declared in the same scope.
429 If a class or enumeration name and an object, function, or enumerator
430 are declared in the same scope (in any order) with the same name, the
431 class or enumeration name is hidden wherever the object, function, or
432 enumerator name is visible.
434 It's the responsibility of the caller to check that
435 inserting this name is valid here. Returns nonzero if the new binding
439 supplement_binding (cxx_binding *binding, tree decl)
441 tree bval = binding->value;
444 timevar_push (TV_NAME_LOOKUP);
445 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
446 /* The new name is the type name. */
447 binding->type = decl;
448 else if (/* BVAL is null when push_class_level_binding moves an
449 inherited type-binding out of the way to make room for a
450 new value binding. */
452 /* BVAL is error_mark_node when DECL's name has been used
453 in a non-class scope prior declaration. In that case,
454 we should have already issued a diagnostic; for graceful
455 error recovery purpose, pretend this was the intended
456 declaration for that name. */
457 || bval == error_mark_node
458 /* If BVAL is anticipated but has not yet been declared,
459 pretend it is not there at all. */
460 || (TREE_CODE (bval) == FUNCTION_DECL
461 && DECL_ANTICIPATED (bval)
462 && !DECL_HIDDEN_FRIEND_P (bval)))
463 binding->value = decl;
464 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
466 /* The old binding was a type name. It was placed in
467 VALUE field because it was thought, at the point it was
468 declared, to be the only entity with such a name. Move the
469 type name into the type slot; it is now hidden by the new
471 binding->type = bval;
472 binding->value = decl;
473 binding->value_is_inherited = false;
475 else if (TREE_CODE (bval) == TYPE_DECL
476 && TREE_CODE (decl) == TYPE_DECL
477 && DECL_NAME (decl) == DECL_NAME (bval)
478 && binding->scope->kind != sk_class
479 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
480 /* If either type involves template parameters, we must
481 wait until instantiation. */
482 || uses_template_parms (TREE_TYPE (decl))
483 || uses_template_parms (TREE_TYPE (bval))))
484 /* We have two typedef-names, both naming the same type to have
485 the same name. In general, this is OK because of:
489 In a given scope, a typedef specifier can be used to redefine
490 the name of any type declared in that scope to refer to the
491 type to which it already refers.
493 However, in class scopes, this rule does not apply due to the
494 stricter language in [class.mem] prohibiting redeclarations of
497 /* There can be two block-scope declarations of the same variable,
498 so long as they are `extern' declarations. However, there cannot
499 be two declarations of the same static data member:
503 A member shall not be declared twice in the
504 member-specification. */
505 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
506 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
507 && !DECL_CLASS_SCOPE_P (decl))
509 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
512 else if (TREE_CODE (decl) == NAMESPACE_DECL
513 && TREE_CODE (bval) == NAMESPACE_DECL
514 && DECL_NAMESPACE_ALIAS (decl)
515 && DECL_NAMESPACE_ALIAS (bval)
516 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
519 In a declarative region, a namespace-alias-definition can be
520 used to redefine a namespace-alias declared in that declarative
521 region to refer only to the namespace to which it already
526 error ("declaration of %q#D", decl);
527 error ("conflicts with previous declaration %q+#D", bval);
531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
534 /* Add DECL to the list of things declared in B. */
537 add_decl_to_level (tree decl, cxx_scope *b)
539 /* We used to record virtual tables as if they were ordinary
540 variables, but no longer do so. */
541 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
543 if (TREE_CODE (decl) == NAMESPACE_DECL
544 && !DECL_NAMESPACE_ALIAS (decl))
546 TREE_CHAIN (decl) = b->namespaces;
547 b->namespaces = decl;
551 /* We build up the list in reverse order, and reverse it later if
553 TREE_CHAIN (decl) = b->names;
557 /* If appropriate, add decl to separate list of statics. We
558 include extern variables because they might turn out to be
559 static later. It's OK for this list to contain a few false
561 if (b->kind == sk_namespace)
562 if ((TREE_CODE (decl) == VAR_DECL
563 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
564 || (TREE_CODE (decl) == FUNCTION_DECL
565 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
566 VEC_safe_push (tree, gc, b->static_decls, decl);
570 /* Record a decl-node X as belonging to the current lexical scope.
571 Check for errors (such as an incompatible declaration for the same
572 name already seen in the same scope). IS_FRIEND is true if X is
573 declared as a friend.
575 Returns either X or an old decl for the same name.
576 If an old decl is returned, it may have been smashed
577 to agree with what X says. */
580 pushdecl_maybe_friend (tree x, bool is_friend)
584 int need_new_binding;
586 timevar_push (TV_NAME_LOOKUP);
588 if (x == error_mark_node)
589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
591 need_new_binding = 1;
593 if (DECL_TEMPLATE_PARM_P (x))
594 /* Template parameters have no context; they are not X::T even
595 when declared within a class or namespace. */
599 if (current_function_decl && x != current_function_decl
600 /* A local declaration for a function doesn't constitute
602 && TREE_CODE (x) != FUNCTION_DECL
603 /* A local declaration for an `extern' variable is in the
604 scope of the current namespace, not the current
606 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
607 /* When parsing the parameter list of a function declarator,
608 don't set DECL_CONTEXT to an enclosing function. When we
609 push the PARM_DECLs in order to process the function body,
610 current_binding_level->this_entity will be set. */
611 && !(TREE_CODE (x) == PARM_DECL
612 && current_binding_level->kind == sk_function_parms
613 && current_binding_level->this_entity == NULL)
614 && !DECL_CONTEXT (x))
615 DECL_CONTEXT (x) = current_function_decl;
617 /* If this is the declaration for a namespace-scope function,
618 but the declaration itself is in a local scope, mark the
620 if (TREE_CODE (x) == FUNCTION_DECL
621 && DECL_NAMESPACE_SCOPE_P (x)
622 && current_function_decl
623 && x != current_function_decl)
624 DECL_LOCAL_FUNCTION_P (x) = 1;
627 name = DECL_NAME (x);
630 int different_binding_level = 0;
632 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
633 name = TREE_OPERAND (name, 0);
635 /* In case this decl was explicitly namespace-qualified, look it
636 up in its namespace context. */
637 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
638 t = namespace_binding (name, DECL_CONTEXT (x));
640 t = lookup_name_innermost_nonclass_level (name);
642 /* [basic.link] If there is a visible declaration of an entity
643 with linkage having the same name and type, ignoring entities
644 declared outside the innermost enclosing namespace scope, the
645 block scope declaration declares that same entity and
646 receives the linkage of the previous declaration. */
647 if (! t && current_function_decl && x != current_function_decl
648 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
649 && DECL_EXTERNAL (x))
651 /* Look in block scope. */
652 t = innermost_non_namespace_value (name);
653 /* Or in the innermost namespace. */
655 t = namespace_binding (name, DECL_CONTEXT (x));
656 /* Does it have linkage? Note that if this isn't a DECL, it's an
657 OVERLOAD, which is OK. */
658 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
661 different_binding_level = 1;
664 /* If we are declaring a function, and the result of name-lookup
665 was an OVERLOAD, look for an overloaded instance that is
666 actually the same as the function we are declaring. (If
667 there is one, we have to merge our declaration with the
668 previous declaration.) */
669 if (t && TREE_CODE (t) == OVERLOAD)
673 if (TREE_CODE (x) == FUNCTION_DECL)
674 for (match = t; match; match = OVL_NEXT (match))
676 if (decls_match (OVL_CURRENT (match), x))
680 /* Just choose one. */
684 t = OVL_CURRENT (match);
689 if (t && t != error_mark_node)
691 if (different_binding_level)
693 if (decls_match (x, t))
694 /* The standard only says that the local extern
695 inherits linkage from the previous decl; in
696 particular, default args are not shared. Add
697 the decl into a hash table to make sure only
698 the previous decl in this case is seen by the
701 struct cxx_int_tree_map *h;
704 TREE_PUBLIC (x) = TREE_PUBLIC (t);
706 if (cp_function_chain->extern_decl_map == NULL)
707 cp_function_chain->extern_decl_map
708 = htab_create_ggc (20, cxx_int_tree_map_hash,
709 cxx_int_tree_map_eq, NULL);
711 h = GGC_NEW (struct cxx_int_tree_map);
712 h->uid = DECL_UID (x);
714 loc = htab_find_slot_with_hash
715 (cp_function_chain->extern_decl_map, h,
717 *(struct cxx_int_tree_map **) loc = h;
720 else if (TREE_CODE (t) == PARM_DECL)
722 /* Check for duplicate params. */
723 tree d = duplicate_decls (x, t, is_friend);
725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
727 else if ((DECL_EXTERN_C_FUNCTION_P (x)
728 || DECL_FUNCTION_TEMPLATE_P (x))
729 && is_overloaded_fn (t))
730 /* Don't do anything just yet. */;
731 else if (t == wchar_decl_node)
733 if (! DECL_IN_SYSTEM_HEADER (x))
734 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
737 /* Throw away the redeclaration. */
738 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
742 tree olddecl = duplicate_decls (x, t, is_friend);
744 /* If the redeclaration failed, we can stop at this
746 if (olddecl == error_mark_node)
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
751 if (TREE_CODE (t) == TYPE_DECL)
752 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
756 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
758 /* A redeclaration of main, but not a duplicate of the
763 This function shall not be overloaded. */
764 error ("invalid redeclaration of %q+D", t);
766 /* We don't try to push this declaration since that
768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
773 /* If x has C linkage-specification, (extern "C"),
774 lookup its binding, in case it's already bound to an object.
775 The lookup is done in all namespaces.
776 If we find an existing binding, make sure it has the same
777 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
778 if ((TREE_CODE (x) == FUNCTION_DECL)
779 && DECL_EXTERN_C_P (x)
780 /* We should ignore declarations happening in system headers. */
781 && !DECL_ARTIFICIAL (x)
782 && !DECL_IN_SYSTEM_HEADER (x))
784 cxx_binding *function_binding =
785 lookup_extern_c_fun_binding_in_all_ns (x);
786 tree previous = (function_binding
787 ? function_binding->value
790 && !DECL_ARTIFICIAL (previous)
791 && !DECL_IN_SYSTEM_HEADER (previous)
792 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
794 tree previous = function_binding->value;
796 /* In case either x or previous is declared to throw an exception,
797 make sure both exception specifications are equal. */
798 if (decls_match (x, previous))
800 tree x_exception_spec = NULL_TREE;
801 tree previous_exception_spec = NULL_TREE;
804 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
805 previous_exception_spec =
806 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
807 if (!comp_except_specs (previous_exception_spec,
811 pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
813 pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
815 pedwarn (input_location, 0, "due to different exception specifications");
816 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
821 pedwarn (input_location, 0,
822 "declaration of %q#D with C language linkage", x);
823 pedwarn (input_location, 0,
824 "conflicts with previous declaration %q+#D",
830 check_template_shadow (x);
832 /* If this is a function conjured up by the back end, massage it
833 so it looks friendly. */
834 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
836 retrofit_lang_decl (x);
837 SET_DECL_LANGUAGE (x, lang_c);
841 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
843 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
844 if (!namespace_bindings_p ())
845 /* We do not need to create a binding for this name;
846 push_overloaded_decl will have already done so if
848 need_new_binding = 0;
850 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
852 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
854 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
857 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
858 check_default_args (x);
860 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
861 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
863 /* If declaring a type as a typedef, copy the type (unless we're
864 at line 0), and install this TYPE_DECL as the new type's typedef
865 name. See the extensive comment of set_underlying_type (). */
866 if (TREE_CODE (x) == TYPE_DECL)
868 tree type = TREE_TYPE (x);
870 if (DECL_IS_BUILTIN (x)
871 || (TREE_TYPE (x) != error_mark_node
872 && TYPE_NAME (type) != x
873 /* We don't want to copy the type when all we're
874 doing is making a TYPE_DECL for the purposes of
876 && (!TYPE_NAME (type)
877 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
878 set_underlying_type (x);
880 if (type != error_mark_node
882 && TYPE_IDENTIFIER (type))
883 set_identifier_type_value (DECL_NAME (x), x);
886 /* Multiple external decls of the same identifier ought to match.
888 We get warnings about inline functions where they are defined.
889 We get warnings about other functions from push_overloaded_decl.
891 Avoid duplicate warnings where they are used. */
892 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
896 decl = IDENTIFIER_NAMESPACE_VALUE (name);
897 if (decl && TREE_CODE (decl) == OVERLOAD)
898 decl = OVL_FUNCTION (decl);
900 if (decl && decl != error_mark_node
901 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
902 /* If different sort of thing, we already gave an error. */
903 && TREE_CODE (decl) == TREE_CODE (x)
904 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
906 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
907 permerror (input_location, "previous external decl of %q+#D", decl);
911 if (TREE_CODE (x) == FUNCTION_DECL
913 && !flag_friend_injection)
915 /* This is a new declaration of a friend function, so hide
916 it from ordinary function lookup. */
917 DECL_ANTICIPATED (x) = 1;
918 DECL_HIDDEN_FRIEND_P (x) = 1;
921 /* This name is new in its binding level.
922 Install the new declaration and return it. */
923 if (namespace_bindings_p ())
925 /* Install a global value. */
927 /* If the first global decl has external linkage,
928 warn if we later see static one. */
929 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
930 TREE_PUBLIC (name) = 1;
932 /* Bind the name for the entity. */
933 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
935 && (TREE_CODE (x) == TYPE_DECL
936 || TREE_CODE (x) == VAR_DECL
937 || TREE_CODE (x) == NAMESPACE_DECL
938 || TREE_CODE (x) == CONST_DECL
939 || TREE_CODE (x) == TEMPLATE_DECL))
940 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
942 /* If new decl is `static' and an `extern' was seen previously,
944 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
945 warn_extern_redeclared_static (x, t);
949 /* Here to install a non-global value. */
950 tree oldlocal = innermost_non_namespace_value (name);
951 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
953 if (need_new_binding)
955 push_local_binding (name, x, 0);
956 /* Because push_local_binding will hook X on to the
957 current_binding_level's name list, we don't want to
958 do that again below. */
959 need_new_binding = 0;
962 /* If this is a TYPE_DECL, push it into the type value slot. */
963 if (TREE_CODE (x) == TYPE_DECL)
964 set_identifier_type_value (name, x);
966 /* Clear out any TYPE_DECL shadowed by a namespace so that
967 we won't think this is a type. The C struct hack doesn't
968 go through namespaces. */
969 if (TREE_CODE (x) == NAMESPACE_DECL)
970 set_identifier_type_value (name, NULL_TREE);
977 && TREE_CODE (oldlocal) == VAR_DECL
978 && DECL_DEAD_FOR_LOCAL (oldlocal))
979 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
981 if (oldlocal == NULL_TREE)
982 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
985 /* If this is an extern function declaration, see if we
986 have a global definition or declaration for the function. */
987 if (oldlocal == NULL_TREE
989 && oldglobal != NULL_TREE
990 && TREE_CODE (x) == FUNCTION_DECL
991 && TREE_CODE (oldglobal) == FUNCTION_DECL)
993 /* We have one. Their types must agree. */
994 if (decls_match (x, oldglobal))
998 warning (0, "extern declaration of %q#D doesn't match", x);
999 warning (0, "global declaration %q+#D", oldglobal);
1002 /* If we have a local external declaration,
1003 and no file-scope declaration has yet been seen,
1004 then if we later have a file-scope decl it must not be static. */
1005 if (oldlocal == NULL_TREE
1006 && oldglobal == NULL_TREE
1007 && DECL_EXTERNAL (x)
1009 TREE_PUBLIC (name) = 1;
1011 /* Warn if shadowing an argument at the top level of the body. */
1012 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1013 /* Inline decls shadow nothing. */
1014 && !DECL_FROM_INLINE (x)
1015 && TREE_CODE (oldlocal) == PARM_DECL
1016 /* Don't check the `this' parameter. */
1017 && !DECL_ARTIFICIAL (oldlocal))
1021 /* Don't complain if it's from an enclosing function. */
1022 if (DECL_CONTEXT (oldlocal) == current_function_decl
1023 && TREE_CODE (x) != PARM_DECL)
1025 /* Go to where the parms should be and see if we find
1027 struct cp_binding_level *b = current_binding_level->level_chain;
1029 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1030 /* Skip the ctor/dtor cleanup level. */
1034 if (b->kind == sk_function_parms)
1036 error ("declaration of %q#D shadows a parameter", x);
1041 if (warn_shadow && !err
1042 /* Don't complain about the parms we push and then pop
1043 while tentatively parsing a function declarator. */
1044 && !(TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE))
1046 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
1047 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1051 /* Maybe warn if shadowing something else. */
1052 else if (warn_shadow && !DECL_EXTERNAL (x)
1053 /* No shadow warnings for internally generated vars. */
1054 && ! DECL_ARTIFICIAL (x)
1055 /* No shadow warnings for vars made for inlining. */
1056 && ! DECL_FROM_INLINE (x))
1060 if (current_class_ptr)
1061 member = lookup_member (current_class_type,
1064 /*want_type=*/false);
1068 if (member && !TREE_STATIC (member))
1070 /* Location of previous decl is not useful in this case. */
1071 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1074 else if (oldlocal != NULL_TREE
1075 && TREE_CODE (oldlocal) == VAR_DECL)
1077 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1078 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1080 else if (oldglobal != NULL_TREE
1081 && TREE_CODE (oldglobal) == VAR_DECL)
1082 /* XXX shadow warnings in outer-more namespaces */
1084 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1086 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1091 if (TREE_CODE (x) == VAR_DECL)
1092 maybe_register_incomplete_var (x);
1095 if (need_new_binding)
1096 add_decl_to_level (x,
1097 DECL_NAMESPACE_SCOPE_P (x)
1098 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1099 : current_binding_level);
1101 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1104 /* Record a decl-node X as belonging to the current lexical scope. */
1109 return pushdecl_maybe_friend (x, false);
1112 /* Enter DECL into the symbol table, if that's appropriate. Returns
1113 DECL, or a modified version thereof. */
1116 maybe_push_decl (tree decl)
1118 tree type = TREE_TYPE (decl);
1120 /* Add this decl to the current binding level, but not if it comes
1121 from another scope, e.g. a static member variable. TEM may equal
1122 DECL or it may be a previous decl of the same name. */
1123 if (decl == error_mark_node
1124 || (TREE_CODE (decl) != PARM_DECL
1125 && DECL_CONTEXT (decl) != NULL_TREE
1126 /* Definitions of namespace members outside their namespace are
1128 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1129 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1130 || TREE_CODE (type) == UNKNOWN_TYPE
1131 /* The declaration of a template specialization does not affect
1132 the functions available for overload resolution, so we do not
1134 || (TREE_CODE (decl) == FUNCTION_DECL
1135 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1138 return pushdecl (decl);
1141 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1142 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1143 doesn't really belong to this binding level, that it got here
1144 through a using-declaration. */
1147 push_local_binding (tree id, tree decl, int flags)
1149 struct cp_binding_level *b;
1151 /* Skip over any local classes. This makes sense if we call
1152 push_local_binding with a friend decl of a local class. */
1153 b = innermost_nonclass_level ();
1155 if (lookup_name_innermost_nonclass_level (id))
1157 /* Supplement the existing binding. */
1158 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1159 /* It didn't work. Something else must be bound at this
1160 level. Do not add DECL to the list of things to pop
1165 /* Create a new binding. */
1166 push_binding (id, decl, b);
1168 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1169 /* We must put the OVERLOAD into a TREE_LIST since the
1170 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1171 decls that got here through a using-declaration. */
1172 decl = build_tree_list (NULL_TREE, decl);
1174 /* And put DECL on the list of things declared by the current
1176 add_decl_to_level (decl, b);
1179 /* Check to see whether or not DECL is a variable that would have been
1180 in scope under the ARM, but is not in scope under the ANSI/ISO
1181 standard. If so, issue an error message. If name lookup would
1182 work in both cases, but return a different result, this function
1183 returns the result of ANSI/ISO lookup. Otherwise, it returns
1187 check_for_out_of_scope_variable (tree decl)
1191 /* We only care about out of scope variables. */
1192 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1195 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1196 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1197 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1198 && DECL_DEAD_FOR_LOCAL (shadowed))
1199 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1200 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1202 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1205 if (!DECL_ERROR_REPORTED (decl))
1207 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1208 warning (0, " matches this %q+D under ISO standard rules",
1210 warning (0, " matches this %q+D under old rules", decl);
1211 DECL_ERROR_REPORTED (decl) = 1;
1216 /* If we have already complained about this declaration, there's no
1217 need to do it again. */
1218 if (DECL_ERROR_REPORTED (decl))
1221 DECL_ERROR_REPORTED (decl) = 1;
1223 if (TREE_TYPE (decl) == error_mark_node)
1226 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1228 error ("name lookup of %qD changed for ISO %<for%> scoping",
1230 error (" cannot use obsolete binding at %q+D because "
1231 "it has a destructor", decl);
1232 return error_mark_node;
1236 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1238 if (flag_permissive)
1239 permerror (input_location, " using obsolete binding at %q+D", decl);
1245 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1254 /* true means unconditionally make a BLOCK for the next level pushed. */
1256 static bool keep_next_level_flag;
1258 static int binding_depth = 0;
1259 static int is_class_level = 0;
1266 for (i = 0; i < depth * 2; i++)
1270 /* Return a string describing the kind of SCOPE we have. */
1272 cxx_scope_descriptor (cxx_scope *scope)
1274 /* The order of this table must match the "scope_kind"
1276 static const char* scope_kind_names[] = {
1282 "function-parameter-scope",
1285 "template-parameter-scope",
1286 "template-explicit-spec-scope"
1288 const scope_kind kind = scope->explicit_spec_p
1289 ? sk_template_spec : scope->kind;
1291 return scope_kind_names[kind];
1294 /* Output a debugging information about SCOPE when performing
1297 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1299 const char *desc = cxx_scope_descriptor (scope);
1300 if (scope->this_entity)
1301 verbatim ("%s %s(%E) %p %d\n", action, desc,
1302 scope->this_entity, (void *) scope, line);
1304 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1307 /* Return the estimated initial size of the hashtable of a NAMESPACE
1310 static inline size_t
1311 namespace_scope_ht_size (tree ns)
1313 tree name = DECL_NAME (ns);
1315 return name == std_identifier
1316 ? NAMESPACE_STD_HT_SIZE
1317 : (name == global_scope_name
1318 ? GLOBAL_SCOPE_HT_SIZE
1319 : NAMESPACE_ORDINARY_HT_SIZE);
1322 /* A chain of binding_level structures awaiting reuse. */
1324 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1326 /* Insert SCOPE as the innermost binding level. */
1329 push_binding_level (struct cp_binding_level *scope)
1331 /* Add it to the front of currently active scopes stack. */
1332 scope->level_chain = current_binding_level;
1333 current_binding_level = scope;
1334 keep_next_level_flag = false;
1336 if (ENABLE_SCOPE_CHECKING)
1338 scope->binding_depth = binding_depth;
1339 indent (binding_depth);
1340 cxx_scope_debug (scope, input_line, "push");
1346 /* Create a new KIND scope and make it the top of the active scopes stack.
1347 ENTITY is the scope of the associated C++ entity (namespace, class,
1348 function, C++0x enumeration); it is NULL otherwise. */
1351 begin_scope (scope_kind kind, tree entity)
1355 /* Reuse or create a struct for this binding level. */
1356 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1358 scope = free_binding_level;
1359 memset (scope, 0, sizeof (cxx_scope));
1360 free_binding_level = scope->level_chain;
1363 scope = GGC_CNEW (cxx_scope);
1365 scope->this_entity = entity;
1366 scope->more_cleanups_ok = true;
1373 case sk_template_spec:
1374 scope->explicit_spec_p = true;
1375 kind = sk_template_parms;
1377 case sk_template_parms:
1383 case sk_scoped_enum:
1384 case sk_function_parms:
1386 scope->keep = keep_next_level_flag;
1390 NAMESPACE_LEVEL (entity) = scope;
1391 scope->static_decls =
1392 VEC_alloc (tree, gc,
1393 DECL_NAME (entity) == std_identifier
1394 || DECL_NAME (entity) == global_scope_name
1399 /* Should not happen. */
1405 push_binding_level (scope);
1410 /* We're about to leave current scope. Pop the top of the stack of
1411 currently active scopes. Return the enclosing scope, now active. */
1416 cxx_scope *scope = current_binding_level;
1418 if (scope->kind == sk_namespace && class_binding_level)
1419 current_binding_level = class_binding_level;
1421 /* We cannot leave a scope, if there are none left. */
1422 if (NAMESPACE_LEVEL (global_namespace))
1423 gcc_assert (!global_scope_p (scope));
1425 if (ENABLE_SCOPE_CHECKING)
1427 indent (--binding_depth);
1428 cxx_scope_debug (scope, input_line, "leave");
1429 if (is_class_level != (scope == class_binding_level))
1431 indent (binding_depth);
1432 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1437 /* Move one nesting level up. */
1438 current_binding_level = scope->level_chain;
1440 /* Namespace-scopes are left most probably temporarily, not
1441 completely; they can be reopened later, e.g. in namespace-extension
1442 or any name binding activity that requires us to resume a
1443 namespace. For classes, we cache some binding levels. For other
1444 scopes, we just make the structure available for reuse. */
1445 if (scope->kind != sk_namespace
1446 && scope->kind != sk_class)
1448 scope->level_chain = free_binding_level;
1449 gcc_assert (!ENABLE_SCOPE_CHECKING
1450 || scope->binding_depth == binding_depth);
1451 free_binding_level = scope;
1454 /* Find the innermost enclosing class scope, and reset
1455 CLASS_BINDING_LEVEL appropriately. */
1456 if (scope->kind == sk_class)
1458 class_binding_level = NULL;
1459 for (scope = current_binding_level; scope; scope = scope->level_chain)
1460 if (scope->kind == sk_class)
1462 class_binding_level = scope;
1467 return current_binding_level;
1471 resume_scope (struct cp_binding_level* b)
1473 /* Resuming binding levels is meant only for namespaces,
1474 and those cannot nest into classes. */
1475 gcc_assert (!class_binding_level);
1476 /* Also, resuming a non-directly nested namespace is a no-no. */
1477 gcc_assert (b->level_chain == current_binding_level);
1478 current_binding_level = b;
1479 if (ENABLE_SCOPE_CHECKING)
1481 b->binding_depth = binding_depth;
1482 indent (binding_depth);
1483 cxx_scope_debug (b, input_line, "resume");
1489 /* Return the innermost binding level that is not for a class scope. */
1492 innermost_nonclass_level (void)
1496 b = current_binding_level;
1497 while (b->kind == sk_class)
1503 /* We're defining an object of type TYPE. If it needs a cleanup, but
1504 we're not allowed to add any more objects with cleanups to the current
1505 scope, create a new binding level. */
1508 maybe_push_cleanup_level (tree type)
1510 if (type != error_mark_node
1511 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1512 && current_binding_level->more_cleanups_ok == 0)
1514 begin_scope (sk_cleanup, NULL);
1515 current_binding_level->statement_list = push_stmt_list ();
1519 /* Nonzero if we are currently in the global binding level. */
1522 global_bindings_p (void)
1524 return global_scope_p (current_binding_level);
1527 /* True if we are currently in a toplevel binding level. This
1528 means either the global binding level or a namespace in a toplevel
1529 binding level. Since there are no non-toplevel namespace levels,
1530 this really means any namespace or template parameter level. We
1531 also include a class whose context is toplevel. */
1534 toplevel_bindings_p (void)
1536 struct cp_binding_level *b = innermost_nonclass_level ();
1538 return b->kind == sk_namespace || b->kind == sk_template_parms;
1541 /* True if this is a namespace scope, or if we are defining a class
1542 which is itself at namespace scope, or whose enclosing class is
1543 such a class, etc. */
1546 namespace_bindings_p (void)
1548 struct cp_binding_level *b = innermost_nonclass_level ();
1550 return b->kind == sk_namespace;
1553 /* True if the current level needs to have a BLOCK made. */
1558 return (current_binding_level->blocks != NULL_TREE
1559 || current_binding_level->keep
1560 || current_binding_level->kind == sk_cleanup
1561 || current_binding_level->names != NULL_TREE
1562 || current_binding_level->using_directives);
1565 /* Returns the kind of the innermost scope. */
1568 innermost_scope_kind (void)
1570 return current_binding_level->kind;
1573 /* Returns true if this scope was created to store template parameters. */
1576 template_parm_scope_p (void)
1578 return innermost_scope_kind () == sk_template_parms;
1581 /* If KEEP is true, make a BLOCK node for the next binding level,
1582 unconditionally. Otherwise, use the normal logic to decide whether
1583 or not to create a BLOCK. */
1586 keep_next_level (bool keep)
1588 keep_next_level_flag = keep;
1591 /* Return the list of declarations of the current level.
1592 Note that this list is in reverse order unless/until
1593 you nreverse it; and when you do nreverse it, you must
1594 store the result back using `storedecls' or you will lose. */
1599 return current_binding_level->names;
1602 /* For debugging. */
1603 static int no_print_functions = 0;
1604 static int no_print_builtins = 0;
1607 print_binding_level (struct cp_binding_level* lvl)
1611 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1612 if (lvl->more_cleanups_ok)
1613 fprintf (stderr, " more-cleanups-ok");
1614 if (lvl->have_cleanups)
1615 fprintf (stderr, " have-cleanups");
1616 fprintf (stderr, "\n");
1619 fprintf (stderr, " names:\t");
1620 /* We can probably fit 3 names to a line? */
1621 for (t = lvl->names; t; t = TREE_CHAIN (t))
1623 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1625 if (no_print_builtins
1626 && (TREE_CODE (t) == TYPE_DECL)
1627 && DECL_IS_BUILTIN (t))
1630 /* Function decls tend to have longer names. */
1631 if (TREE_CODE (t) == FUNCTION_DECL)
1638 fprintf (stderr, "\n\t");
1641 print_node_brief (stderr, "", t, 0);
1642 if (t == error_mark_node)
1646 fprintf (stderr, "\n");
1648 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1651 cp_class_binding *b;
1652 fprintf (stderr, " class-shadowed:");
1654 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1656 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1657 fprintf (stderr, "\n");
1659 if (lvl->type_shadowed)
1661 fprintf (stderr, " type-shadowed:");
1662 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1664 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1666 fprintf (stderr, "\n");
1671 print_other_binding_stack (struct cp_binding_level *stack)
1673 struct cp_binding_level *level;
1674 for (level = stack; !global_scope_p (level); level = level->level_chain)
1676 fprintf (stderr, "binding level %p\n", (void *) level);
1677 print_binding_level (level);
1682 print_binding_stack (void)
1684 struct cp_binding_level *b;
1685 fprintf (stderr, "current_binding_level=%p\n"
1686 "class_binding_level=%p\n"
1687 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1688 (void *) current_binding_level, (void *) class_binding_level,
1689 (void *) NAMESPACE_LEVEL (global_namespace));
1690 if (class_binding_level)
1692 for (b = class_binding_level; b; b = b->level_chain)
1693 if (b == current_binding_level)
1696 b = class_binding_level;
1698 b = current_binding_level;
1701 b = current_binding_level;
1702 print_other_binding_stack (b);
1703 fprintf (stderr, "global:\n");
1704 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1707 /* Return the type associated with id. */
1710 identifier_type_value (tree id)
1712 timevar_push (TV_NAME_LOOKUP);
1713 /* There is no type with that name, anywhere. */
1714 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1716 /* This is not the type marker, but the real thing. */
1717 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1719 /* Have to search for it. It must be on the global level, now.
1720 Ask lookup_name not to return non-types. */
1721 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1727 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1728 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1731 identifier_global_value (tree t)
1733 return IDENTIFIER_GLOBAL_VALUE (t);
1736 /* Push a definition of struct, union or enum tag named ID. into
1737 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1738 the tag ID is not already defined. */
1741 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1745 if (b->kind != sk_namespace)
1747 /* Shadow the marker, not the real thing, so that the marker
1748 gets restored later. */
1749 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1751 = tree_cons (id, old_type_value, b->type_shadowed);
1752 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1753 TREE_TYPE (b->type_shadowed) = type;
1757 cxx_binding *binding =
1758 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1761 supplement_binding (binding, decl);
1763 binding->value = decl;
1765 /* Store marker instead of real type. */
1766 type = global_type_node;
1768 SET_IDENTIFIER_TYPE_VALUE (id, type);
1771 /* As set_identifier_type_value_with_scope, but using
1772 current_binding_level. */
1775 set_identifier_type_value (tree id, tree decl)
1777 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1780 /* Return the name for the constructor (or destructor) for the
1781 specified class TYPE. When given a template, this routine doesn't
1782 lose the specialization. */
1785 constructor_name_full (tree type)
1787 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1790 /* Return the name for the constructor (or destructor) for the
1791 specified class. When given a template, return the plain
1792 unspecialized name. */
1795 constructor_name (tree type)
1798 name = constructor_name_full (type);
1799 if (IDENTIFIER_TEMPLATE (name))
1800 name = IDENTIFIER_TEMPLATE (name);
1804 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1805 which must be a class type. */
1808 constructor_name_p (tree name, tree type)
1812 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1817 if (TREE_CODE (name) != IDENTIFIER_NODE)
1820 ctor_name = constructor_name_full (type);
1821 if (name == ctor_name)
1823 if (IDENTIFIER_TEMPLATE (ctor_name)
1824 && name == IDENTIFIER_TEMPLATE (ctor_name))
1829 /* Counter used to create anonymous type names. */
1831 static GTY(()) int anon_cnt;
1833 /* Return an IDENTIFIER which can be used as a name for
1834 anonymous structs and unions. */
1837 make_anon_name (void)
1841 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1842 return get_identifier (buf);
1845 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1847 static inline cxx_binding *
1848 find_binding (cxx_scope *scope, cxx_binding *binding)
1850 timevar_push (TV_NAME_LOOKUP);
1852 for (; binding != NULL; binding = binding->previous)
1853 if (binding->scope == scope)
1854 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1856 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1859 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1861 static inline cxx_binding *
1862 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1864 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1867 /* Fold-in case where NAME is used only once. */
1868 if (scope == b->scope && b->previous == NULL)
1870 return find_binding (scope, b);
1875 /* Always returns a binding for name in scope. If no binding is
1876 found, make a new one. */
1878 static cxx_binding *
1879 binding_for_name (cxx_scope *scope, tree name)
1881 cxx_binding *result;
1883 result = cxx_scope_find_binding_for_name (scope, name);
1886 /* Not found, make a new one. */
1887 result = cxx_binding_make (NULL, NULL);
1888 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1889 result->scope = scope;
1890 result->is_local = false;
1891 result->value_is_inherited = false;
1892 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1896 /* Walk through the bindings associated to the name of FUNCTION,
1897 and return the first binding that declares a function with a
1898 "C" linkage specification, a.k.a 'extern "C"'.
1899 This function looks for the binding, regardless of which scope it
1900 has been defined in. It basically looks in all the known scopes.
1901 Note that this function does not lookup for bindings of builtin functions
1902 or for functions declared in system headers. */
1904 lookup_extern_c_fun_binding_in_all_ns (tree function)
1909 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1911 name = DECL_NAME (function);
1912 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1914 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1916 iter = iter->previous)
1919 && TREE_CODE (iter->value) == FUNCTION_DECL
1920 && DECL_EXTERN_C_P (iter->value)
1921 && !DECL_ARTIFICIAL (iter->value))
1929 /* Insert another USING_DECL into the current binding level, returning
1930 this declaration. If this is a redeclaration, do nothing, and
1931 return NULL_TREE if this not in namespace scope (in namespace
1932 scope, a using decl might extend any previous bindings). */
1935 push_using_decl (tree scope, tree name)
1939 timevar_push (TV_NAME_LOOKUP);
1940 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1941 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1942 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1943 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1947 namespace_bindings_p () ? decl : NULL_TREE);
1948 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1949 USING_DECL_SCOPE (decl) = scope;
1950 TREE_CHAIN (decl) = current_binding_level->usings;
1951 current_binding_level->usings = decl;
1952 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1955 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1956 caller to set DECL_CONTEXT properly. */
1959 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1961 struct cp_binding_level *b;
1962 tree function_decl = current_function_decl;
1964 timevar_push (TV_NAME_LOOKUP);
1965 current_function_decl = NULL_TREE;
1966 if (level->kind == sk_class)
1968 b = class_binding_level;
1969 class_binding_level = level;
1970 pushdecl_class_level (x);
1971 class_binding_level = b;
1975 b = current_binding_level;
1976 current_binding_level = level;
1977 x = pushdecl_maybe_friend (x, is_friend);
1978 current_binding_level = b;
1980 current_function_decl = function_decl;
1981 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1984 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1985 other definitions already in place. We get around this by making
1986 the value of the identifier point to a list of all the things that
1987 want to be referenced by that name. It is then up to the users of
1988 that name to decide what to do with that list.
1990 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1991 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1993 FLAGS is a bitwise-or of the following values:
1994 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1996 PUSH_USING: DECL is being pushed as the result of a using
1999 IS_FRIEND is true if this is a friend declaration.
2001 The value returned may be a previous declaration if we guessed wrong
2002 about what language DECL should belong to (C or C++). Otherwise,
2003 it's always DECL (and never something that's not a _DECL). */
2006 push_overloaded_decl (tree decl, int flags, bool is_friend)
2008 tree name = DECL_NAME (decl);
2011 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2013 timevar_push (TV_NAME_LOOKUP);
2015 old = namespace_binding (name, DECL_CONTEXT (decl));
2017 old = lookup_name_innermost_nonclass_level (name);
2021 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2023 tree t = TREE_TYPE (old);
2024 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2025 && (! DECL_IN_SYSTEM_HEADER (decl)
2026 || ! DECL_IN_SYSTEM_HEADER (old)))
2027 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2030 else if (is_overloaded_fn (old))
2034 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2036 tree fn = OVL_CURRENT (tmp);
2039 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2040 && !(flags & PUSH_USING)
2041 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2042 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2043 && ! decls_match (fn, decl))
2044 error ("%q#D conflicts with previous using declaration %q#D",
2047 dup = duplicate_decls (decl, fn, is_friend);
2048 /* If DECL was a redeclaration of FN -- even an invalid
2049 one -- pass that information along to our caller. */
2050 if (dup == fn || dup == error_mark_node)
2051 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2054 /* We don't overload implicit built-ins. duplicate_decls()
2055 may fail to merge the decls if the new decl is e.g. a
2056 template function. */
2057 if (TREE_CODE (old) == FUNCTION_DECL
2058 && DECL_ANTICIPATED (old)
2059 && !DECL_HIDDEN_FRIEND_P (old))
2062 else if (old == error_mark_node)
2063 /* Ignore the undefined symbol marker. */
2067 error ("previous non-function declaration %q+#D", old);
2068 error ("conflicts with function declaration %q#D", decl);
2069 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2073 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2074 /* If it's a using declaration, we always need to build an OVERLOAD,
2075 because it's the only way to remember that the declaration comes
2076 from 'using', and have the lookup behave correctly. */
2077 || (flags & PUSH_USING))
2079 if (old && TREE_CODE (old) != OVERLOAD)
2080 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2082 new_binding = ovl_cons (decl, old);
2083 if (flags & PUSH_USING)
2084 OVL_USED (new_binding) = 1;
2087 /* NAME is not ambiguous. */
2091 set_namespace_binding (name, current_namespace, new_binding);
2094 /* We only create an OVERLOAD if there was a previous binding at
2095 this level, or if decl is a template. In the former case, we
2096 need to remove the old binding and replace it with the new
2097 binding. We must also run through the NAMES on the binding
2098 level where the name was bound to update the chain. */
2100 if (TREE_CODE (new_binding) == OVERLOAD && old)
2104 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2106 d = &TREE_CHAIN (*d))
2108 || (TREE_CODE (*d) == TREE_LIST
2109 && TREE_VALUE (*d) == old))
2111 if (TREE_CODE (*d) == TREE_LIST)
2112 /* Just replace the old binding with the new. */
2113 TREE_VALUE (*d) = new_binding;
2115 /* Build a TREE_LIST to wrap the OVERLOAD. */
2116 *d = tree_cons (NULL_TREE, new_binding,
2119 /* And update the cxx_binding node. */
2120 IDENTIFIER_BINDING (name)->value = new_binding;
2121 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2124 /* We should always find a previous binding in this case. */
2128 /* Install the new binding. */
2129 push_local_binding (name, new_binding, flags);
2132 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2135 /* Check a non-member using-declaration. Return the name and scope
2136 being used, and the USING_DECL, or NULL_TREE on failure. */
2139 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2141 /* [namespace.udecl]
2142 A using-declaration for a class member shall be a
2143 member-declaration. */
2146 error ("%qT is not a namespace", scope);
2149 else if (scope == error_mark_node)
2152 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2155 A using-declaration shall not name a template-id. */
2156 error ("a using-declaration cannot specify a template-id. "
2157 "Try %<using %D%>", name);
2161 if (TREE_CODE (decl) == NAMESPACE_DECL)
2163 error ("namespace %qD not allowed in using-declaration", decl);
2167 if (TREE_CODE (decl) == SCOPE_REF)
2169 /* It's a nested name with template parameter dependent scope.
2170 This can only be using-declaration for class member. */
2171 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2175 if (is_overloaded_fn (decl))
2176 decl = get_first_fn (decl);
2178 gcc_assert (DECL_P (decl));
2180 /* Make a USING_DECL. */
2181 return push_using_decl (scope, name);
2184 /* Process local and global using-declarations. */
2187 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2188 tree *newval, tree *newtype)
2190 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2192 *newval = *newtype = NULL_TREE;
2193 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2197 if (!decls.value && !decls.type)
2199 error ("%qD not declared", name);
2203 /* Shift the old and new bindings around so we're comparing class and
2204 enumeration names to each other. */
2205 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2211 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2213 decls.type = decls.value;
2214 decls.value = NULL_TREE;
2217 /* It is impossible to overload a built-in function; any explicit
2218 declaration eliminates the built-in declaration. So, if OLDVAL
2219 is a built-in, then we can just pretend it isn't there. */
2221 && TREE_CODE (oldval) == FUNCTION_DECL
2222 && DECL_ANTICIPATED (oldval)
2223 && !DECL_HIDDEN_FRIEND_P (oldval))
2228 /* Check for using functions. */
2229 if (is_overloaded_fn (decls.value))
2233 if (oldval && !is_overloaded_fn (oldval))
2235 error ("%qD is already declared in this scope", name);
2240 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2242 tree new_fn = OVL_CURRENT (tmp);
2244 /* [namespace.udecl]
2246 If a function declaration in namespace scope or block
2247 scope has the same name and the same parameter types as a
2248 function introduced by a using declaration the program is
2250 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2252 tree old_fn = OVL_CURRENT (tmp1);
2254 if (new_fn == old_fn)
2255 /* The function already exists in the current namespace. */
2257 else if (OVL_USED (tmp1))
2258 continue; /* this is a using decl */
2259 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2260 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2262 gcc_assert (!DECL_ANTICIPATED (old_fn)
2263 || DECL_HIDDEN_FRIEND_P (old_fn));
2265 /* There was already a non-using declaration in
2266 this scope with the same parameter types. If both
2267 are the same extern "C" functions, that's ok. */
2268 if (decls_match (new_fn, old_fn))
2272 error ("%qD is already declared in this scope", name);
2278 /* If we broke out of the loop, there's no reason to add
2279 this function to the using declarations for this
2284 /* If we are adding to an existing OVERLOAD, then we no
2285 longer know the type of the set of functions. */
2286 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2287 TREE_TYPE (*newval) = unknown_type_node;
2288 /* Add this new function to the set. */
2289 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2290 /* If there is only one function, then we use its type. (A
2291 using-declaration naming a single function can be used in
2292 contexts where overload resolution cannot be
2294 if (TREE_CODE (*newval) != OVERLOAD)
2296 *newval = ovl_cons (*newval, NULL_TREE);
2297 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2299 OVL_USED (*newval) = 1;
2304 *newval = decls.value;
2305 if (oldval && !decls_match (*newval, oldval))
2306 error ("%qD is already declared in this scope", name);
2312 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2314 error ("reference to %qD is ambiguous", name);
2315 print_candidates (decls.type);
2319 *newtype = decls.type;
2320 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2321 error ("%qD is already declared in this scope", name);
2324 /* If *newval is empty, shift any class or enumeration name down. */
2328 *newtype = NULL_TREE;
2332 /* Process a using-declaration at function scope. */
2335 do_local_using_decl (tree decl, tree scope, tree name)
2337 tree oldval, oldtype, newval, newtype;
2338 tree orig_decl = decl;
2340 decl = validate_nonmember_using_decl (decl, scope, name);
2341 if (decl == NULL_TREE)
2344 if (building_stmt_tree ()
2345 && at_function_scope_p ())
2346 add_decl_expr (decl);
2348 oldval = lookup_name_innermost_nonclass_level (name);
2349 oldtype = lookup_type_current_level (name);
2351 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2355 if (is_overloaded_fn (newval))
2359 /* We only need to push declarations for those functions
2360 that were not already bound in the current level.
2361 The old value might be NULL_TREE, it might be a single
2362 function, or an OVERLOAD. */
2363 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2364 term = OVL_FUNCTION (oldval);
2367 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2369 push_overloaded_decl (OVL_CURRENT (fn),
2370 PUSH_LOCAL | PUSH_USING,
2374 push_local_binding (name, newval, PUSH_USING);
2378 push_local_binding (name, newtype, PUSH_USING);
2379 set_identifier_type_value (name, newtype);
2382 /* Emit debug info. */
2383 if (!processing_template_decl)
2384 cp_emit_debug_info_for_using (orig_decl, current_scope());
2387 /* Returns true if ROOT (a namespace, class, or function) encloses
2388 CHILD. CHILD may be either a class type or a namespace. */
2391 is_ancestor (tree root, tree child)
2393 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2394 || TREE_CODE (root) == FUNCTION_DECL
2395 || CLASS_TYPE_P (root)));
2396 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2397 || CLASS_TYPE_P (child)));
2399 /* The global namespace encloses everything. */
2400 if (root == global_namespace)
2405 /* If we've run out of scopes, stop. */
2408 /* If we've reached the ROOT, it encloses CHILD. */
2411 /* Go out one level. */
2413 child = TYPE_NAME (child);
2414 child = DECL_CONTEXT (child);
2418 /* Enter the class or namespace scope indicated by T suitable for name
2419 lookup. T can be arbitrary scope, not necessary nested inside the
2420 current scope. Returns a non-null scope to pop iff pop_scope
2421 should be called later to exit this scope. */
2426 if (TREE_CODE (t) == NAMESPACE_DECL)
2427 push_decl_namespace (t);
2428 else if (CLASS_TYPE_P (t))
2430 if (!at_class_scope_p ()
2431 || !same_type_p (current_class_type, t))
2432 push_nested_class (t);
2434 /* T is the same as the current scope. There is therefore no
2435 need to re-enter the scope. Since we are not actually
2436 pushing a new scope, our caller should not call
2444 /* Leave scope pushed by push_scope. */
2449 if (TREE_CODE (t) == NAMESPACE_DECL)
2450 pop_decl_namespace ();
2451 else if CLASS_TYPE_P (t)
2452 pop_nested_class ();
2455 /* Subroutine of push_inner_scope. */
2458 push_inner_scope_r (tree outer, tree inner)
2463 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2466 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2468 push_inner_scope_r (outer, prev);
2469 if (TREE_CODE (inner) == NAMESPACE_DECL)
2471 struct cp_binding_level *save_template_parm = 0;
2472 /* Temporary take out template parameter scopes. They are saved
2473 in reversed order in save_template_parm. */
2474 while (current_binding_level->kind == sk_template_parms)
2476 struct cp_binding_level *b = current_binding_level;
2477 current_binding_level = b->level_chain;
2478 b->level_chain = save_template_parm;
2479 save_template_parm = b;
2482 resume_scope (NAMESPACE_LEVEL (inner));
2483 current_namespace = inner;
2485 /* Restore template parameter scopes. */
2486 while (save_template_parm)
2488 struct cp_binding_level *b = save_template_parm;
2489 save_template_parm = b->level_chain;
2490 b->level_chain = current_binding_level;
2491 current_binding_level = b;
2498 /* Enter the scope INNER from current scope. INNER must be a scope
2499 nested inside current scope. This works with both name lookup and
2500 pushing name into scope. In case a template parameter scope is present,
2501 namespace is pushed under the template parameter scope according to
2502 name lookup rule in 14.6.1/6.
2504 Return the former current scope suitable for pop_inner_scope. */
2507 push_inner_scope (tree inner)
2509 tree outer = current_scope ();
2511 outer = current_namespace;
2513 push_inner_scope_r (outer, inner);
2517 /* Exit the current scope INNER back to scope OUTER. */
2520 pop_inner_scope (tree outer, tree inner)
2523 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2526 while (outer != inner)
2528 if (TREE_CODE (inner) == NAMESPACE_DECL)
2530 struct cp_binding_level *save_template_parm = 0;
2531 /* Temporary take out template parameter scopes. They are saved
2532 in reversed order in save_template_parm. */
2533 while (current_binding_level->kind == sk_template_parms)
2535 struct cp_binding_level *b = current_binding_level;
2536 current_binding_level = b->level_chain;
2537 b->level_chain = save_template_parm;
2538 save_template_parm = b;
2543 /* Restore template parameter scopes. */
2544 while (save_template_parm)
2546 struct cp_binding_level *b = save_template_parm;
2547 save_template_parm = b->level_chain;
2548 b->level_chain = current_binding_level;
2549 current_binding_level = b;
2555 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2559 /* Do a pushlevel for class declarations. */
2562 pushlevel_class (void)
2564 if (ENABLE_SCOPE_CHECKING)
2567 class_binding_level = begin_scope (sk_class, current_class_type);
2570 /* ...and a poplevel for class declarations. */
2573 poplevel_class (void)
2575 struct cp_binding_level *level = class_binding_level;
2576 cp_class_binding *cb;
2580 timevar_push (TV_NAME_LOOKUP);
2581 gcc_assert (level != 0);
2583 /* If we're leaving a toplevel class, cache its binding level. */
2584 if (current_class_depth == 1)
2585 previous_class_level = level;
2586 for (shadowed = level->type_shadowed;
2588 shadowed = TREE_CHAIN (shadowed))
2589 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2591 /* Remove the bindings for all of the class-level declarations. */
2592 if (level->class_shadowed)
2595 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2597 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2598 ggc_free (level->class_shadowed);
2599 level->class_shadowed = NULL;
2602 /* Now, pop out of the binding level which we created up in the
2603 `pushlevel_class' routine. */
2604 if (ENABLE_SCOPE_CHECKING)
2608 timevar_pop (TV_NAME_LOOKUP);
2611 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2612 appropriate. DECL is the value to which a name has just been
2613 bound. CLASS_TYPE is the class in which the lookup occurred. */
2616 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2619 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2623 if (TREE_CODE (decl) == OVERLOAD)
2624 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2627 gcc_assert (DECL_P (decl));
2628 context = context_for_name_lookup (decl);
2631 if (is_properly_derived_from (class_type, context))
2632 INHERITED_VALUE_BINDING_P (binding) = 1;
2634 INHERITED_VALUE_BINDING_P (binding) = 0;
2636 else if (binding->value == decl)
2637 /* We only encounter a TREE_LIST when there is an ambiguity in the
2638 base classes. Such an ambiguity can be overridden by a
2639 definition in this class. */
2640 INHERITED_VALUE_BINDING_P (binding) = 1;
2642 INHERITED_VALUE_BINDING_P (binding) = 0;
2645 /* Make the declaration of X appear in CLASS scope. */
2648 pushdecl_class_level (tree x)
2651 bool is_valid = true;
2653 timevar_push (TV_NAME_LOOKUP);
2654 /* Get the name of X. */
2655 if (TREE_CODE (x) == OVERLOAD)
2656 name = DECL_NAME (get_first_fn (x));
2658 name = DECL_NAME (x);
2662 is_valid = push_class_level_binding (name, x);
2663 if (TREE_CODE (x) == TYPE_DECL)
2664 set_identifier_type_value (name, x);
2666 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2668 /* If X is an anonymous aggregate, all of its members are
2669 treated as if they were members of the class containing the
2670 aggregate, for naming purposes. */
2673 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2675 location_t save_location = input_location;
2676 input_location = DECL_SOURCE_LOCATION (f);
2677 if (!pushdecl_class_level (f))
2679 input_location = save_location;
2682 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2685 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2686 scope. If the value returned is non-NULL, and the PREVIOUS field
2687 is not set, callers must set the PREVIOUS field explicitly. */
2689 static cxx_binding *
2690 get_class_binding (tree name, cxx_scope *scope)
2695 cxx_binding *binding;
2697 class_type = scope->this_entity;
2699 /* Get the type binding. */
2700 type_binding = lookup_member (class_type, name,
2701 /*protect=*/2, /*want_type=*/true);
2702 /* Get the value binding. */
2703 value_binding = lookup_member (class_type, name,
2704 /*protect=*/2, /*want_type=*/false);
2707 && (TREE_CODE (value_binding) == TYPE_DECL
2708 || DECL_CLASS_TEMPLATE_P (value_binding)
2709 || (TREE_CODE (value_binding) == TREE_LIST
2710 && TREE_TYPE (value_binding) == error_mark_node
2711 && (TREE_CODE (TREE_VALUE (value_binding))
2713 /* We found a type binding, even when looking for a non-type
2714 binding. This means that we already processed this binding
2717 else if (value_binding)
2719 if (TREE_CODE (value_binding) == TREE_LIST
2720 && TREE_TYPE (value_binding) == error_mark_node)
2721 /* NAME is ambiguous. */
2723 else if (BASELINK_P (value_binding))
2724 /* NAME is some overloaded functions. */
2725 value_binding = BASELINK_FUNCTIONS (value_binding);
2728 /* If we found either a type binding or a value binding, create a
2729 new binding object. */
2730 if (type_binding || value_binding)
2732 binding = new_class_binding (name,
2736 /* This is a class-scope binding, not a block-scope binding. */
2737 LOCAL_BINDING_P (binding) = 0;
2738 set_inherited_value_binding_p (binding, value_binding, class_type);
2746 /* Make the declaration(s) of X appear in CLASS scope under the name
2747 NAME. Returns true if the binding is valid. */
2750 push_class_level_binding (tree name, tree x)
2752 cxx_binding *binding;
2756 timevar_push (TV_NAME_LOOKUP);
2757 /* The class_binding_level will be NULL if x is a template
2758 parameter name in a member template. */
2759 if (!class_binding_level)
2760 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2762 if (name == error_mark_node)
2763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2765 /* Check for invalid member names. */
2766 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2767 /* We could have been passed a tree list if this is an ambiguous
2768 declaration. If so, pull the declaration out because
2769 check_template_shadow will not handle a TREE_LIST. */
2770 if (TREE_CODE (decl) == TREE_LIST
2771 && TREE_TYPE (decl) == error_mark_node)
2772 decl = TREE_VALUE (decl);
2774 if (!check_template_shadow (decl))
2775 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2779 If T is the name of a class, then each of the following shall
2780 have a name different from T:
2782 -- every static data member of class T;
2784 -- every member of class T that is itself a type;
2786 -- every enumerator of every member of class T that is an
2789 -- every member of every anonymous union that is a member of
2792 (Non-static data members were also forbidden to have the same
2793 name as T until TC1.) */
2794 if ((TREE_CODE (x) == VAR_DECL
2795 || TREE_CODE (x) == CONST_DECL
2796 || (TREE_CODE (x) == TYPE_DECL
2797 && !DECL_SELF_REFERENCE_P (x))
2798 /* A data member of an anonymous union. */
2799 || (TREE_CODE (x) == FIELD_DECL
2800 && DECL_CONTEXT (x) != current_class_type))
2801 && DECL_NAME (x) == constructor_name (current_class_type))
2803 tree scope = context_for_name_lookup (x);
2804 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2806 error ("%qD has the same name as the class in which it is "
2809 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2813 /* Get the current binding for NAME in this class, if any. */
2814 binding = IDENTIFIER_BINDING (name);
2815 if (!binding || binding->scope != class_binding_level)
2817 binding = get_class_binding (name, class_binding_level);
2818 /* If a new binding was created, put it at the front of the
2819 IDENTIFIER_BINDING list. */
2822 binding->previous = IDENTIFIER_BINDING (name);
2823 IDENTIFIER_BINDING (name) = binding;
2827 /* If there is already a binding, then we may need to update the
2829 if (binding && binding->value)
2831 tree bval = binding->value;
2832 tree old_decl = NULL_TREE;
2834 if (INHERITED_VALUE_BINDING_P (binding))
2836 /* If the old binding was from a base class, and was for a
2837 tag name, slide it over to make room for the new binding.
2838 The old binding is still visible if explicitly qualified
2839 with a class-key. */
2840 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2841 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2843 old_decl = binding->type;
2844 binding->type = bval;
2845 binding->value = NULL_TREE;
2846 INHERITED_VALUE_BINDING_P (binding) = 0;
2851 /* Any inherited type declaration is hidden by the type
2852 declaration in the derived class. */
2853 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2854 binding->type = NULL_TREE;
2857 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2859 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2861 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2863 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2864 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2866 if (old_decl && binding->scope == class_binding_level)
2869 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2870 here. This function is only used to register bindings
2871 from with the class definition itself. */
2872 INHERITED_VALUE_BINDING_P (binding) = 0;
2873 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2877 /* Note that we declared this value so that we can issue an error if
2878 this is an invalid redeclaration of a name already used for some
2880 note_name_declared_in_class (name, decl);
2882 /* If we didn't replace an existing binding, put the binding on the
2883 stack of bindings for the identifier, and update the shadowed
2885 if (binding && binding->scope == class_binding_level)
2886 /* Supplement the existing binding. */
2887 ok = supplement_binding (binding, decl);
2890 /* Create a new binding. */
2891 push_binding (name, decl, class_binding_level);
2895 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2898 /* Process "using SCOPE::NAME" in a class scope. Return the
2899 USING_DECL created. */
2902 do_class_using_decl (tree scope, tree name)
2904 /* The USING_DECL returned by this function. */
2906 /* The declaration (or declarations) name by this using
2907 declaration. NULL if we are in a template and cannot figure out
2908 what has been named. */
2910 /* True if SCOPE is a dependent type. */
2911 bool scope_dependent_p;
2912 /* True if SCOPE::NAME is dependent. */
2913 bool name_dependent_p;
2914 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2915 bool bases_dependent_p;
2920 if (name == error_mark_node)
2923 if (!scope || !TYPE_P (scope))
2925 error ("using-declaration for non-member at class scope");
2929 /* Make sure the name is not invalid */
2930 if (TREE_CODE (name) == BIT_NOT_EXPR)
2932 error ("%<%T::%D%> names destructor", scope, name);
2935 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2937 error ("%<%T::%D%> names constructor", scope, name);
2940 if (constructor_name_p (name, current_class_type))
2942 error ("%<%T::%D%> names constructor in %qT",
2943 scope, name, current_class_type);
2947 scope_dependent_p = dependent_type_p (scope);
2948 name_dependent_p = (scope_dependent_p
2949 || (IDENTIFIER_TYPENAME_P (name)
2950 && dependent_type_p (TREE_TYPE (name))));
2952 bases_dependent_p = false;
2953 if (processing_template_decl)
2954 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2955 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2957 if (dependent_type_p (TREE_TYPE (base_binfo)))
2959 bases_dependent_p = true;
2965 /* From [namespace.udecl]:
2967 A using-declaration used as a member-declaration shall refer to a
2968 member of a base class of the class being defined.
2970 In general, we cannot check this constraint in a template because
2971 we do not know the entire set of base classes of the current
2972 class type. However, if all of the base classes are
2973 non-dependent, then we can avoid delaying the check until
2975 if (!scope_dependent_p)
2978 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2979 if (b_kind < bk_proper_base)
2981 if (!bases_dependent_p)
2983 error_not_base_type (scope, current_class_type);
2987 else if (!name_dependent_p)
2989 decl = lookup_member (binfo, name, 0, false);
2992 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2996 /* The binfo from which the functions came does not matter. */
2997 if (BASELINK_P (decl))
2998 decl = BASELINK_FUNCTIONS (decl);
3002 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3003 USING_DECL_DECLS (value) = decl;
3004 USING_DECL_SCOPE (value) = scope;
3005 DECL_DEPENDENT_P (value) = !decl;
3011 /* Return the binding value for name in scope. */
3014 namespace_binding (tree name, tree scope)
3016 cxx_binding *binding;
3019 scope = global_namespace;
3021 /* Unnecessary for the global namespace because it can't be an alias. */
3022 scope = ORIGINAL_NAMESPACE (scope);
3024 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3026 return binding ? binding->value : NULL_TREE;
3029 /* Set the binding value for name in scope. */
3032 set_namespace_binding (tree name, tree scope, tree val)
3036 timevar_push (TV_NAME_LOOKUP);
3037 if (scope == NULL_TREE)
3038 scope = global_namespace;
3039 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3040 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3043 supplement_binding (b, val);
3044 timevar_pop (TV_NAME_LOOKUP);
3047 /* Set the context of a declaration to scope. Complain if we are not
3051 set_decl_namespace (tree decl, tree scope, bool friendp)
3055 /* Get rid of namespace aliases. */
3056 scope = ORIGINAL_NAMESPACE (scope);
3058 /* It is ok for friends to be qualified in parallel space. */
3059 if (!friendp && !is_ancestor (current_namespace, scope))
3060 error ("declaration of %qD not in a namespace surrounding %qD",
3062 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3064 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3065 if (scope == current_namespace)
3067 if (at_namespace_scope_p ())
3068 error ("explicit qualification in declaration of %qD",
3073 /* See whether this has been declared in the namespace. */
3074 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3075 if (old == error_mark_node)
3076 /* No old declaration at all. */
3078 if (!is_overloaded_fn (decl))
3079 /* Don't compare non-function decls with decls_match here, since
3080 it can't check for the correct constness at this
3081 point. pushdecl will find those errors later. */
3083 /* Since decl is a function, old should contain a function decl. */
3084 if (!is_overloaded_fn (old))
3086 fn = OVL_CURRENT (old);
3087 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3089 /* A template can be explicitly specialized in any namespace. */
3090 if (processing_explicit_instantiation)
3092 if (processing_template_decl || processing_specialization)
3093 /* We have not yet called push_template_decl to turn a
3094 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3095 match. But, we'll check later, when we construct the
3098 /* Instantiations or specializations of templates may be declared as
3099 friends in any namespace. */
3100 if (friendp && DECL_USE_TEMPLATE (decl))
3102 if (is_overloaded_fn (old))
3104 for (; old; old = OVL_NEXT (old))
3105 if (decls_match (decl, OVL_CURRENT (old)))
3108 else if (decls_match (decl, old))
3111 error ("%qD should have been declared inside %qD", decl, scope);
3114 /* Return the namespace where the current declaration is declared. */
3117 current_decl_namespace (void)
3120 /* If we have been pushed into a different namespace, use it. */
3121 if (decl_namespace_list)
3122 return TREE_PURPOSE (decl_namespace_list);
3124 if (current_class_type)
3125 result = decl_namespace_context (current_class_type);
3126 else if (current_function_decl)
3127 result = decl_namespace_context (current_function_decl);
3129 result = current_namespace;
3133 /* Process any ATTRIBUTES on a namespace definition. Currently only
3134 attribute visibility is meaningful, which is a property of the syntactic
3135 block rather than the namespace as a whole, so we don't touch the
3136 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3139 handle_namespace_attrs (tree ns, tree attributes)
3142 bool saw_vis = false;
3144 for (d = attributes; d; d = TREE_CHAIN (d))
3146 tree name = TREE_PURPOSE (d);
3147 tree args = TREE_VALUE (d);
3149 #ifdef HANDLE_PRAGMA_VISIBILITY
3150 if (is_attribute_p ("visibility", name))
3152 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3153 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3155 warning (OPT_Wattributes,
3156 "%qD attribute requires a single NTBS argument",
3161 if (!TREE_PUBLIC (ns))
3162 warning (OPT_Wattributes,
3163 "%qD attribute is meaningless since members of the "
3164 "anonymous namespace get local symbols", name);
3166 push_visibility (TREE_STRING_POINTER (x));
3172 warning (OPT_Wattributes, "%qD attribute directive ignored",
3181 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3182 select a name that is unique to this compilation unit. */
3185 push_namespace (tree name)
3189 int implicit_use = 0;
3192 timevar_push (TV_NAME_LOOKUP);
3194 /* We should not get here if the global_namespace is not yet constructed
3195 nor if NAME designates the global namespace: The global scope is
3196 constructed elsewhere. */
3197 gcc_assert (global_namespace != NULL && name != global_scope_name);
3201 name = get_anonymous_namespace_name();
3202 d = IDENTIFIER_NAMESPACE_VALUE (name);
3204 /* Reopening anonymous namespace. */
3210 /* Check whether this is an extended namespace definition. */
3211 d = IDENTIFIER_NAMESPACE_VALUE (name);
3212 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3215 if (DECL_NAMESPACE_ALIAS (d))
3217 error ("namespace alias %qD not allowed here, assuming %qD",
3218 d, DECL_NAMESPACE_ALIAS (d));
3219 d = DECL_NAMESPACE_ALIAS (d);
3226 /* Make a new namespace, binding the name to it. */
3227 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3228 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3229 /* The name of this namespace is not visible to other translation
3230 units if it is an anonymous namespace or member thereof. */
3231 if (anon || decl_anon_ns_mem_p (current_namespace))
3232 TREE_PUBLIC (d) = 0;
3234 TREE_PUBLIC (d) = 1;
3238 /* Clear DECL_NAME for the benefit of debugging back ends. */
3239 SET_DECL_ASSEMBLER_NAME (d, name);
3240 DECL_NAME (d) = NULL_TREE;
3242 begin_scope (sk_namespace, d);
3245 resume_scope (NAMESPACE_LEVEL (d));
3248 do_using_directive (d);
3249 /* Enter the name space. */
3250 current_namespace = d;
3252 timevar_pop (TV_NAME_LOOKUP);
3255 /* Pop from the scope of the current namespace. */
3258 pop_namespace (void)
3260 gcc_assert (current_namespace != global_namespace);
3261 current_namespace = CP_DECL_CONTEXT (current_namespace);
3262 /* The binding level is not popped, as it might be re-opened later. */
3266 /* Push into the scope of the namespace NS, even if it is deeply
3267 nested within another namespace. */
3270 push_nested_namespace (tree ns)
3272 if (ns == global_namespace)
3273 push_to_top_level ();
3276 push_nested_namespace (CP_DECL_CONTEXT (ns));
3277 push_namespace (DECL_NAME (ns));
3281 /* Pop back from the scope of the namespace NS, which was previously
3282 entered with push_nested_namespace. */
3285 pop_nested_namespace (tree ns)
3287 timevar_push (TV_NAME_LOOKUP);
3288 while (ns != global_namespace)
3291 ns = CP_DECL_CONTEXT (ns);
3294 pop_from_top_level ();
3295 timevar_pop (TV_NAME_LOOKUP);
3298 /* Temporarily set the namespace for the current declaration. */
3301 push_decl_namespace (tree decl)
3303 if (TREE_CODE (decl) != NAMESPACE_DECL)
3304 decl = decl_namespace_context (decl);
3305 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3306 NULL_TREE, decl_namespace_list);
3309 /* [namespace.memdef]/2 */
3312 pop_decl_namespace (void)
3314 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3317 /* Return the namespace that is the common ancestor
3318 of two given namespaces. */
3321 namespace_ancestor (tree ns1, tree ns2)
3323 timevar_push (TV_NAME_LOOKUP);
3324 if (is_ancestor (ns1, ns2))
3325 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3326 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3327 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3330 /* Process a namespace-alias declaration. */
3333 do_namespace_alias (tree alias, tree name_space)
3335 if (name_space == error_mark_node)
3338 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3340 name_space = ORIGINAL_NAMESPACE (name_space);
3342 /* Build the alias. */
3343 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3344 DECL_NAMESPACE_ALIAS (alias) = name_space;
3345 DECL_EXTERNAL (alias) = 1;
3346 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3349 /* Emit debug info for namespace alias. */
3350 if (!building_stmt_tree ())
3351 (*debug_hooks->global_decl) (alias);
3354 /* Like pushdecl, only it places X in the current namespace,
3358 pushdecl_namespace_level (tree x, bool is_friend)
3360 struct cp_binding_level *b = current_binding_level;
3363 timevar_push (TV_NAME_LOOKUP);
3364 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3366 /* Now, the type_shadowed stack may screw us. Munge it so it does
3368 if (TREE_CODE (t) == TYPE_DECL)
3370 tree name = DECL_NAME (t);
3372 tree *ptr = (tree *)0;
3373 for (; !global_scope_p (b); b = b->level_chain)
3375 tree shadowed = b->type_shadowed;
3376 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3377 if (TREE_PURPOSE (shadowed) == name)
3379 ptr = &TREE_VALUE (shadowed);
3380 /* Can't break out of the loop here because sometimes
3381 a binding level will have duplicate bindings for
3382 PT names. It's gross, but I haven't time to fix it. */
3385 newval = TREE_TYPE (t);
3386 if (ptr == (tree *)0)
3388 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3389 up here if this is changed to an assertion. --KR */
3390 SET_IDENTIFIER_TYPE_VALUE (name, t);
3397 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3400 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3401 directive is not directly from the source. Also find the common
3402 ancestor and let our users know about the new namespace */
3404 add_using_namespace (tree user, tree used, bool indirect)
3407 timevar_push (TV_NAME_LOOKUP);
3408 /* Using oneself is a no-op. */
3411 timevar_pop (TV_NAME_LOOKUP);
3414 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3415 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3416 /* Check if we already have this. */
3417 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3421 /* Promote to direct usage. */
3422 TREE_INDIRECT_USING (t) = 0;
3423 timevar_pop (TV_NAME_LOOKUP);
3427 /* Add used to the user's using list. */
3428 DECL_NAMESPACE_USING (user)
3429 = tree_cons (used, namespace_ancestor (user, used),
3430 DECL_NAMESPACE_USING (user));
3432 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3434 /* Add user to the used's users list. */
3435 DECL_NAMESPACE_USERS (used)
3436 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3438 /* Recursively add all namespaces used. */
3439 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3440 /* indirect usage */
3441 add_using_namespace (user, TREE_PURPOSE (t), 1);
3443 /* Tell everyone using us about the new used namespaces. */
3444 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3445 add_using_namespace (TREE_PURPOSE (t), used, 1);
3446 timevar_pop (TV_NAME_LOOKUP);
3449 /* Process a using-declaration not appearing in class or local scope. */
3452 do_toplevel_using_decl (tree decl, tree scope, tree name)
3454 tree oldval, oldtype, newval, newtype;
3455 tree orig_decl = decl;
3456 cxx_binding *binding;
3458 decl = validate_nonmember_using_decl (decl, scope, name);
3459 if (decl == NULL_TREE)
3462 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3464 oldval = binding->value;
3465 oldtype = binding->type;
3467 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3469 /* Emit debug info. */
3470 if (!processing_template_decl)
3471 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3473 /* Copy declarations found. */
3475 binding->value = newval;
3477 binding->type = newtype;
3480 /* Process a using-directive. */
3483 do_using_directive (tree name_space)
3485 tree context = NULL_TREE;
3487 if (name_space == error_mark_node)
3490 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3492 if (building_stmt_tree ())
3493 add_stmt (build_stmt (USING_STMT, name_space));
3494 name_space = ORIGINAL_NAMESPACE (name_space);
3496 if (!toplevel_bindings_p ())
3498 push_using_directive (name_space);
3503 add_using_namespace (current_namespace, name_space, 0);
3504 if (current_namespace != global_namespace)
3505 context = current_namespace;
3507 /* Emit debugging info. */
3508 if (!processing_template_decl)
3509 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3514 /* Deal with a using-directive seen by the parser. Currently we only
3515 handle attributes here, since they cannot appear inside a template. */
3518 parse_using_directive (tree name_space, tree attribs)
3522 do_using_directive (name_space);
3524 for (a = attribs; a; a = TREE_CHAIN (a))
3526 tree name = TREE_PURPOSE (a);
3527 if (is_attribute_p ("strong", name))
3529 if (!toplevel_bindings_p ())
3530 error ("strong using only meaningful at namespace scope");
3531 else if (name_space != error_mark_node)
3533 if (!is_ancestor (current_namespace, name_space))
3534 error ("current namespace %qD does not enclose strongly used namespace %qD",
3535 current_namespace, name_space);
3536 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3537 = tree_cons (current_namespace, 0,
3538 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3542 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3546 /* Like pushdecl, only it places X in the global scope if appropriate.
3547 Calls cp_finish_decl to register the variable, initializing it with
3548 *INIT, if INIT is non-NULL. */
3551 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3553 timevar_push (TV_NAME_LOOKUP);
3554 push_to_top_level ();
3555 x = pushdecl_namespace_level (x, is_friend);
3557 finish_decl (x, *init, NULL_TREE);
3558 pop_from_top_level ();
3559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3562 /* Like pushdecl, only it places X in the global scope if appropriate. */
3565 pushdecl_top_level (tree x)
3567 return pushdecl_top_level_1 (x, NULL, false);
3570 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3573 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3575 return pushdecl_top_level_1 (x, NULL, is_friend);
3578 /* Like pushdecl, only it places X in the global scope if
3579 appropriate. Calls cp_finish_decl to register the variable,
3580 initializing it with INIT. */
3583 pushdecl_top_level_and_finish (tree x, tree init)
3585 return pushdecl_top_level_1 (x, &init, false);
3588 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3589 duplicates. The first list becomes the tail of the result.
3591 The algorithm is O(n^2). We could get this down to O(n log n) by
3592 doing a sort on the addresses of the functions, if that becomes
3596 merge_functions (tree s1, tree s2)
3598 for (; s2; s2 = OVL_NEXT (s2))
3600 tree fn2 = OVL_CURRENT (s2);
3603 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3605 tree fn1 = OVL_CURRENT (fns1);
3607 /* If the function from S2 is already in S1, there is no
3608 need to add it again. For `extern "C"' functions, we
3609 might have two FUNCTION_DECLs for the same function, in
3610 different namespaces; again, we only need one of them. */
3612 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3613 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3617 /* If we exhausted all of the functions in S1, FN2 is new. */
3619 s1 = build_overload (fn2, s1);
3624 /* This should return an error not all definitions define functions.
3625 It is not an error if we find two functions with exactly the
3626 same signature, only if these are selected in overload resolution.
3627 old is the current set of bindings, new_binding the freshly-found binding.
3628 XXX Do we want to give *all* candidates in case of ambiguity?
3629 XXX In what way should I treat extern declarations?
3630 XXX I don't want to repeat the entire duplicate_decls here */
3633 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3636 gcc_assert (old != NULL);
3638 /* Copy the type. */
3639 type = new_binding->type;
3640 if (LOOKUP_NAMESPACES_ONLY (flags)
3641 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3644 /* Copy the value. */
3645 val = new_binding->value;
3648 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3651 switch (TREE_CODE (val))
3654 /* If we expect types or namespaces, and not templates,
3655 or this is not a template class. */
3656 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3657 && !DECL_CLASS_TEMPLATE_P (val)))
3661 if (LOOKUP_NAMESPACES_ONLY (flags)
3662 || (type && (flags & LOOKUP_PREFER_TYPES)))
3665 case NAMESPACE_DECL:
3666 if (LOOKUP_TYPES_ONLY (flags))
3670 /* Ignore built-in functions that are still anticipated. */
3671 if (LOOKUP_QUALIFIERS_ONLY (flags))
3675 if (LOOKUP_QUALIFIERS_ONLY (flags))
3680 /* If val is hidden, shift down any class or enumeration name. */
3689 else if (val && val != old->value)
3691 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3692 old->value = merge_functions (old->value, val);
3695 old->value = tree_cons (NULL_TREE, old->value,
3696 build_tree_list (NULL_TREE, val));
3697 TREE_TYPE (old->value) = error_mark_node;
3703 else if (type && old->type != type)
3705 old->type = tree_cons (NULL_TREE, old->type,
3706 build_tree_list (NULL_TREE, type));
3707 TREE_TYPE (old->type) = error_mark_node;
3711 /* Return the declarations that are members of the namespace NS. */
3714 cp_namespace_decls (tree ns)
3716 return NAMESPACE_LEVEL (ns)->names;
3719 /* Combine prefer_type and namespaces_only into flags. */
3722 lookup_flags (int prefer_type, int namespaces_only)
3724 if (namespaces_only)
3725 return LOOKUP_PREFER_NAMESPACES;
3726 if (prefer_type > 1)
3727 return LOOKUP_PREFER_TYPES;
3728 if (prefer_type > 0)
3729 return LOOKUP_PREFER_BOTH;
3733 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3734 ignore it or not. Subroutine of lookup_name_real and
3735 lookup_type_scope. */
3738 qualify_lookup (tree val, int flags)
3740 if (val == NULL_TREE)
3742 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3744 if ((flags & LOOKUP_PREFER_TYPES)
3745 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3747 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3752 /* Given a lookup that returned VAL, decide if we want to ignore it or
3753 not based on DECL_ANTICIPATED. */
3756 hidden_name_p (tree val)
3759 && DECL_LANG_SPECIFIC (val)
3760 && DECL_ANTICIPATED (val))
3765 /* Remove any hidden friend functions from a possibly overloaded set
3769 remove_hidden_names (tree fns)
3774 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3776 else if (TREE_CODE (fns) == OVERLOAD)
3780 for (o = fns; o; o = OVL_NEXT (o))
3781 if (hidden_name_p (OVL_CURRENT (o)))
3787 for (o = fns; o; o = OVL_NEXT (o))
3788 if (!hidden_name_p (OVL_CURRENT (o)))
3789 n = build_overload (OVL_CURRENT (o), n);
3797 /* Unscoped lookup of a global: iterate over current namespaces,
3798 considering using-directives. */
3801 unqualified_namespace_lookup (tree name, int flags)
3803 tree initial = current_decl_namespace ();
3804 tree scope = initial;
3806 struct cp_binding_level *level;
3807 tree val = NULL_TREE;
3809 timevar_push (TV_NAME_LOOKUP);
3811 for (; !val; scope = CP_DECL_CONTEXT (scope))
3813 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3815 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3818 ambiguous_decl (&binding, b, flags);
3820 /* Add all _DECLs seen through local using-directives. */
3821 for (level = current_binding_level;
3822 level->kind != sk_namespace;
3823 level = level->level_chain)
3824 if (!lookup_using_namespace (name, &binding, level->using_directives,
3826 /* Give up because of error. */
3827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3829 /* Add all _DECLs seen through global using-directives. */
3830 /* XXX local and global using lists should work equally. */
3834 if (!lookup_using_namespace (name, &binding,
3835 DECL_NAMESPACE_USING (siter),
3837 /* Give up because of error. */
3838 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3839 if (siter == scope) break;
3840 siter = CP_DECL_CONTEXT (siter);
3843 val = binding.value;
3844 if (scope == global_namespace)
3847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3850 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3851 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3854 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3855 declaration found. If no suitable declaration can be found,
3856 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3857 neither a class-type nor a namespace a diagnostic is issued. */
3860 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3865 if (TREE_CODE (scope) == NAMESPACE_DECL)
3867 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3869 flags |= LOOKUP_COMPLAIN;
3871 flags |= LOOKUP_PREFER_TYPES;
3872 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3875 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3876 t = lookup_enumerator (scope, name);
3877 else if (is_class_type (scope, complain))
3878 t = lookup_member (scope, name, 2, is_type_p);
3881 return error_mark_node;
3885 /* Subroutine of unqualified_namespace_lookup:
3886 Add the bindings of NAME in used namespaces to VAL.
3887 We are currently looking for names in namespace SCOPE, so we
3888 look through USINGS for using-directives of namespaces
3889 which have SCOPE as a common ancestor with the current scope.
3890 Returns false on errors. */
3893 lookup_using_namespace (tree name, struct scope_binding *val,
3894 tree usings, tree scope, int flags)
3897 timevar_push (TV_NAME_LOOKUP);
3898 /* Iterate over all used namespaces in current, searching for using
3899 directives of scope. */
3900 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3901 if (TREE_VALUE (iter) == scope)
3903 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3905 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3906 /* Resolve ambiguities. */
3908 ambiguous_decl (val, val1, flags);
3910 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3914 Accepts the NAME to lookup and its qualifying SCOPE.
3915 Returns the name/type pair found into the cxx_binding *RESULT,
3916 or false on error. */
3919 qualified_lookup_using_namespace (tree name, tree scope,
3920 struct scope_binding *result, int flags)
3922 /* Maintain a list of namespaces visited... */
3923 tree seen = NULL_TREE;
3924 /* ... and a list of namespace yet to see. */
3925 tree todo = NULL_TREE;
3926 tree todo_maybe = NULL_TREE;
3928 timevar_push (TV_NAME_LOOKUP);
3929 /* Look through namespace aliases. */
3930 scope = ORIGINAL_NAMESPACE (scope);
3931 while (scope && result->value != error_mark_node)
3933 cxx_binding *binding =
3934 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3935 seen = tree_cons (scope, NULL_TREE, seen);
3937 ambiguous_decl (result, binding, flags);
3939 /* Consider strong using directives always, and non-strong ones
3940 if we haven't found a binding yet. ??? Shouldn't we consider
3941 non-strong ones if the initial RESULT is non-NULL, but the
3942 binding in the given namespace is? */
3943 for (usings = DECL_NAMESPACE_USING (scope); usings;
3944 usings = TREE_CHAIN (usings))
3945 /* If this was a real directive, and we have not seen it. */
3946 if (!TREE_INDIRECT_USING (usings))
3948 /* Try to avoid queuing the same namespace more than once,
3949 the exception being when a namespace was already
3950 enqueued for todo_maybe and then a strong using is
3951 found for it. We could try to remove it from
3952 todo_maybe, but it's probably not worth the effort. */
3953 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3954 && !purpose_member (TREE_PURPOSE (usings), seen)
3955 && !purpose_member (TREE_PURPOSE (usings), todo))
3956 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3957 else if ((!result->value && !result->type)
3958 && !purpose_member (TREE_PURPOSE (usings), seen)
3959 && !purpose_member (TREE_PURPOSE (usings), todo)
3960 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3961 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3966 scope = TREE_PURPOSE (todo);
3967 todo = TREE_CHAIN (todo);
3970 && (!result->value && !result->type))
3972 scope = TREE_PURPOSE (todo_maybe);
3973 todo = TREE_CHAIN (todo_maybe);
3974 todo_maybe = NULL_TREE;
3977 scope = NULL_TREE; /* If there never was a todo list. */
3979 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3982 /* Subroutine of outer_binding.
3983 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
3987 binding_to_template_parms_of_scope_p (cxx_binding *binding,
3992 if (!binding || !scope)
3995 binding_value = binding->value ? binding->value : binding->type;
3998 && scope->this_entity
3999 && get_template_info (scope->this_entity)
4000 && parameter_of_template_p (binding_value,
4001 TI_TEMPLATE (get_template_info \
4002 (scope->this_entity))));
4005 /* Return the innermost non-namespace binding for NAME from a scope
4006 containing BINDING, or, if BINDING is NULL, the current scope.
4007 Please note that for a given template, the template parameters are
4008 considered to be in the scope containing the current scope.
4009 If CLASS_P is false, then class bindings are ignored. */
4012 outer_binding (tree name,
4013 cxx_binding *binding,
4018 cxx_scope *outer_scope;
4022 scope = binding->scope->level_chain;
4023 outer = binding->previous;
4027 scope = current_binding_level;
4028 outer = IDENTIFIER_BINDING (name);
4030 outer_scope = outer ? outer->scope : NULL;
4032 /* Because we create class bindings lazily, we might be missing a
4033 class binding for NAME. If there are any class binding levels
4034 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4035 declared, we must lookup NAME in those class scopes. */
4037 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4039 if (scope->kind == sk_class)
4041 cxx_binding *class_binding;
4043 class_binding = get_class_binding (name, scope);
4046 /* Thread this new class-scope binding onto the
4047 IDENTIFIER_BINDING list so that future lookups
4049 class_binding->previous = outer;
4051 binding->previous = class_binding;
4053 IDENTIFIER_BINDING (name) = class_binding;
4054 return class_binding;
4057 /* If we are in a member template, the template parms of the member
4058 template are considered to be inside the scope of the containing
4059 class, but within G++ the class bindings are all pushed between the
4060 template parms and the function body. So if the outer binding is
4061 a template parm for the current scope, return it now rather than
4062 look for a class binding. */
4063 if (outer_scope && outer_scope->kind == sk_template_parms
4064 && binding_to_template_parms_of_scope_p (outer, scope))
4067 scope = scope->level_chain;
4073 /* Return the innermost block-scope or class-scope value binding for
4074 NAME, or NULL_TREE if there is no such binding. */
4077 innermost_non_namespace_value (tree name)
4079 cxx_binding *binding;
4080 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4081 return binding ? binding->value : NULL_TREE;
4084 /* Look up NAME in the current binding level and its superiors in the
4085 namespace of variables, functions and typedefs. Return a ..._DECL
4086 node of some kind representing its definition if there is only one
4087 such declaration, or return a TREE_LIST with all the overloaded
4088 definitions if there are many, or return 0 if it is undefined.
4089 Hidden name, either friend declaration or built-in function, are
4092 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4093 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4094 Otherwise we prefer non-TYPE_DECLs.
4096 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4097 BLOCK_P is false, bindings in block scopes are ignored. */
4100 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4101 int namespaces_only, int flags)
4104 tree val = NULL_TREE;
4106 timevar_push (TV_NAME_LOOKUP);
4107 /* Conversion operators are handled specially because ordinary
4108 unqualified name lookup will not find template conversion
4110 if (IDENTIFIER_TYPENAME_P (name))
4112 struct cp_binding_level *level;
4114 for (level = current_binding_level;
4115 level && level->kind != sk_namespace;
4116 level = level->level_chain)
4121 /* A conversion operator can only be declared in a class
4123 if (level->kind != sk_class)
4126 /* Lookup the conversion operator in the class. */
4127 class_type = level->this_entity;
4128 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4130 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4133 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4136 flags |= lookup_flags (prefer_type, namespaces_only);
4138 /* First, look in non-namespace scopes. */
4140 if (current_class_type == NULL_TREE)
4143 if (block_p || !nonclass)
4144 for (iter = outer_binding (name, NULL, !nonclass);
4146 iter = outer_binding (name, iter, !nonclass))
4150 /* Skip entities we don't want. */
4151 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4154 /* If this is the kind of thing we're looking for, we're done. */
4155 if (qualify_lookup (iter->value, flags))
4156 binding = iter->value;
4157 else if ((flags & LOOKUP_PREFER_TYPES)
4158 && qualify_lookup (iter->type, flags))
4159 binding = iter->type;
4161 binding = NULL_TREE;
4165 if (hidden_name_p (binding))
4167 /* A non namespace-scope binding can only be hidden in the
4168 presence of a local class, due to friend declarations.
4170 In particular, consider:
4178 B* b; // error: B is hidden
4179 C* c; // OK, finds ::C
4182 B *b; // error: B is hidden
4183 C *c; // OK, finds ::C
4188 The standard says that "B" is a local class in "f"
4189 (but not nested within "A") -- but that name lookup
4190 for "B" does not find this declaration until it is
4191 declared directly with "f".
4197 If a friend declaration appears in a local class and
4198 the name specified is an unqualified name, a prior
4199 declaration is looked up without considering scopes
4200 that are outside the innermost enclosing non-class
4201 scope. For a friend function declaration, if there is
4202 no prior declaration, the program is ill-formed. For a
4203 friend class declaration, if there is no prior
4204 declaration, the class that is specified belongs to the
4205 innermost enclosing non-class scope, but if it is
4206 subsequently referenced, its name is not found by name
4207 lookup until a matching declaration is provided in the
4208 innermost enclosing nonclass scope.
4210 So just keep looking for a non-hidden binding.
4212 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4220 /* Now lookup in namespace scopes. */
4222 val = unqualified_namespace_lookup (name, flags);
4224 /* If we have a single function from a using decl, pull it out. */
4225 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4226 val = OVL_FUNCTION (val);
4228 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4232 lookup_name_nonclass (tree name)
4234 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4238 lookup_function_nonclass (tree name, tree args, bool block_p)
4241 lookup_arg_dependent (name,
4242 lookup_name_real (name, 0, 1, block_p, 0,
4248 lookup_name (tree name)
4250 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4254 lookup_name_prefer_type (tree name, int prefer_type)
4256 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4257 0, LOOKUP_COMPLAIN);
4260 /* Look up NAME for type used in elaborated name specifier in
4261 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4262 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4263 name, more scopes are checked if cleanup or template parameter
4264 scope is encountered.
4266 Unlike lookup_name_real, we make sure that NAME is actually
4267 declared in the desired scope, not from inheritance, nor using
4268 directive. For using declaration, there is DR138 still waiting
4269 to be resolved. Hidden name coming from an earlier friend
4270 declaration is also returned.
4272 A TYPE_DECL best matching the NAME is returned. Catching error
4273 and issuing diagnostics are caller's responsibility. */
4276 lookup_type_scope (tree name, tag_scope scope)
4278 cxx_binding *iter = NULL;
4279 tree val = NULL_TREE;
4281 timevar_push (TV_NAME_LOOKUP);
4283 /* Look in non-namespace scope first. */
4284 if (current_binding_level->kind != sk_namespace)
4285 iter = outer_binding (name, NULL, /*class_p=*/ true);
4286 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4288 /* Check if this is the kind of thing we're looking for.
4289 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4290 base class. For ITER->VALUE, we can simply use
4291 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4294 We check ITER->TYPE before ITER->VALUE in order to handle
4295 typedef struct C {} C;
4298 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4299 && (scope != ts_current
4300 || LOCAL_BINDING_P (iter)
4301 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4303 else if ((scope != ts_current
4304 || !INHERITED_VALUE_BINDING_P (iter))
4305 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4312 /* Look in namespace scope. */
4315 iter = cxx_scope_find_binding_for_name
4316 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4320 /* If this is the kind of thing we're looking for, we're done. */
4321 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4323 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4329 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4330 and template parameter scopes. */
4333 struct cp_binding_level *b = current_binding_level;
4336 if (iter->scope == b)
4337 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4339 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4340 || b->kind == sk_function_parms)
4342 else if (b->kind == sk_class
4343 && scope == ts_within_enclosing_non_class)
4350 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4353 /* Similar to `lookup_name' but look only in the innermost non-class
4357 lookup_name_innermost_nonclass_level (tree name)
4359 struct cp_binding_level *b;
4362 timevar_push (TV_NAME_LOOKUP);
4363 b = innermost_nonclass_level ();
4365 if (b->kind == sk_namespace)
4367 t = IDENTIFIER_NAMESPACE_VALUE (name);
4369 /* extern "C" function() */
4370 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4373 else if (IDENTIFIER_BINDING (name)
4374 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4376 cxx_binding *binding;
4377 binding = IDENTIFIER_BINDING (name);
4380 if (binding->scope == b
4381 && !(TREE_CODE (binding->value) == VAR_DECL
4382 && DECL_DEAD_FOR_LOCAL (binding->value)))
4383 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4385 if (b->kind == sk_cleanup)
4392 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4395 /* Like lookup_name_innermost_nonclass_level, but for types. */
4398 lookup_type_current_level (tree name)
4402 timevar_push (TV_NAME_LOOKUP);
4403 gcc_assert (current_binding_level->kind != sk_namespace);
4405 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4406 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4408 struct cp_binding_level *b = current_binding_level;
4411 if (purpose_member (name, b->type_shadowed))
4412 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4413 REAL_IDENTIFIER_TYPE_VALUE (name));
4414 if (b->kind == sk_cleanup)
4421 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4424 /* [basic.lookup.koenig] */
4425 /* A nonzero return value in the functions below indicates an error. */
4436 static bool arg_assoc (struct arg_lookup*, tree);
4437 static bool arg_assoc_args (struct arg_lookup*, tree);
4438 static bool arg_assoc_type (struct arg_lookup*, tree);
4439 static bool add_function (struct arg_lookup *, tree);
4440 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4441 static bool arg_assoc_class (struct arg_lookup *, tree);
4442 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4444 /* Add a function to the lookup structure.
4445 Returns true on error. */
4448 add_function (struct arg_lookup *k, tree fn)
4450 /* We used to check here to see if the function was already in the list,
4451 but that's O(n^2), which is just too expensive for function lookup.
4452 Now we deal with the occasional duplicate in joust. In doing this, we
4453 assume that the number of duplicates will be small compared to the
4454 total number of functions being compared, which should usually be the
4457 /* We must find only functions, or exactly one non-function. */
4460 else if (fn == k->functions)
4462 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4463 k->functions = build_overload (fn, k->functions);
4466 tree f1 = OVL_CURRENT (k->functions);
4468 if (is_overloaded_fn (f1))
4470 fn = f1; f1 = f2; f2 = fn;
4472 error ("%q+D is not a function,", f1);
4473 error (" conflict with %q+D", f2);
4474 error (" in call to %qD", k->name);
4481 /* Returns true iff CURRENT has declared itself to be an associated
4482 namespace of SCOPE via a strong using-directive (or transitive chain
4483 thereof). Both are namespaces. */
4486 is_associated_namespace (tree current, tree scope)
4488 tree seen = NULL_TREE;
4489 tree todo = NULL_TREE;
4493 if (scope == current)
4495 seen = tree_cons (scope, NULL_TREE, seen);
4496 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4497 if (!purpose_member (TREE_PURPOSE (t), seen))
4498 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4501 scope = TREE_PURPOSE (todo);
4502 todo = TREE_CHAIN (todo);
4509 /* Return whether FN is a friend of an associated class of ARG. */
4512 friend_of_associated_class_p (tree arg, tree fn)
4518 else if (type_unknown_p (arg))
4521 type = TREE_TYPE (arg);
4523 /* If TYPE is a class, the class itself and all base classes are
4524 associated classes. */
4525 if (CLASS_TYPE_P (type))
4527 if (is_friend (type, fn))
4530 if (TYPE_BINFO (type))
4532 tree binfo, base_binfo;
4535 for (binfo = TYPE_BINFO (type), i = 0;
4536 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4538 if (is_friend (BINFO_TYPE (base_binfo), fn))
4543 /* If TYPE is a class member, the class of which it is a member is
4544 an associated class. */
4545 if ((CLASS_TYPE_P (type)
4546 || TREE_CODE (type) == UNION_TYPE
4547 || TREE_CODE (type) == ENUMERAL_TYPE)
4548 && TYPE_CONTEXT (type)
4549 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4550 && is_friend (TYPE_CONTEXT (type), fn))
4556 /* Add functions of a namespace to the lookup structure.
4557 Returns true on error. */
4560 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4564 if (purpose_member (scope, k->namespaces))
4566 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4568 /* Check out our super-users. */
4569 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4570 value = TREE_CHAIN (value))
4571 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4574 /* Also look down into inline namespaces. */
4575 for (value = DECL_NAMESPACE_USING (scope); value;
4576 value = TREE_CHAIN (value))
4577 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4578 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4581 value = namespace_binding (k->name, scope);
4585 for (; value; value = OVL_NEXT (value))
4587 /* We don't want to find arbitrary hidden functions via argument
4588 dependent lookup. We only want to find friends of associated
4590 if (hidden_name_p (OVL_CURRENT (value)))
4594 for (args = k->args; args; args = TREE_CHAIN (args))
4595 if (friend_of_associated_class_p (TREE_VALUE (args),
4596 OVL_CURRENT (value)))
4602 if (add_function (k, OVL_CURRENT (value)))
4609 /* Adds everything associated with a template argument to the lookup
4610 structure. Returns true on error. */
4613 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4615 /* [basic.lookup.koenig]
4617 If T is a template-id, its associated namespaces and classes are
4618 ... the namespaces and classes associated with the types of the
4619 template arguments provided for template type parameters
4620 (excluding template template parameters); the namespaces in which
4621 any template template arguments are defined; and the classes in
4622 which any member templates used as template template arguments
4623 are defined. [Note: non-type template arguments do not
4624 contribute to the set of associated namespaces. ] */
4626 /* Consider first template template arguments. */
4627 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4628 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4630 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4632 tree ctx = CP_DECL_CONTEXT (arg);
4634 /* It's not a member template. */
4635 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4636 return arg_assoc_namespace (k, ctx);
4637 /* Otherwise, it must be member template. */
4639 return arg_assoc_class (k, ctx);
4641 /* It's an argument pack; handle it recursively. */
4642 else if (ARGUMENT_PACK_P (arg))
4644 tree args = ARGUMENT_PACK_ARGS (arg);
4645 int i, len = TREE_VEC_LENGTH (args);
4646 for (i = 0; i < len; ++i)
4647 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4652 /* It's not a template template argument, but it is a type template
4654 else if (TYPE_P (arg))
4655 return arg_assoc_type (k, arg);
4656 /* It's a non-type template argument. */
4661 /* Adds everything associated with class to the lookup structure.
4662 Returns true on error. */
4665 arg_assoc_class (struct arg_lookup *k, tree type)
4667 tree list, friends, context;
4670 /* Backend build structures, such as __builtin_va_list, aren't
4671 affected by all this. */
4672 if (!CLASS_TYPE_P (type))
4675 if (purpose_member (type, k->classes))
4677 k->classes = tree_cons (type, NULL_TREE, k->classes);
4679 context = decl_namespace_context (type);
4680 if (arg_assoc_namespace (k, context))
4683 if (TYPE_BINFO (type))
4685 /* Process baseclasses. */
4686 tree binfo, base_binfo;
4688 for (binfo = TYPE_BINFO (type), i = 0;
4689 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4690 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4694 /* Process friends. */
4695 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4696 list = TREE_CHAIN (list))
4697 if (k->name == FRIEND_NAME (list))
4698 for (friends = FRIEND_DECLS (list); friends;
4699 friends = TREE_CHAIN (friends))
4701 tree fn = TREE_VALUE (friends);
4703 /* Only interested in global functions with potentially hidden
4704 (i.e. unqualified) declarations. */
4705 if (CP_DECL_CONTEXT (fn) != context)
4707 /* Template specializations are never found by name lookup.
4708 (Templates themselves can be found, but not template
4709 specializations.) */
4710 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4712 if (add_function (k, fn))
4716 /* Process template arguments. */
4717 if (CLASSTYPE_TEMPLATE_INFO (type)
4718 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4720 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4721 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4722 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4728 /* Adds everything associated with a given type.
4729 Returns 1 on error. */
4732 arg_assoc_type (struct arg_lookup *k, tree type)
4734 /* As we do not get the type of non-type dependent expressions
4735 right, we can end up with such things without a type. */
4739 if (TYPE_PTRMEM_P (type))
4741 /* Pointer to member: associate class type and value type. */
4742 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4744 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4746 else switch (TREE_CODE (type))
4756 case FIXED_POINT_TYPE:
4760 if (TYPE_PTRMEMFUNC_P (type))
4761 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4762 return arg_assoc_class (k, type);
4764 case REFERENCE_TYPE:
4766 return arg_assoc_type (k, TREE_TYPE (type));
4769 return arg_assoc_namespace (k, decl_namespace_context (type));
4771 /* The basetype is referenced in the first arg type, so just
4774 /* Associate the parameter types. */
4775 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4777 /* Associate the return type. */
4778 return arg_assoc_type (k, TREE_TYPE (type));
4779 case TEMPLATE_TYPE_PARM:
4780 case BOUND_TEMPLATE_TEMPLATE_PARM:
4785 gcc_assert (type == unknown_type_node
4786 || type == init_list_type_node);
4788 case TYPE_PACK_EXPANSION:
4789 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4797 /* Adds everything associated with arguments. Returns true on error. */
4800 arg_assoc_args (struct arg_lookup *k, tree args)
4802 for (; args; args = TREE_CHAIN (args))
4803 if (arg_assoc (k, TREE_VALUE (args)))
4808 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4811 arg_assoc (struct arg_lookup *k, tree n)
4813 if (n == error_mark_node)
4817 return arg_assoc_type (k, n);
4819 if (! type_unknown_p (n))
4820 return arg_assoc_type (k, TREE_TYPE (n));
4822 if (TREE_CODE (n) == ADDR_EXPR)
4823 n = TREE_OPERAND (n, 0);
4824 if (TREE_CODE (n) == COMPONENT_REF)
4825 n = TREE_OPERAND (n, 1);
4826 if (TREE_CODE (n) == OFFSET_REF)
4827 n = TREE_OPERAND (n, 1);
4828 while (TREE_CODE (n) == TREE_LIST)
4830 if (TREE_CODE (n) == BASELINK)
4831 n = BASELINK_FUNCTIONS (n);
4833 if (TREE_CODE (n) == FUNCTION_DECL)
4834 return arg_assoc_type (k, TREE_TYPE (n));
4835 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4837 /* [basic.lookup.koenig]
4839 If T is a template-id, its associated namespaces and classes
4840 are the namespace in which the template is defined; for
4841 member templates, the member template's class... */
4842 tree templ = TREE_OPERAND (n, 0);
4843 tree args = TREE_OPERAND (n, 1);
4847 if (TREE_CODE (templ) == COMPONENT_REF)
4848 templ = TREE_OPERAND (templ, 1);
4850 /* First, the template. There may actually be more than one if
4851 this is an overloaded function template. But, in that case,
4852 we only need the first; all the functions will be in the same
4854 templ = OVL_CURRENT (templ);
4856 ctx = CP_DECL_CONTEXT (templ);
4858 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4860 if (arg_assoc_namespace (k, ctx) == 1)
4863 /* It must be a member template. */
4864 else if (arg_assoc_class (k, ctx) == 1)
4867 /* Now the arguments. */
4869 for (ix = TREE_VEC_LENGTH (args); ix--;)
4870 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4873 else if (TREE_CODE (n) == OVERLOAD)
4875 for (; n; n = OVL_CHAIN (n))
4876 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4883 /* Performs Koenig lookup depending on arguments, where fns
4884 are the functions found in normal lookup. */
4887 lookup_arg_dependent (tree name, tree fns, tree args)
4889 struct arg_lookup k;
4891 timevar_push (TV_NAME_LOOKUP);
4893 /* Remove any hidden friend functions from the list of functions
4894 found so far. They will be added back by arg_assoc_class as
4896 fns = remove_hidden_names (fns);
4901 k.classes = NULL_TREE;
4903 /* We previously performed an optimization here by setting
4904 NAMESPACES to the current namespace when it was safe. However, DR
4905 164 says that namespaces that were already searched in the first
4906 stage of template processing are searched again (potentially
4907 picking up later definitions) in the second stage. */
4908 k.namespaces = NULL_TREE;
4910 arg_assoc_args (&k, args);
4915 && TREE_CODE (fns) != VAR_DECL
4916 && !is_overloaded_fn (fns))
4918 error ("argument dependent lookup finds %q+D", fns);
4919 error (" in call to %qD", name);
4920 fns = error_mark_node;
4923 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4926 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4927 changed (i.e. there was already a directive), or the fresh
4928 TREE_LIST otherwise. */
4931 push_using_directive (tree used)
4933 tree ud = current_binding_level->using_directives;
4934 tree iter, ancestor;
4936 timevar_push (TV_NAME_LOOKUP);
4937 /* Check if we already have this. */
4938 if (purpose_member (used, ud) != NULL_TREE)
4939 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4941 ancestor = namespace_ancestor (current_decl_namespace (), used);
4942 ud = current_binding_level->using_directives;
4943 ud = tree_cons (used, ancestor, ud);
4944 current_binding_level->using_directives = ud;
4946 /* Recursively add all namespaces used. */
4947 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4948 push_using_directive (TREE_PURPOSE (iter));
4950 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4953 /* The type TYPE is being declared. If it is a class template, or a
4954 specialization of a class template, do any processing required and
4955 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4956 being declared a friend. B is the binding level at which this TYPE
4959 Returns the TYPE_DECL for TYPE, which may have been altered by this
4963 maybe_process_template_type_declaration (tree type, int is_friend,
4966 tree decl = TYPE_NAME (type);
4968 if (processing_template_parmlist)
4969 /* You can't declare a new template type in a template parameter
4970 list. But, you can declare a non-template type:
4972 template <class A*> struct S;
4974 is a forward-declaration of `A'. */
4976 else if (b->kind == sk_namespace
4977 && current_binding_level->kind != sk_namespace)
4978 /* If this new type is being injected into a containing scope,
4979 then it's not a template type. */
4983 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4984 || TREE_CODE (type) == ENUMERAL_TYPE);
4986 if (processing_template_decl)
4988 /* This may change after the call to
4989 push_template_decl_real, but we want the original value. */
4990 tree name = DECL_NAME (decl);
4992 decl = push_template_decl_real (decl, is_friend);
4993 if (decl == error_mark_node)
4994 return error_mark_node;
4996 /* If the current binding level is the binding level for the
4997 template parameters (see the comment in
4998 begin_template_parm_list) and the enclosing level is a class
4999 scope, and we're not looking at a friend, push the
5000 declaration of the member class into the class scope. In the
5001 friend case, push_template_decl will already have put the
5002 friend into global scope, if appropriate. */
5003 if (TREE_CODE (type) != ENUMERAL_TYPE
5004 && !is_friend && b->kind == sk_template_parms
5005 && b->level_chain->kind == sk_class)
5007 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5009 if (!COMPLETE_TYPE_P (current_class_type))
5011 maybe_add_class_template_decl_list (current_class_type,
5012 type, /*friend_p=*/0);
5013 /* Put this UTD in the table of UTDs for the class. */
5014 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5015 CLASSTYPE_NESTED_UTDS (current_class_type) =
5016 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5018 binding_table_insert
5019 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5028 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5029 that the NAME is a class template, the tag is processed but not pushed.
5031 The pushed scope depend on the SCOPE parameter:
5032 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5034 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5035 non-template-parameter scope. This case is needed for forward
5037 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5038 TS_GLOBAL case except that names within template-parameter scopes
5039 are not pushed at all.
5041 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5044 pushtag (tree name, tree type, tag_scope scope)
5046 struct cp_binding_level *b;
5049 timevar_push (TV_NAME_LOOKUP);
5050 b = current_binding_level;
5051 while (/* Cleanup scopes are not scopes from the point of view of
5053 b->kind == sk_cleanup
5054 /* Neither are function parameter scopes. */
5055 || b->kind == sk_function_parms
5056 /* Neither are the scopes used to hold template parameters
5057 for an explicit specialization. For an ordinary template
5058 declaration, these scopes are not scopes from the point of
5059 view of the language. */
5060 || (b->kind == sk_template_parms
5061 && (b->explicit_spec_p || scope == ts_global))
5062 || (b->kind == sk_class
5063 && (scope != ts_current
5064 /* We may be defining a new type in the initializer
5065 of a static member variable. We allow this when
5066 not pedantic, and it is particularly useful for
5067 type punning via an anonymous union. */
5068 || COMPLETE_TYPE_P (b->this_entity))))
5071 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5073 /* Do C++ gratuitous typedefing. */
5074 if (IDENTIFIER_TYPE_VALUE (name) != type)
5078 tree context = TYPE_CONTEXT (type);
5082 tree cs = current_scope ();
5084 if (scope == ts_current)
5086 else if (cs != NULL_TREE && TYPE_P (cs))
5087 /* When declaring a friend class of a local class, we want
5088 to inject the newly named class into the scope
5089 containing the local class, not the namespace
5091 context = decl_function_context (get_type_decl (cs));
5094 context = current_namespace;
5096 if (b->kind == sk_class
5097 || (b->kind == sk_template_parms
5098 && b->level_chain->kind == sk_class))
5101 if (current_lang_name == lang_name_java)
5102 TYPE_FOR_JAVA (type) = 1;
5104 tdef = create_implicit_typedef (name, type);
5105 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5106 if (scope == ts_within_enclosing_non_class)
5108 /* This is a friend. Make this TYPE_DECL node hidden from
5109 ordinary name lookup. Its corresponding TEMPLATE_DECL
5110 will be marked in push_template_decl_real. */
5111 retrofit_lang_decl (tdef);
5112 DECL_ANTICIPATED (tdef) = 1;
5113 DECL_FRIEND_P (tdef) = 1;
5116 decl = maybe_process_template_type_declaration
5117 (type, scope == ts_within_enclosing_non_class, b);
5118 if (decl == error_mark_node)
5119 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5121 if (b->kind == sk_class)
5123 if (!TYPE_BEING_DEFINED (current_class_type))
5124 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5126 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5127 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5128 class. But if it's a member template class, we want
5129 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5131 finish_member_declaration (decl);
5133 pushdecl_class_level (decl);
5135 else if (b->kind != sk_template_parms)
5137 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5138 if (decl == error_mark_node)
5139 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5143 set_identifier_type_value_with_scope (name, tdef, b);
5145 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5147 /* If this is a local class, keep track of it. We need this
5148 information for name-mangling, and so that it is possible to
5149 find all function definitions in a translation unit in a
5150 convenient way. (It's otherwise tricky to find a member
5151 function definition it's only pointed to from within a local
5153 if (TYPE_CONTEXT (type)
5154 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5155 VEC_safe_push (tree, gc, local_classes, type);
5157 if (b->kind == sk_class
5158 && !COMPLETE_TYPE_P (current_class_type))
5160 maybe_add_class_template_decl_list (current_class_type,
5161 type, /*friend_p=*/0);
5163 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5164 CLASSTYPE_NESTED_UTDS (current_class_type)
5165 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5167 binding_table_insert
5168 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5171 decl = TYPE_NAME (type);
5172 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5173 TYPE_STUB_DECL (type) = decl;
5175 /* Set type visibility now if this is a forward declaration. */
5176 TREE_PUBLIC (decl) = 1;
5177 determine_visibility (decl);
5179 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5182 /* Subroutines for reverting temporarily to top-level for instantiation
5183 of templates and such. We actually need to clear out the class- and
5184 local-value slots of all identifiers, so that only the global values
5185 are at all visible. Simply setting current_binding_level to the global
5186 scope isn't enough, because more binding levels may be pushed. */
5187 struct saved_scope *scope_chain;
5189 /* If ID has not already been marked, add an appropriate binding to
5193 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5195 cxx_saved_binding *saved;
5197 if (!id || !IDENTIFIER_BINDING (id))
5200 if (IDENTIFIER_MARKED (id))
5203 IDENTIFIER_MARKED (id) = 1;
5205 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5206 saved->identifier = id;
5207 saved->binding = IDENTIFIER_BINDING (id);
5208 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5209 IDENTIFIER_BINDING (id) = NULL;
5213 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5217 timevar_push (TV_NAME_LOOKUP);
5218 for (t = names; t; t = TREE_CHAIN (t))
5222 if (TREE_CODE (t) == TREE_LIST)
5223 id = TREE_PURPOSE (t);
5227 store_binding (id, old_bindings);
5229 timevar_pop (TV_NAME_LOOKUP);
5232 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5233 objects, rather than a TREE_LIST. */
5236 store_class_bindings (VEC(cp_class_binding,gc) *names,
5237 VEC(cxx_saved_binding,gc) **old_bindings)
5240 cp_class_binding *cb;
5242 timevar_push (TV_NAME_LOOKUP);
5243 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5244 store_binding (cb->identifier, old_bindings);
5245 timevar_pop (TV_NAME_LOOKUP);
5249 push_to_top_level (void)
5251 struct saved_scope *s;
5252 struct cp_binding_level *b;
5253 cxx_saved_binding *sb;
5257 timevar_push (TV_NAME_LOOKUP);
5258 s = GGC_CNEW (struct saved_scope);
5260 b = scope_chain ? current_binding_level : 0;
5262 /* If we're in the middle of some function, save our state. */
5266 push_function_context ();
5271 if (scope_chain && previous_class_level)
5272 store_class_bindings (previous_class_level->class_shadowed,
5275 /* Have to include the global scope, because class-scope decls
5276 aren't listed anywhere useful. */
5277 for (; b; b = b->level_chain)
5281 /* Template IDs are inserted into the global level. If they were
5282 inserted into namespace level, finish_file wouldn't find them
5283 when doing pending instantiations. Therefore, don't stop at
5284 namespace level, but continue until :: . */
5285 if (global_scope_p (b))
5288 store_bindings (b->names, &s->old_bindings);
5289 /* We also need to check class_shadowed to save class-level type
5290 bindings, since pushclass doesn't fill in b->names. */
5291 if (b->kind == sk_class)
5292 store_class_bindings (b->class_shadowed, &s->old_bindings);
5294 /* Unwind type-value slots back to top level. */
5295 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5296 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5299 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5300 IDENTIFIER_MARKED (sb->identifier) = 0;
5302 s->prev = scope_chain;
5304 s->need_pop_function_context = need_pop;
5305 s->function_decl = current_function_decl;
5306 s->skip_evaluation = skip_evaluation;
5309 current_function_decl = NULL_TREE;
5310 current_lang_base = VEC_alloc (tree, gc, 10);
5311 current_lang_name = lang_name_cplusplus;
5312 current_namespace = global_namespace;
5313 push_class_stack ();
5314 skip_evaluation = 0;
5315 timevar_pop (TV_NAME_LOOKUP);
5319 pop_from_top_level (void)
5321 struct saved_scope *s = scope_chain;
5322 cxx_saved_binding *saved;
5325 timevar_push (TV_NAME_LOOKUP);
5326 /* Clear out class-level bindings cache. */
5327 if (previous_class_level)
5328 invalidate_class_lookup_cache ();
5331 current_lang_base = 0;
5333 scope_chain = s->prev;
5334 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5336 tree id = saved->identifier;
5338 IDENTIFIER_BINDING (id) = saved->binding;
5339 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5342 /* If we were in the middle of compiling a function, restore our
5344 if (s->need_pop_function_context)
5345 pop_function_context ();
5346 current_function_decl = s->function_decl;
5347 skip_evaluation = s->skip_evaluation;
5348 timevar_pop (TV_NAME_LOOKUP);
5351 /* Pop off extraneous binding levels left over due to syntax errors.
5353 We don't pop past namespaces, as they might be valid. */
5356 pop_everything (void)
5358 if (ENABLE_SCOPE_CHECKING)
5359 verbatim ("XXX entering pop_everything ()\n");
5360 while (!toplevel_bindings_p ())
5362 if (current_binding_level->kind == sk_class)
5363 pop_nested_class ();
5367 if (ENABLE_SCOPE_CHECKING)
5368 verbatim ("XXX leaving pop_everything ()\n");
5371 /* Emit debugging information for using declarations and directives.
5372 If input tree is overloaded fn then emit debug info for all
5376 cp_emit_debug_info_for_using (tree t, tree context)
5378 /* Don't try to emit any debug information if we have errors. */
5379 if (sorrycount || errorcount)
5382 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5383 of a builtin function. */
5384 if (TREE_CODE (t) == FUNCTION_DECL
5385 && DECL_EXTERNAL (t)
5386 && DECL_BUILT_IN (t))
5389 /* Do not supply context to imported_module_or_decl, if
5390 it is a global namespace. */
5391 if (context == global_namespace)
5392 context = NULL_TREE;
5395 t = BASELINK_FUNCTIONS (t);
5397 /* FIXME: Handle TEMPLATE_DECLs. */
5398 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5399 if (TREE_CODE (t) != TEMPLATE_DECL)
5401 if (building_stmt_tree ())
5402 add_stmt (build_stmt (USING_STMT, t));
5404 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5408 #include "gt-cp-name-lookup.h"