1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
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_IN_SYSTEM_HEADER (x))
783 cxx_binding *function_binding =
784 lookup_extern_c_fun_binding_in_all_ns (x);
786 && !DECL_IN_SYSTEM_HEADER (function_binding->value))
788 tree previous = function_binding->value;
790 /* In case either x or previous is declared to throw an exception,
791 make sure both exception specifications are equal. */
792 if (decls_match (x, previous))
794 tree x_exception_spec = NULL_TREE;
795 tree previous_exception_spec = NULL_TREE;
798 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
799 previous_exception_spec =
800 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
801 if (!comp_except_specs (previous_exception_spec,
805 pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
807 pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
809 pedwarn (input_location, 0, "due to different exception specifications");
810 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
816 check_template_shadow (x);
818 /* If this is a function conjured up by the back end, massage it
819 so it looks friendly. */
820 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
822 retrofit_lang_decl (x);
823 SET_DECL_LANGUAGE (x, lang_c);
827 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
829 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
830 if (!namespace_bindings_p ())
831 /* We do not need to create a binding for this name;
832 push_overloaded_decl will have already done so if
834 need_new_binding = 0;
836 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
838 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
840 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
843 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
844 check_default_args (t);
846 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
849 /* If declaring a type as a typedef, copy the type (unless we're
850 at line 0), and install this TYPE_DECL as the new type's typedef
851 name. See the extensive comment in ../c-decl.c (pushdecl). */
852 if (TREE_CODE (x) == TYPE_DECL)
854 tree type = TREE_TYPE (x);
855 if (DECL_IS_BUILTIN (x))
857 if (TYPE_NAME (type) == 0)
858 TYPE_NAME (type) = x;
860 else if (type != error_mark_node && TYPE_NAME (type) != x
861 /* We don't want to copy the type when all we're
862 doing is making a TYPE_DECL for the purposes of
864 && (!TYPE_NAME (type)
865 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
867 DECL_ORIGINAL_TYPE (x) = type;
868 type = build_variant_type_copy (type);
869 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
870 TYPE_NAME (type) = x;
871 TREE_TYPE (x) = type;
874 if (type != error_mark_node
876 && TYPE_IDENTIFIER (type))
877 set_identifier_type_value (DECL_NAME (x), x);
880 /* Multiple external decls of the same identifier ought to match.
882 We get warnings about inline functions where they are defined.
883 We get warnings about other functions from push_overloaded_decl.
885 Avoid duplicate warnings where they are used. */
886 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
890 decl = IDENTIFIER_NAMESPACE_VALUE (name);
891 if (decl && TREE_CODE (decl) == OVERLOAD)
892 decl = OVL_FUNCTION (decl);
894 if (decl && decl != error_mark_node
895 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
896 /* If different sort of thing, we already gave an error. */
897 && TREE_CODE (decl) == TREE_CODE (x)
898 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
900 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
901 permerror (input_location, "previous external decl of %q+#D", decl);
905 if (TREE_CODE (x) == FUNCTION_DECL
907 && !flag_friend_injection)
909 /* This is a new declaration of a friend function, so hide
910 it from ordinary function lookup. */
911 DECL_ANTICIPATED (x) = 1;
912 DECL_HIDDEN_FRIEND_P (x) = 1;
915 /* This name is new in its binding level.
916 Install the new declaration and return it. */
917 if (namespace_bindings_p ())
919 /* Install a global value. */
921 /* If the first global decl has external linkage,
922 warn if we later see static one. */
923 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
924 TREE_PUBLIC (name) = 1;
926 /* Bind the name for the entity. */
927 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
929 && (TREE_CODE (x) == TYPE_DECL
930 || TREE_CODE (x) == VAR_DECL
931 || TREE_CODE (x) == NAMESPACE_DECL
932 || TREE_CODE (x) == CONST_DECL
933 || TREE_CODE (x) == TEMPLATE_DECL))
934 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
936 /* If new decl is `static' and an `extern' was seen previously,
938 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
939 warn_extern_redeclared_static (x, t);
943 /* Here to install a non-global value. */
944 tree oldlocal = innermost_non_namespace_value (name);
945 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
947 if (need_new_binding)
949 push_local_binding (name, x, 0);
950 /* Because push_local_binding will hook X on to the
951 current_binding_level's name list, we don't want to
952 do that again below. */
953 need_new_binding = 0;
956 /* If this is a TYPE_DECL, push it into the type value slot. */
957 if (TREE_CODE (x) == TYPE_DECL)
958 set_identifier_type_value (name, x);
960 /* Clear out any TYPE_DECL shadowed by a namespace so that
961 we won't think this is a type. The C struct hack doesn't
962 go through namespaces. */
963 if (TREE_CODE (x) == NAMESPACE_DECL)
964 set_identifier_type_value (name, NULL_TREE);
971 && TREE_CODE (oldlocal) == VAR_DECL
972 && DECL_DEAD_FOR_LOCAL (oldlocal))
973 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
975 if (oldlocal == NULL_TREE)
976 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
979 /* If this is an extern function declaration, see if we
980 have a global definition or declaration for the function. */
981 if (oldlocal == NULL_TREE
983 && oldglobal != NULL_TREE
984 && TREE_CODE (x) == FUNCTION_DECL
985 && TREE_CODE (oldglobal) == FUNCTION_DECL)
987 /* We have one. Their types must agree. */
988 if (decls_match (x, oldglobal))
992 warning (0, "extern declaration of %q#D doesn't match", x);
993 warning (0, "global declaration %q+#D", oldglobal);
996 /* If we have a local external declaration,
997 and no file-scope declaration has yet been seen,
998 then if we later have a file-scope decl it must not be static. */
999 if (oldlocal == NULL_TREE
1000 && oldglobal == NULL_TREE
1001 && DECL_EXTERNAL (x)
1003 TREE_PUBLIC (name) = 1;
1005 /* Don't complain about the parms we push and then pop
1006 while tentatively parsing a function declarator. */
1007 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1010 /* Warn if shadowing an argument at the top level of the body. */
1011 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1012 /* Inline decls shadow nothing. */
1013 && !DECL_FROM_INLINE (x)
1014 && TREE_CODE (oldlocal) == PARM_DECL
1015 /* Don't check the `this' parameter. */
1016 && !DECL_ARTIFICIAL (oldlocal))
1020 /* Don't complain if it's from an enclosing function. */
1021 if (DECL_CONTEXT (oldlocal) == current_function_decl
1022 && TREE_CODE (x) != PARM_DECL)
1024 /* Go to where the parms should be and see if we find
1026 struct cp_binding_level *b = current_binding_level->level_chain;
1028 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1029 /* Skip the ctor/dtor cleanup level. */
1033 if (b->kind == sk_function_parms)
1035 error ("declaration of %q#D shadows a parameter", x);
1040 if (warn_shadow && !err)
1042 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
1043 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1047 /* Maybe warn if shadowing something else. */
1048 else if (warn_shadow && !DECL_EXTERNAL (x)
1049 /* No shadow warnings for internally generated vars. */
1050 && ! DECL_ARTIFICIAL (x)
1051 /* No shadow warnings for vars made for inlining. */
1052 && ! DECL_FROM_INLINE (x))
1056 if (current_class_ptr)
1057 member = lookup_member (current_class_type,
1060 /*want_type=*/false);
1064 if (member && !TREE_STATIC (member))
1066 /* Location of previous decl is not useful in this case. */
1067 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1070 else if (oldlocal != NULL_TREE
1071 && TREE_CODE (oldlocal) == VAR_DECL)
1073 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1074 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1076 else if (oldglobal != NULL_TREE
1077 && TREE_CODE (oldglobal) == VAR_DECL)
1078 /* XXX shadow warnings in outer-more namespaces */
1080 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1082 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1087 if (TREE_CODE (x) == VAR_DECL)
1088 maybe_register_incomplete_var (x);
1091 if (need_new_binding)
1092 add_decl_to_level (x,
1093 DECL_NAMESPACE_SCOPE_P (x)
1094 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1095 : current_binding_level);
1097 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1100 /* Record a decl-node X as belonging to the current lexical scope. */
1105 return pushdecl_maybe_friend (x, false);
1108 /* Enter DECL into the symbol table, if that's appropriate. Returns
1109 DECL, or a modified version thereof. */
1112 maybe_push_decl (tree decl)
1114 tree type = TREE_TYPE (decl);
1116 /* Add this decl to the current binding level, but not if it comes
1117 from another scope, e.g. a static member variable. TEM may equal
1118 DECL or it may be a previous decl of the same name. */
1119 if (decl == error_mark_node
1120 || (TREE_CODE (decl) != PARM_DECL
1121 && DECL_CONTEXT (decl) != NULL_TREE
1122 /* Definitions of namespace members outside their namespace are
1124 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1125 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1126 || TREE_CODE (type) == UNKNOWN_TYPE
1127 /* The declaration of a template specialization does not affect
1128 the functions available for overload resolution, so we do not
1130 || (TREE_CODE (decl) == FUNCTION_DECL
1131 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1134 return pushdecl (decl);
1137 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1138 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1139 doesn't really belong to this binding level, that it got here
1140 through a using-declaration. */
1143 push_local_binding (tree id, tree decl, int flags)
1145 struct cp_binding_level *b;
1147 /* Skip over any local classes. This makes sense if we call
1148 push_local_binding with a friend decl of a local class. */
1149 b = innermost_nonclass_level ();
1151 if (lookup_name_innermost_nonclass_level (id))
1153 /* Supplement the existing binding. */
1154 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1155 /* It didn't work. Something else must be bound at this
1156 level. Do not add DECL to the list of things to pop
1161 /* Create a new binding. */
1162 push_binding (id, decl, b);
1164 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1165 /* We must put the OVERLOAD into a TREE_LIST since the
1166 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1167 decls that got here through a using-declaration. */
1168 decl = build_tree_list (NULL_TREE, decl);
1170 /* And put DECL on the list of things declared by the current
1172 add_decl_to_level (decl, b);
1175 /* Check to see whether or not DECL is a variable that would have been
1176 in scope under the ARM, but is not in scope under the ANSI/ISO
1177 standard. If so, issue an error message. If name lookup would
1178 work in both cases, but return a different result, this function
1179 returns the result of ANSI/ISO lookup. Otherwise, it returns
1183 check_for_out_of_scope_variable (tree decl)
1187 /* We only care about out of scope variables. */
1188 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1191 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1192 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1193 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1194 && DECL_DEAD_FOR_LOCAL (shadowed))
1195 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1196 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1198 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1201 if (!DECL_ERROR_REPORTED (decl))
1203 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1204 warning (0, " matches this %q+D under ISO standard rules",
1206 warning (0, " matches this %q+D under old rules", decl);
1207 DECL_ERROR_REPORTED (decl) = 1;
1212 /* If we have already complained about this declaration, there's no
1213 need to do it again. */
1214 if (DECL_ERROR_REPORTED (decl))
1217 DECL_ERROR_REPORTED (decl) = 1;
1219 if (TREE_TYPE (decl) == error_mark_node)
1222 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1224 error ("name lookup of %qD changed for ISO %<for%> scoping",
1226 error (" cannot use obsolete binding at %q+D because "
1227 "it has a destructor", decl);
1228 return error_mark_node;
1232 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1234 if (flag_permissive)
1235 permerror (input_location, " using obsolete binding at %q+D", decl);
1241 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1250 /* true means unconditionally make a BLOCK for the next level pushed. */
1252 static bool keep_next_level_flag;
1254 static int binding_depth = 0;
1255 static int is_class_level = 0;
1262 for (i = 0; i < depth * 2; i++)
1266 /* Return a string describing the kind of SCOPE we have. */
1268 cxx_scope_descriptor (cxx_scope *scope)
1270 /* The order of this table must match the "scope_kind"
1272 static const char* scope_kind_names[] = {
1278 "function-parameter-scope",
1281 "template-parameter-scope",
1282 "template-explicit-spec-scope"
1284 const scope_kind kind = scope->explicit_spec_p
1285 ? sk_template_spec : scope->kind;
1287 return scope_kind_names[kind];
1290 /* Output a debugging information about SCOPE when performing
1293 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1295 const char *desc = cxx_scope_descriptor (scope);
1296 if (scope->this_entity)
1297 verbatim ("%s %s(%E) %p %d\n", action, desc,
1298 scope->this_entity, (void *) scope, line);
1300 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1303 /* Return the estimated initial size of the hashtable of a NAMESPACE
1306 static inline size_t
1307 namespace_scope_ht_size (tree ns)
1309 tree name = DECL_NAME (ns);
1311 return name == std_identifier
1312 ? NAMESPACE_STD_HT_SIZE
1313 : (name == global_scope_name
1314 ? GLOBAL_SCOPE_HT_SIZE
1315 : NAMESPACE_ORDINARY_HT_SIZE);
1318 /* A chain of binding_level structures awaiting reuse. */
1320 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1322 /* Insert SCOPE as the innermost binding level. */
1325 push_binding_level (struct cp_binding_level *scope)
1327 /* Add it to the front of currently active scopes stack. */
1328 scope->level_chain = current_binding_level;
1329 current_binding_level = scope;
1330 keep_next_level_flag = false;
1332 if (ENABLE_SCOPE_CHECKING)
1334 scope->binding_depth = binding_depth;
1335 indent (binding_depth);
1336 cxx_scope_debug (scope, input_line, "push");
1342 /* Create a new KIND scope and make it the top of the active scopes stack.
1343 ENTITY is the scope of the associated C++ entity (namespace, class,
1344 function, C++0x enumeration); it is NULL otherwise. */
1347 begin_scope (scope_kind kind, tree entity)
1351 /* Reuse or create a struct for this binding level. */
1352 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1354 scope = free_binding_level;
1355 memset (scope, 0, sizeof (cxx_scope));
1356 free_binding_level = scope->level_chain;
1359 scope = GGC_CNEW (cxx_scope);
1361 scope->this_entity = entity;
1362 scope->more_cleanups_ok = true;
1369 case sk_template_spec:
1370 scope->explicit_spec_p = true;
1371 kind = sk_template_parms;
1373 case sk_template_parms:
1379 case sk_scoped_enum:
1380 case sk_function_parms:
1382 scope->keep = keep_next_level_flag;
1386 NAMESPACE_LEVEL (entity) = scope;
1387 scope->static_decls =
1388 VEC_alloc (tree, gc,
1389 DECL_NAME (entity) == std_identifier
1390 || DECL_NAME (entity) == global_scope_name
1395 /* Should not happen. */
1401 push_binding_level (scope);
1406 /* We're about to leave current scope. Pop the top of the stack of
1407 currently active scopes. Return the enclosing scope, now active. */
1412 cxx_scope *scope = current_binding_level;
1414 if (scope->kind == sk_namespace && class_binding_level)
1415 current_binding_level = class_binding_level;
1417 /* We cannot leave a scope, if there are none left. */
1418 if (NAMESPACE_LEVEL (global_namespace))
1419 gcc_assert (!global_scope_p (scope));
1421 if (ENABLE_SCOPE_CHECKING)
1423 indent (--binding_depth);
1424 cxx_scope_debug (scope, input_line, "leave");
1425 if (is_class_level != (scope == class_binding_level))
1427 indent (binding_depth);
1428 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1433 /* Move one nesting level up. */
1434 current_binding_level = scope->level_chain;
1436 /* Namespace-scopes are left most probably temporarily, not
1437 completely; they can be reopened later, e.g. in namespace-extension
1438 or any name binding activity that requires us to resume a
1439 namespace. For classes, we cache some binding levels. For other
1440 scopes, we just make the structure available for reuse. */
1441 if (scope->kind != sk_namespace
1442 && scope->kind != sk_class)
1444 scope->level_chain = free_binding_level;
1445 gcc_assert (!ENABLE_SCOPE_CHECKING
1446 || scope->binding_depth == binding_depth);
1447 free_binding_level = scope;
1450 /* Find the innermost enclosing class scope, and reset
1451 CLASS_BINDING_LEVEL appropriately. */
1452 if (scope->kind == sk_class)
1454 class_binding_level = NULL;
1455 for (scope = current_binding_level; scope; scope = scope->level_chain)
1456 if (scope->kind == sk_class)
1458 class_binding_level = scope;
1463 return current_binding_level;
1467 resume_scope (struct cp_binding_level* b)
1469 /* Resuming binding levels is meant only for namespaces,
1470 and those cannot nest into classes. */
1471 gcc_assert (!class_binding_level);
1472 /* Also, resuming a non-directly nested namespace is a no-no. */
1473 gcc_assert (b->level_chain == current_binding_level);
1474 current_binding_level = b;
1475 if (ENABLE_SCOPE_CHECKING)
1477 b->binding_depth = binding_depth;
1478 indent (binding_depth);
1479 cxx_scope_debug (b, input_line, "resume");
1485 /* Return the innermost binding level that is not for a class scope. */
1488 innermost_nonclass_level (void)
1492 b = current_binding_level;
1493 while (b->kind == sk_class)
1499 /* We're defining an object of type TYPE. If it needs a cleanup, but
1500 we're not allowed to add any more objects with cleanups to the current
1501 scope, create a new binding level. */
1504 maybe_push_cleanup_level (tree type)
1506 if (type != error_mark_node
1507 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1508 && current_binding_level->more_cleanups_ok == 0)
1510 begin_scope (sk_cleanup, NULL);
1511 current_binding_level->statement_list = push_stmt_list ();
1515 /* Nonzero if we are currently in the global binding level. */
1518 global_bindings_p (void)
1520 return global_scope_p (current_binding_level);
1523 /* True if we are currently in a toplevel binding level. This
1524 means either the global binding level or a namespace in a toplevel
1525 binding level. Since there are no non-toplevel namespace levels,
1526 this really means any namespace or template parameter level. We
1527 also include a class whose context is toplevel. */
1530 toplevel_bindings_p (void)
1532 struct cp_binding_level *b = innermost_nonclass_level ();
1534 return b->kind == sk_namespace || b->kind == sk_template_parms;
1537 /* True if this is a namespace scope, or if we are defining a class
1538 which is itself at namespace scope, or whose enclosing class is
1539 such a class, etc. */
1542 namespace_bindings_p (void)
1544 struct cp_binding_level *b = innermost_nonclass_level ();
1546 return b->kind == sk_namespace;
1549 /* True if the current level needs to have a BLOCK made. */
1554 return (current_binding_level->blocks != NULL_TREE
1555 || current_binding_level->keep
1556 || current_binding_level->kind == sk_cleanup
1557 || current_binding_level->names != NULL_TREE
1558 || current_binding_level->using_directives);
1561 /* Returns the kind of the innermost scope. */
1564 innermost_scope_kind (void)
1566 return current_binding_level->kind;
1569 /* Returns true if this scope was created to store template parameters. */
1572 template_parm_scope_p (void)
1574 return innermost_scope_kind () == sk_template_parms;
1577 /* If KEEP is true, make a BLOCK node for the next binding level,
1578 unconditionally. Otherwise, use the normal logic to decide whether
1579 or not to create a BLOCK. */
1582 keep_next_level (bool keep)
1584 keep_next_level_flag = keep;
1587 /* Return the list of declarations of the current level.
1588 Note that this list is in reverse order unless/until
1589 you nreverse it; and when you do nreverse it, you must
1590 store the result back using `storedecls' or you will lose. */
1595 return current_binding_level->names;
1598 /* For debugging. */
1599 static int no_print_functions = 0;
1600 static int no_print_builtins = 0;
1603 print_binding_level (struct cp_binding_level* lvl)
1607 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1608 if (lvl->more_cleanups_ok)
1609 fprintf (stderr, " more-cleanups-ok");
1610 if (lvl->have_cleanups)
1611 fprintf (stderr, " have-cleanups");
1612 fprintf (stderr, "\n");
1615 fprintf (stderr, " names:\t");
1616 /* We can probably fit 3 names to a line? */
1617 for (t = lvl->names; t; t = TREE_CHAIN (t))
1619 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1621 if (no_print_builtins
1622 && (TREE_CODE (t) == TYPE_DECL)
1623 && DECL_IS_BUILTIN (t))
1626 /* Function decls tend to have longer names. */
1627 if (TREE_CODE (t) == FUNCTION_DECL)
1634 fprintf (stderr, "\n\t");
1637 print_node_brief (stderr, "", t, 0);
1638 if (t == error_mark_node)
1642 fprintf (stderr, "\n");
1644 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1647 cp_class_binding *b;
1648 fprintf (stderr, " class-shadowed:");
1650 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1652 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1653 fprintf (stderr, "\n");
1655 if (lvl->type_shadowed)
1657 fprintf (stderr, " type-shadowed:");
1658 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1660 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1662 fprintf (stderr, "\n");
1667 print_other_binding_stack (struct cp_binding_level *stack)
1669 struct cp_binding_level *level;
1670 for (level = stack; !global_scope_p (level); level = level->level_chain)
1672 fprintf (stderr, "binding level %p\n", (void *) level);
1673 print_binding_level (level);
1678 print_binding_stack (void)
1680 struct cp_binding_level *b;
1681 fprintf (stderr, "current_binding_level=%p\n"
1682 "class_binding_level=%p\n"
1683 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1684 (void *) current_binding_level, (void *) class_binding_level,
1685 (void *) NAMESPACE_LEVEL (global_namespace));
1686 if (class_binding_level)
1688 for (b = class_binding_level; b; b = b->level_chain)
1689 if (b == current_binding_level)
1692 b = class_binding_level;
1694 b = current_binding_level;
1697 b = current_binding_level;
1698 print_other_binding_stack (b);
1699 fprintf (stderr, "global:\n");
1700 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1703 /* Return the type associated with id. */
1706 identifier_type_value (tree id)
1708 timevar_push (TV_NAME_LOOKUP);
1709 /* There is no type with that name, anywhere. */
1710 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1712 /* This is not the type marker, but the real thing. */
1713 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1715 /* Have to search for it. It must be on the global level, now.
1716 Ask lookup_name not to return non-types. */
1717 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1723 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1724 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1727 identifier_global_value (tree t)
1729 return IDENTIFIER_GLOBAL_VALUE (t);
1732 /* Push a definition of struct, union or enum tag named ID. into
1733 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1734 the tag ID is not already defined. */
1737 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1741 if (b->kind != sk_namespace)
1743 /* Shadow the marker, not the real thing, so that the marker
1744 gets restored later. */
1745 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1747 = tree_cons (id, old_type_value, b->type_shadowed);
1748 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1749 TREE_TYPE (b->type_shadowed) = type;
1753 cxx_binding *binding =
1754 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1757 supplement_binding (binding, decl);
1759 binding->value = decl;
1761 /* Store marker instead of real type. */
1762 type = global_type_node;
1764 SET_IDENTIFIER_TYPE_VALUE (id, type);
1767 /* As set_identifier_type_value_with_scope, but using
1768 current_binding_level. */
1771 set_identifier_type_value (tree id, tree decl)
1773 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1776 /* Return the name for the constructor (or destructor) for the
1777 specified class TYPE. When given a template, this routine doesn't
1778 lose the specialization. */
1781 constructor_name_full (tree type)
1783 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1786 /* Return the name for the constructor (or destructor) for the
1787 specified class. When given a template, return the plain
1788 unspecialized name. */
1791 constructor_name (tree type)
1794 name = constructor_name_full (type);
1795 if (IDENTIFIER_TEMPLATE (name))
1796 name = IDENTIFIER_TEMPLATE (name);
1800 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1801 which must be a class type. */
1804 constructor_name_p (tree name, tree type)
1808 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1813 if (TREE_CODE (name) != IDENTIFIER_NODE)
1816 ctor_name = constructor_name_full (type);
1817 if (name == ctor_name)
1819 if (IDENTIFIER_TEMPLATE (ctor_name)
1820 && name == IDENTIFIER_TEMPLATE (ctor_name))
1825 /* Counter used to create anonymous type names. */
1827 static GTY(()) int anon_cnt;
1829 /* Return an IDENTIFIER which can be used as a name for
1830 anonymous structs and unions. */
1833 make_anon_name (void)
1837 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1838 return get_identifier (buf);
1841 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1843 static inline cxx_binding *
1844 find_binding (cxx_scope *scope, cxx_binding *binding)
1846 timevar_push (TV_NAME_LOOKUP);
1848 for (; binding != NULL; binding = binding->previous)
1849 if (binding->scope == scope)
1850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1852 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1855 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1857 static inline cxx_binding *
1858 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1860 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1863 /* Fold-in case where NAME is used only once. */
1864 if (scope == b->scope && b->previous == NULL)
1866 return find_binding (scope, b);
1871 /* Always returns a binding for name in scope. If no binding is
1872 found, make a new one. */
1874 static cxx_binding *
1875 binding_for_name (cxx_scope *scope, tree name)
1877 cxx_binding *result;
1879 result = cxx_scope_find_binding_for_name (scope, name);
1882 /* Not found, make a new one. */
1883 result = cxx_binding_make (NULL, NULL);
1884 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1885 result->scope = scope;
1886 result->is_local = false;
1887 result->value_is_inherited = false;
1888 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1892 /* Walk through the bindings associated to the name of FUNCTION,
1893 and return the first binding that declares a function with a
1894 "C" linkage specification, a.k.a 'extern "C"'.
1895 This function looks for the binding, regardless of which scope it
1896 has been defined in. It basically looks in all the known scopes.
1897 Note that this function does not lookup for bindings of builtin functions
1898 or for functions declared in system headers. */
1900 lookup_extern_c_fun_binding_in_all_ns (tree function)
1905 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1907 name = DECL_NAME (function);
1908 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1910 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1912 iter = iter->previous)
1915 && TREE_CODE (iter->value) == FUNCTION_DECL
1916 && DECL_EXTERN_C_P (iter->value)
1917 && !DECL_ARTIFICIAL (iter->value))
1925 /* Insert another USING_DECL into the current binding level, returning
1926 this declaration. If this is a redeclaration, do nothing, and
1927 return NULL_TREE if this not in namespace scope (in namespace
1928 scope, a using decl might extend any previous bindings). */
1931 push_using_decl (tree scope, tree name)
1935 timevar_push (TV_NAME_LOOKUP);
1936 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1937 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1938 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1939 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1942 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1943 namespace_bindings_p () ? decl : NULL_TREE);
1944 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1945 USING_DECL_SCOPE (decl) = scope;
1946 TREE_CHAIN (decl) = current_binding_level->usings;
1947 current_binding_level->usings = decl;
1948 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1951 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1952 caller to set DECL_CONTEXT properly. */
1955 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1957 struct cp_binding_level *b;
1958 tree function_decl = current_function_decl;
1960 timevar_push (TV_NAME_LOOKUP);
1961 current_function_decl = NULL_TREE;
1962 if (level->kind == sk_class)
1964 b = class_binding_level;
1965 class_binding_level = level;
1966 pushdecl_class_level (x);
1967 class_binding_level = b;
1971 b = current_binding_level;
1972 current_binding_level = level;
1973 x = pushdecl_maybe_friend (x, is_friend);
1974 current_binding_level = b;
1976 current_function_decl = function_decl;
1977 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1980 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1981 other definitions already in place. We get around this by making
1982 the value of the identifier point to a list of all the things that
1983 want to be referenced by that name. It is then up to the users of
1984 that name to decide what to do with that list.
1986 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1987 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1989 FLAGS is a bitwise-or of the following values:
1990 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1992 PUSH_USING: DECL is being pushed as the result of a using
1995 IS_FRIEND is true if this is a friend declaration.
1997 The value returned may be a previous declaration if we guessed wrong
1998 about what language DECL should belong to (C or C++). Otherwise,
1999 it's always DECL (and never something that's not a _DECL). */
2002 push_overloaded_decl (tree decl, int flags, bool is_friend)
2004 tree name = DECL_NAME (decl);
2007 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2009 timevar_push (TV_NAME_LOOKUP);
2011 old = namespace_binding (name, DECL_CONTEXT (decl));
2013 old = lookup_name_innermost_nonclass_level (name);
2017 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2019 tree t = TREE_TYPE (old);
2020 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2021 && (! DECL_IN_SYSTEM_HEADER (decl)
2022 || ! DECL_IN_SYSTEM_HEADER (old)))
2023 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2026 else if (is_overloaded_fn (old))
2030 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2032 tree fn = OVL_CURRENT (tmp);
2035 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2036 && !(flags & PUSH_USING)
2037 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2038 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2039 && ! decls_match (fn, decl))
2040 error ("%q#D conflicts with previous using declaration %q#D",
2043 dup = duplicate_decls (decl, fn, is_friend);
2044 /* If DECL was a redeclaration of FN -- even an invalid
2045 one -- pass that information along to our caller. */
2046 if (dup == fn || dup == error_mark_node)
2047 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2050 /* We don't overload implicit built-ins. duplicate_decls()
2051 may fail to merge the decls if the new decl is e.g. a
2052 template function. */
2053 if (TREE_CODE (old) == FUNCTION_DECL
2054 && DECL_ANTICIPATED (old)
2055 && !DECL_HIDDEN_FRIEND_P (old))
2058 else if (old == error_mark_node)
2059 /* Ignore the undefined symbol marker. */
2063 error ("previous non-function declaration %q+#D", old);
2064 error ("conflicts with function declaration %q#D", decl);
2065 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2069 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2070 /* If it's a using declaration, we always need to build an OVERLOAD,
2071 because it's the only way to remember that the declaration comes
2072 from 'using', and have the lookup behave correctly. */
2073 || (flags & PUSH_USING))
2075 if (old && TREE_CODE (old) != OVERLOAD)
2076 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2078 new_binding = ovl_cons (decl, old);
2079 if (flags & PUSH_USING)
2080 OVL_USED (new_binding) = 1;
2083 /* NAME is not ambiguous. */
2087 set_namespace_binding (name, current_namespace, new_binding);
2090 /* We only create an OVERLOAD if there was a previous binding at
2091 this level, or if decl is a template. In the former case, we
2092 need to remove the old binding and replace it with the new
2093 binding. We must also run through the NAMES on the binding
2094 level where the name was bound to update the chain. */
2096 if (TREE_CODE (new_binding) == OVERLOAD && old)
2100 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2102 d = &TREE_CHAIN (*d))
2104 || (TREE_CODE (*d) == TREE_LIST
2105 && TREE_VALUE (*d) == old))
2107 if (TREE_CODE (*d) == TREE_LIST)
2108 /* Just replace the old binding with the new. */
2109 TREE_VALUE (*d) = new_binding;
2111 /* Build a TREE_LIST to wrap the OVERLOAD. */
2112 *d = tree_cons (NULL_TREE, new_binding,
2115 /* And update the cxx_binding node. */
2116 IDENTIFIER_BINDING (name)->value = new_binding;
2117 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2120 /* We should always find a previous binding in this case. */
2124 /* Install the new binding. */
2125 push_local_binding (name, new_binding, flags);
2128 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2131 /* Check a non-member using-declaration. Return the name and scope
2132 being used, and the USING_DECL, or NULL_TREE on failure. */
2135 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2137 /* [namespace.udecl]
2138 A using-declaration for a class member shall be a
2139 member-declaration. */
2142 error ("%qT is not a namespace", scope);
2145 else if (scope == error_mark_node)
2148 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2151 A using-declaration shall not name a template-id. */
2152 error ("a using-declaration cannot specify a template-id. "
2153 "Try %<using %D%>", name);
2157 if (TREE_CODE (decl) == NAMESPACE_DECL)
2159 error ("namespace %qD not allowed in using-declaration", decl);
2163 if (TREE_CODE (decl) == SCOPE_REF)
2165 /* It's a nested name with template parameter dependent scope.
2166 This can only be using-declaration for class member. */
2167 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2171 if (is_overloaded_fn (decl))
2172 decl = get_first_fn (decl);
2174 gcc_assert (DECL_P (decl));
2176 /* Make a USING_DECL. */
2177 return push_using_decl (scope, name);
2180 /* Process local and global using-declarations. */
2183 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2184 tree *newval, tree *newtype)
2186 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2188 *newval = *newtype = NULL_TREE;
2189 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2193 if (!decls.value && !decls.type)
2195 error ("%qD not declared", name);
2199 /* Shift the old and new bindings around so we're comparing class and
2200 enumeration names to each other. */
2201 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2207 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2209 decls.type = decls.value;
2210 decls.value = NULL_TREE;
2213 /* It is impossible to overload a built-in function; any explicit
2214 declaration eliminates the built-in declaration. So, if OLDVAL
2215 is a built-in, then we can just pretend it isn't there. */
2217 && TREE_CODE (oldval) == FUNCTION_DECL
2218 && DECL_ANTICIPATED (oldval)
2219 && !DECL_HIDDEN_FRIEND_P (oldval))
2224 /* Check for using functions. */
2225 if (is_overloaded_fn (decls.value))
2229 if (oldval && !is_overloaded_fn (oldval))
2231 error ("%qD is already declared in this scope", name);
2236 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2238 tree new_fn = OVL_CURRENT (tmp);
2240 /* [namespace.udecl]
2242 If a function declaration in namespace scope or block
2243 scope has the same name and the same parameter types as a
2244 function introduced by a using declaration the program is
2246 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2248 tree old_fn = OVL_CURRENT (tmp1);
2250 if (new_fn == old_fn)
2251 /* The function already exists in the current namespace. */
2253 else if (OVL_USED (tmp1))
2254 continue; /* this is a using decl */
2255 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2256 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2258 gcc_assert (!DECL_ANTICIPATED (old_fn)
2259 || DECL_HIDDEN_FRIEND_P (old_fn));
2261 /* There was already a non-using declaration in
2262 this scope with the same parameter types. If both
2263 are the same extern "C" functions, that's ok. */
2264 if (decls_match (new_fn, old_fn))
2268 error ("%qD is already declared in this scope", name);
2274 /* If we broke out of the loop, there's no reason to add
2275 this function to the using declarations for this
2280 /* If we are adding to an existing OVERLOAD, then we no
2281 longer know the type of the set of functions. */
2282 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2283 TREE_TYPE (*newval) = unknown_type_node;
2284 /* Add this new function to the set. */
2285 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2286 /* If there is only one function, then we use its type. (A
2287 using-declaration naming a single function can be used in
2288 contexts where overload resolution cannot be
2290 if (TREE_CODE (*newval) != OVERLOAD)
2292 *newval = ovl_cons (*newval, NULL_TREE);
2293 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2295 OVL_USED (*newval) = 1;
2300 *newval = decls.value;
2301 if (oldval && !decls_match (*newval, oldval))
2302 error ("%qD is already declared in this scope", name);
2308 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2310 error ("reference to %qD is ambiguous", name);
2311 print_candidates (decls.type);
2315 *newtype = decls.type;
2316 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2317 error ("%qD is already declared in this scope", name);
2320 /* If *newval is empty, shift any class or enumeration name down. */
2324 *newtype = NULL_TREE;
2328 /* Process a using-declaration at function scope. */
2331 do_local_using_decl (tree decl, tree scope, tree name)
2333 tree oldval, oldtype, newval, newtype;
2334 tree orig_decl = decl;
2336 decl = validate_nonmember_using_decl (decl, scope, name);
2337 if (decl == NULL_TREE)
2340 if (building_stmt_tree ()
2341 && at_function_scope_p ())
2342 add_decl_expr (decl);
2344 oldval = lookup_name_innermost_nonclass_level (name);
2345 oldtype = lookup_type_current_level (name);
2347 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2351 if (is_overloaded_fn (newval))
2355 /* We only need to push declarations for those functions
2356 that were not already bound in the current level.
2357 The old value might be NULL_TREE, it might be a single
2358 function, or an OVERLOAD. */
2359 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2360 term = OVL_FUNCTION (oldval);
2363 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2365 push_overloaded_decl (OVL_CURRENT (fn),
2366 PUSH_LOCAL | PUSH_USING,
2370 push_local_binding (name, newval, PUSH_USING);
2374 push_local_binding (name, newtype, PUSH_USING);
2375 set_identifier_type_value (name, newtype);
2378 /* Emit debug info. */
2379 if (!processing_template_decl)
2380 cp_emit_debug_info_for_using (orig_decl, current_scope());
2383 /* Returns true if ROOT (a namespace, class, or function) encloses
2384 CHILD. CHILD may be either a class type or a namespace. */
2387 is_ancestor (tree root, tree child)
2389 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2390 || TREE_CODE (root) == FUNCTION_DECL
2391 || CLASS_TYPE_P (root)));
2392 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2393 || CLASS_TYPE_P (child)));
2395 /* The global namespace encloses everything. */
2396 if (root == global_namespace)
2401 /* If we've run out of scopes, stop. */
2404 /* If we've reached the ROOT, it encloses CHILD. */
2407 /* Go out one level. */
2409 child = TYPE_NAME (child);
2410 child = DECL_CONTEXT (child);
2414 /* Enter the class or namespace scope indicated by T suitable for name
2415 lookup. T can be arbitrary scope, not necessary nested inside the
2416 current scope. Returns a non-null scope to pop iff pop_scope
2417 should be called later to exit this scope. */
2422 if (TREE_CODE (t) == NAMESPACE_DECL)
2423 push_decl_namespace (t);
2424 else if (CLASS_TYPE_P (t))
2426 if (!at_class_scope_p ()
2427 || !same_type_p (current_class_type, t))
2428 push_nested_class (t);
2430 /* T is the same as the current scope. There is therefore no
2431 need to re-enter the scope. Since we are not actually
2432 pushing a new scope, our caller should not call
2440 /* Leave scope pushed by push_scope. */
2445 if (TREE_CODE (t) == NAMESPACE_DECL)
2446 pop_decl_namespace ();
2447 else if CLASS_TYPE_P (t)
2448 pop_nested_class ();
2451 /* Subroutine of push_inner_scope. */
2454 push_inner_scope_r (tree outer, tree inner)
2459 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2462 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2464 push_inner_scope_r (outer, prev);
2465 if (TREE_CODE (inner) == NAMESPACE_DECL)
2467 struct cp_binding_level *save_template_parm = 0;
2468 /* Temporary take out template parameter scopes. They are saved
2469 in reversed order in save_template_parm. */
2470 while (current_binding_level->kind == sk_template_parms)
2472 struct cp_binding_level *b = current_binding_level;
2473 current_binding_level = b->level_chain;
2474 b->level_chain = save_template_parm;
2475 save_template_parm = b;
2478 resume_scope (NAMESPACE_LEVEL (inner));
2479 current_namespace = inner;
2481 /* Restore template parameter scopes. */
2482 while (save_template_parm)
2484 struct cp_binding_level *b = save_template_parm;
2485 save_template_parm = b->level_chain;
2486 b->level_chain = current_binding_level;
2487 current_binding_level = b;
2494 /* Enter the scope INNER from current scope. INNER must be a scope
2495 nested inside current scope. This works with both name lookup and
2496 pushing name into scope. In case a template parameter scope is present,
2497 namespace is pushed under the template parameter scope according to
2498 name lookup rule in 14.6.1/6.
2500 Return the former current scope suitable for pop_inner_scope. */
2503 push_inner_scope (tree inner)
2505 tree outer = current_scope ();
2507 outer = current_namespace;
2509 push_inner_scope_r (outer, inner);
2513 /* Exit the current scope INNER back to scope OUTER. */
2516 pop_inner_scope (tree outer, tree inner)
2519 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2522 while (outer != inner)
2524 if (TREE_CODE (inner) == NAMESPACE_DECL)
2526 struct cp_binding_level *save_template_parm = 0;
2527 /* Temporary take out template parameter scopes. They are saved
2528 in reversed order in save_template_parm. */
2529 while (current_binding_level->kind == sk_template_parms)
2531 struct cp_binding_level *b = current_binding_level;
2532 current_binding_level = b->level_chain;
2533 b->level_chain = save_template_parm;
2534 save_template_parm = b;
2539 /* Restore template parameter scopes. */
2540 while (save_template_parm)
2542 struct cp_binding_level *b = save_template_parm;
2543 save_template_parm = b->level_chain;
2544 b->level_chain = current_binding_level;
2545 current_binding_level = b;
2551 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2555 /* Do a pushlevel for class declarations. */
2558 pushlevel_class (void)
2560 if (ENABLE_SCOPE_CHECKING)
2563 class_binding_level = begin_scope (sk_class, current_class_type);
2566 /* ...and a poplevel for class declarations. */
2569 poplevel_class (void)
2571 struct cp_binding_level *level = class_binding_level;
2572 cp_class_binding *cb;
2576 timevar_push (TV_NAME_LOOKUP);
2577 gcc_assert (level != 0);
2579 /* If we're leaving a toplevel class, cache its binding level. */
2580 if (current_class_depth == 1)
2581 previous_class_level = level;
2582 for (shadowed = level->type_shadowed;
2584 shadowed = TREE_CHAIN (shadowed))
2585 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2587 /* Remove the bindings for all of the class-level declarations. */
2588 if (level->class_shadowed)
2591 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2593 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2594 ggc_free (level->class_shadowed);
2595 level->class_shadowed = NULL;
2598 /* Now, pop out of the binding level which we created up in the
2599 `pushlevel_class' routine. */
2600 if (ENABLE_SCOPE_CHECKING)
2604 timevar_pop (TV_NAME_LOOKUP);
2607 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2608 appropriate. DECL is the value to which a name has just been
2609 bound. CLASS_TYPE is the class in which the lookup occurred. */
2612 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2615 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2619 if (TREE_CODE (decl) == OVERLOAD)
2620 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2623 gcc_assert (DECL_P (decl));
2624 context = context_for_name_lookup (decl);
2627 if (is_properly_derived_from (class_type, context))
2628 INHERITED_VALUE_BINDING_P (binding) = 1;
2630 INHERITED_VALUE_BINDING_P (binding) = 0;
2632 else if (binding->value == decl)
2633 /* We only encounter a TREE_LIST when there is an ambiguity in the
2634 base classes. Such an ambiguity can be overridden by a
2635 definition in this class. */
2636 INHERITED_VALUE_BINDING_P (binding) = 1;
2638 INHERITED_VALUE_BINDING_P (binding) = 0;
2641 /* Make the declaration of X appear in CLASS scope. */
2644 pushdecl_class_level (tree x)
2647 bool is_valid = true;
2649 timevar_push (TV_NAME_LOOKUP);
2650 /* Get the name of X. */
2651 if (TREE_CODE (x) == OVERLOAD)
2652 name = DECL_NAME (get_first_fn (x));
2654 name = DECL_NAME (x);
2658 is_valid = push_class_level_binding (name, x);
2659 if (TREE_CODE (x) == TYPE_DECL)
2660 set_identifier_type_value (name, x);
2662 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2664 /* If X is an anonymous aggregate, all of its members are
2665 treated as if they were members of the class containing the
2666 aggregate, for naming purposes. */
2669 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2671 location_t save_location = input_location;
2672 input_location = DECL_SOURCE_LOCATION (f);
2673 if (!pushdecl_class_level (f))
2675 input_location = save_location;
2678 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2681 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2682 scope. If the value returned is non-NULL, and the PREVIOUS field
2683 is not set, callers must set the PREVIOUS field explicitly. */
2685 static cxx_binding *
2686 get_class_binding (tree name, cxx_scope *scope)
2691 cxx_binding *binding;
2693 class_type = scope->this_entity;
2695 /* Get the type binding. */
2696 type_binding = lookup_member (class_type, name,
2697 /*protect=*/2, /*want_type=*/true);
2698 /* Get the value binding. */
2699 value_binding = lookup_member (class_type, name,
2700 /*protect=*/2, /*want_type=*/false);
2703 && (TREE_CODE (value_binding) == TYPE_DECL
2704 || DECL_CLASS_TEMPLATE_P (value_binding)
2705 || (TREE_CODE (value_binding) == TREE_LIST
2706 && TREE_TYPE (value_binding) == error_mark_node
2707 && (TREE_CODE (TREE_VALUE (value_binding))
2709 /* We found a type binding, even when looking for a non-type
2710 binding. This means that we already processed this binding
2713 else if (value_binding)
2715 if (TREE_CODE (value_binding) == TREE_LIST
2716 && TREE_TYPE (value_binding) == error_mark_node)
2717 /* NAME is ambiguous. */
2719 else if (BASELINK_P (value_binding))
2720 /* NAME is some overloaded functions. */
2721 value_binding = BASELINK_FUNCTIONS (value_binding);
2724 /* If we found either a type binding or a value binding, create a
2725 new binding object. */
2726 if (type_binding || value_binding)
2728 binding = new_class_binding (name,
2732 /* This is a class-scope binding, not a block-scope binding. */
2733 LOCAL_BINDING_P (binding) = 0;
2734 set_inherited_value_binding_p (binding, value_binding, class_type);
2742 /* Make the declaration(s) of X appear in CLASS scope under the name
2743 NAME. Returns true if the binding is valid. */
2746 push_class_level_binding (tree name, tree x)
2748 cxx_binding *binding;
2752 timevar_push (TV_NAME_LOOKUP);
2753 /* The class_binding_level will be NULL if x is a template
2754 parameter name in a member template. */
2755 if (!class_binding_level)
2756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2758 if (name == error_mark_node)
2759 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2761 /* Check for invalid member names. */
2762 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2763 /* We could have been passed a tree list if this is an ambiguous
2764 declaration. If so, pull the declaration out because
2765 check_template_shadow will not handle a TREE_LIST. */
2766 if (TREE_CODE (decl) == TREE_LIST
2767 && TREE_TYPE (decl) == error_mark_node)
2768 decl = TREE_VALUE (decl);
2770 if (!check_template_shadow (decl))
2771 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2775 If T is the name of a class, then each of the following shall
2776 have a name different from T:
2778 -- every static data member of class T;
2780 -- every member of class T that is itself a type;
2782 -- every enumerator of every member of class T that is an
2785 -- every member of every anonymous union that is a member of
2788 (Non-static data members were also forbidden to have the same
2789 name as T until TC1.) */
2790 if ((TREE_CODE (x) == VAR_DECL
2791 || TREE_CODE (x) == CONST_DECL
2792 || (TREE_CODE (x) == TYPE_DECL
2793 && !DECL_SELF_REFERENCE_P (x))
2794 /* A data member of an anonymous union. */
2795 || (TREE_CODE (x) == FIELD_DECL
2796 && DECL_CONTEXT (x) != current_class_type))
2797 && DECL_NAME (x) == constructor_name (current_class_type))
2799 tree scope = context_for_name_lookup (x);
2800 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2802 error ("%qD has the same name as the class in which it is "
2805 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2809 /* Get the current binding for NAME in this class, if any. */
2810 binding = IDENTIFIER_BINDING (name);
2811 if (!binding || binding->scope != class_binding_level)
2813 binding = get_class_binding (name, class_binding_level);
2814 /* If a new binding was created, put it at the front of the
2815 IDENTIFIER_BINDING list. */
2818 binding->previous = IDENTIFIER_BINDING (name);
2819 IDENTIFIER_BINDING (name) = binding;
2823 /* If there is already a binding, then we may need to update the
2825 if (binding && binding->value)
2827 tree bval = binding->value;
2828 tree old_decl = NULL_TREE;
2830 if (INHERITED_VALUE_BINDING_P (binding))
2832 /* If the old binding was from a base class, and was for a
2833 tag name, slide it over to make room for the new binding.
2834 The old binding is still visible if explicitly qualified
2835 with a class-key. */
2836 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2837 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2839 old_decl = binding->type;
2840 binding->type = bval;
2841 binding->value = NULL_TREE;
2842 INHERITED_VALUE_BINDING_P (binding) = 0;
2847 /* Any inherited type declaration is hidden by the type
2848 declaration in the derived class. */
2849 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2850 binding->type = NULL_TREE;
2853 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2855 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2856 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2857 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2859 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2862 if (old_decl && binding->scope == class_binding_level)
2865 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2866 here. This function is only used to register bindings
2867 from with the class definition itself. */
2868 INHERITED_VALUE_BINDING_P (binding) = 0;
2869 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2873 /* Note that we declared this value so that we can issue an error if
2874 this is an invalid redeclaration of a name already used for some
2876 note_name_declared_in_class (name, decl);
2878 /* If we didn't replace an existing binding, put the binding on the
2879 stack of bindings for the identifier, and update the shadowed
2881 if (binding && binding->scope == class_binding_level)
2882 /* Supplement the existing binding. */
2883 ok = supplement_binding (binding, decl);
2886 /* Create a new binding. */
2887 push_binding (name, decl, class_binding_level);
2891 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2894 /* Process "using SCOPE::NAME" in a class scope. Return the
2895 USING_DECL created. */
2898 do_class_using_decl (tree scope, tree name)
2900 /* The USING_DECL returned by this function. */
2902 /* The declaration (or declarations) name by this using
2903 declaration. NULL if we are in a template and cannot figure out
2904 what has been named. */
2906 /* True if SCOPE is a dependent type. */
2907 bool scope_dependent_p;
2908 /* True if SCOPE::NAME is dependent. */
2909 bool name_dependent_p;
2910 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2911 bool bases_dependent_p;
2916 if (name == error_mark_node)
2919 if (!scope || !TYPE_P (scope))
2921 error ("using-declaration for non-member at class scope");
2925 /* Make sure the name is not invalid */
2926 if (TREE_CODE (name) == BIT_NOT_EXPR)
2928 error ("%<%T::%D%> names destructor", scope, name);
2931 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2933 error ("%<%T::%D%> names constructor", scope, name);
2936 if (constructor_name_p (name, current_class_type))
2938 error ("%<%T::%D%> names constructor in %qT",
2939 scope, name, current_class_type);
2943 scope_dependent_p = dependent_type_p (scope);
2944 name_dependent_p = (scope_dependent_p
2945 || (IDENTIFIER_TYPENAME_P (name)
2946 && dependent_type_p (TREE_TYPE (name))));
2948 bases_dependent_p = false;
2949 if (processing_template_decl)
2950 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2951 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2953 if (dependent_type_p (TREE_TYPE (base_binfo)))
2955 bases_dependent_p = true;
2961 /* From [namespace.udecl]:
2963 A using-declaration used as a member-declaration shall refer to a
2964 member of a base class of the class being defined.
2966 In general, we cannot check this constraint in a template because
2967 we do not know the entire set of base classes of the current
2968 class type. However, if all of the base classes are
2969 non-dependent, then we can avoid delaying the check until
2971 if (!scope_dependent_p)
2974 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2975 if (b_kind < bk_proper_base)
2977 if (!bases_dependent_p)
2979 error_not_base_type (scope, current_class_type);
2983 else if (!name_dependent_p)
2985 decl = lookup_member (binfo, name, 0, false);
2988 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2992 /* The binfo from which the functions came does not matter. */
2993 if (BASELINK_P (decl))
2994 decl = BASELINK_FUNCTIONS (decl);
2998 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2999 USING_DECL_DECLS (value) = decl;
3000 USING_DECL_SCOPE (value) = scope;
3001 DECL_DEPENDENT_P (value) = !decl;
3007 /* Return the binding value for name in scope. */
3010 namespace_binding (tree name, tree scope)
3012 cxx_binding *binding;
3015 scope = global_namespace;
3017 /* Unnecessary for the global namespace because it can't be an alias. */
3018 scope = ORIGINAL_NAMESPACE (scope);
3020 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3022 return binding ? binding->value : NULL_TREE;
3025 /* Set the binding value for name in scope. */
3028 set_namespace_binding (tree name, tree scope, tree val)
3032 timevar_push (TV_NAME_LOOKUP);
3033 if (scope == NULL_TREE)
3034 scope = global_namespace;
3035 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3036 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3039 supplement_binding (b, val);
3040 timevar_pop (TV_NAME_LOOKUP);
3043 /* Set the context of a declaration to scope. Complain if we are not
3047 set_decl_namespace (tree decl, tree scope, bool friendp)
3051 /* Get rid of namespace aliases. */
3052 scope = ORIGINAL_NAMESPACE (scope);
3054 /* It is ok for friends to be qualified in parallel space. */
3055 if (!friendp && !is_ancestor (current_namespace, scope))
3056 error ("declaration of %qD not in a namespace surrounding %qD",
3058 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3060 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3061 if (scope == current_namespace)
3063 if (at_namespace_scope_p ())
3064 error ("explicit qualification in declaration of %qD",
3069 /* See whether this has been declared in the namespace. */
3070 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3071 if (old == error_mark_node)
3072 /* No old declaration at all. */
3074 if (!is_overloaded_fn (decl))
3075 /* Don't compare non-function decls with decls_match here, since
3076 it can't check for the correct constness at this
3077 point. pushdecl will find those errors later. */
3079 /* Since decl is a function, old should contain a function decl. */
3080 if (!is_overloaded_fn (old))
3082 fn = OVL_CURRENT (old);
3083 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3085 /* A template can be explicitly specialized in any namespace. */
3086 if (processing_explicit_instantiation)
3088 if (processing_template_decl || processing_specialization)
3089 /* We have not yet called push_template_decl to turn a
3090 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3091 match. But, we'll check later, when we construct the
3094 /* Instantiations or specializations of templates may be declared as
3095 friends in any namespace. */
3096 if (friendp && DECL_USE_TEMPLATE (decl))
3098 if (is_overloaded_fn (old))
3100 for (; old; old = OVL_NEXT (old))
3101 if (decls_match (decl, OVL_CURRENT (old)))
3104 else if (decls_match (decl, old))
3107 error ("%qD should have been declared inside %qD", decl, scope);
3110 /* Return the namespace where the current declaration is declared. */
3113 current_decl_namespace (void)
3116 /* If we have been pushed into a different namespace, use it. */
3117 if (decl_namespace_list)
3118 return TREE_PURPOSE (decl_namespace_list);
3120 if (current_class_type)
3121 result = decl_namespace_context (current_class_type);
3122 else if (current_function_decl)
3123 result = decl_namespace_context (current_function_decl);
3125 result = current_namespace;
3129 /* Process any ATTRIBUTES on a namespace definition. Currently only
3130 attribute visibility is meaningful, which is a property of the syntactic
3131 block rather than the namespace as a whole, so we don't touch the
3132 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3135 handle_namespace_attrs (tree ns, tree attributes)
3138 bool saw_vis = false;
3140 for (d = attributes; d; d = TREE_CHAIN (d))
3142 tree name = TREE_PURPOSE (d);
3143 tree args = TREE_VALUE (d);
3145 #ifdef HANDLE_PRAGMA_VISIBILITY
3146 if (is_attribute_p ("visibility", name))
3148 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3149 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3151 warning (OPT_Wattributes,
3152 "%qD attribute requires a single NTBS argument",
3157 if (!TREE_PUBLIC (ns))
3158 warning (OPT_Wattributes,
3159 "%qD attribute is meaningless since members of the "
3160 "anonymous namespace get local symbols", name);
3162 push_visibility (TREE_STRING_POINTER (x));
3168 warning (OPT_Wattributes, "%qD attribute directive ignored",
3177 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3178 select a name that is unique to this compilation unit. */
3181 push_namespace (tree name)
3185 int implicit_use = 0;
3188 timevar_push (TV_NAME_LOOKUP);
3190 /* We should not get here if the global_namespace is not yet constructed
3191 nor if NAME designates the global namespace: The global scope is
3192 constructed elsewhere. */
3193 gcc_assert (global_namespace != NULL && name != global_scope_name);
3197 name = get_anonymous_namespace_name();
3198 d = IDENTIFIER_NAMESPACE_VALUE (name);
3200 /* Reopening anonymous namespace. */
3206 /* Check whether this is an extended namespace definition. */
3207 d = IDENTIFIER_NAMESPACE_VALUE (name);
3208 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3211 if (DECL_NAMESPACE_ALIAS (d))
3213 error ("namespace alias %qD not allowed here, assuming %qD",
3214 d, DECL_NAMESPACE_ALIAS (d));
3215 d = DECL_NAMESPACE_ALIAS (d);
3222 /* Make a new namespace, binding the name to it. */
3223 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3224 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3225 /* The name of this namespace is not visible to other translation
3226 units if it is an anonymous namespace or member thereof. */
3227 if (anon || decl_anon_ns_mem_p (current_namespace))
3228 TREE_PUBLIC (d) = 0;
3230 TREE_PUBLIC (d) = 1;
3234 /* Clear DECL_NAME for the benefit of debugging back ends. */
3235 SET_DECL_ASSEMBLER_NAME (d, name);
3236 DECL_NAME (d) = NULL_TREE;
3238 begin_scope (sk_namespace, d);
3241 resume_scope (NAMESPACE_LEVEL (d));
3244 do_using_directive (d);
3245 /* Enter the name space. */
3246 current_namespace = d;
3248 timevar_pop (TV_NAME_LOOKUP);
3251 /* Pop from the scope of the current namespace. */
3254 pop_namespace (void)
3256 gcc_assert (current_namespace != global_namespace);
3257 current_namespace = CP_DECL_CONTEXT (current_namespace);
3258 /* The binding level is not popped, as it might be re-opened later. */
3262 /* Push into the scope of the namespace NS, even if it is deeply
3263 nested within another namespace. */
3266 push_nested_namespace (tree ns)
3268 if (ns == global_namespace)
3269 push_to_top_level ();
3272 push_nested_namespace (CP_DECL_CONTEXT (ns));
3273 push_namespace (DECL_NAME (ns));
3277 /* Pop back from the scope of the namespace NS, which was previously
3278 entered with push_nested_namespace. */
3281 pop_nested_namespace (tree ns)
3283 timevar_push (TV_NAME_LOOKUP);
3284 while (ns != global_namespace)
3287 ns = CP_DECL_CONTEXT (ns);
3290 pop_from_top_level ();
3291 timevar_pop (TV_NAME_LOOKUP);
3294 /* Temporarily set the namespace for the current declaration. */
3297 push_decl_namespace (tree decl)
3299 if (TREE_CODE (decl) != NAMESPACE_DECL)
3300 decl = decl_namespace_context (decl);
3301 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3302 NULL_TREE, decl_namespace_list);
3305 /* [namespace.memdef]/2 */
3308 pop_decl_namespace (void)
3310 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3313 /* Return the namespace that is the common ancestor
3314 of two given namespaces. */
3317 namespace_ancestor (tree ns1, tree ns2)
3319 timevar_push (TV_NAME_LOOKUP);
3320 if (is_ancestor (ns1, ns2))
3321 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3322 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3323 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3326 /* Process a namespace-alias declaration. */
3329 do_namespace_alias (tree alias, tree name_space)
3331 if (name_space == error_mark_node)
3334 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3336 name_space = ORIGINAL_NAMESPACE (name_space);
3338 /* Build the alias. */
3339 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3340 DECL_NAMESPACE_ALIAS (alias) = name_space;
3341 DECL_EXTERNAL (alias) = 1;
3342 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3345 /* Emit debug info for namespace alias. */
3346 if (!building_stmt_tree ())
3347 (*debug_hooks->global_decl) (alias);
3350 /* Like pushdecl, only it places X in the current namespace,
3354 pushdecl_namespace_level (tree x, bool is_friend)
3356 struct cp_binding_level *b = current_binding_level;
3359 timevar_push (TV_NAME_LOOKUP);
3360 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3362 /* Now, the type_shadowed stack may screw us. Munge it so it does
3364 if (TREE_CODE (t) == TYPE_DECL)
3366 tree name = DECL_NAME (t);
3368 tree *ptr = (tree *)0;
3369 for (; !global_scope_p (b); b = b->level_chain)
3371 tree shadowed = b->type_shadowed;
3372 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3373 if (TREE_PURPOSE (shadowed) == name)
3375 ptr = &TREE_VALUE (shadowed);
3376 /* Can't break out of the loop here because sometimes
3377 a binding level will have duplicate bindings for
3378 PT names. It's gross, but I haven't time to fix it. */
3381 newval = TREE_TYPE (t);
3382 if (ptr == (tree *)0)
3384 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3385 up here if this is changed to an assertion. --KR */
3386 SET_IDENTIFIER_TYPE_VALUE (name, t);
3393 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3396 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3397 directive is not directly from the source. Also find the common
3398 ancestor and let our users know about the new namespace */
3400 add_using_namespace (tree user, tree used, bool indirect)
3403 timevar_push (TV_NAME_LOOKUP);
3404 /* Using oneself is a no-op. */
3407 timevar_pop (TV_NAME_LOOKUP);
3410 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3411 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3412 /* Check if we already have this. */
3413 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3417 /* Promote to direct usage. */
3418 TREE_INDIRECT_USING (t) = 0;
3419 timevar_pop (TV_NAME_LOOKUP);
3423 /* Add used to the user's using list. */
3424 DECL_NAMESPACE_USING (user)
3425 = tree_cons (used, namespace_ancestor (user, used),
3426 DECL_NAMESPACE_USING (user));
3428 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3430 /* Add user to the used's users list. */
3431 DECL_NAMESPACE_USERS (used)
3432 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3434 /* Recursively add all namespaces used. */
3435 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3436 /* indirect usage */
3437 add_using_namespace (user, TREE_PURPOSE (t), 1);
3439 /* Tell everyone using us about the new used namespaces. */
3440 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3441 add_using_namespace (TREE_PURPOSE (t), used, 1);
3442 timevar_pop (TV_NAME_LOOKUP);
3445 /* Process a using-declaration not appearing in class or local scope. */
3448 do_toplevel_using_decl (tree decl, tree scope, tree name)
3450 tree oldval, oldtype, newval, newtype;
3451 tree orig_decl = decl;
3452 cxx_binding *binding;
3454 decl = validate_nonmember_using_decl (decl, scope, name);
3455 if (decl == NULL_TREE)
3458 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3460 oldval = binding->value;
3461 oldtype = binding->type;
3463 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3465 /* Emit debug info. */
3466 if (!processing_template_decl)
3467 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3469 /* Copy declarations found. */
3471 binding->value = newval;
3473 binding->type = newtype;
3476 /* Process a using-directive. */
3479 do_using_directive (tree name_space)
3481 tree context = NULL_TREE;
3483 if (name_space == error_mark_node)
3486 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3488 if (building_stmt_tree ())
3489 add_stmt (build_stmt (USING_STMT, name_space));
3490 name_space = ORIGINAL_NAMESPACE (name_space);
3492 if (!toplevel_bindings_p ())
3494 push_using_directive (name_space);
3499 add_using_namespace (current_namespace, name_space, 0);
3500 if (current_namespace != global_namespace)
3501 context = current_namespace;
3503 /* Emit debugging info. */
3504 if (!processing_template_decl)
3505 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3510 /* Deal with a using-directive seen by the parser. Currently we only
3511 handle attributes here, since they cannot appear inside a template. */
3514 parse_using_directive (tree name_space, tree attribs)
3518 do_using_directive (name_space);
3520 for (a = attribs; a; a = TREE_CHAIN (a))
3522 tree name = TREE_PURPOSE (a);
3523 if (is_attribute_p ("strong", name))
3525 if (!toplevel_bindings_p ())
3526 error ("strong using only meaningful at namespace scope");
3527 else if (name_space != error_mark_node)
3529 if (!is_ancestor (current_namespace, name_space))
3530 error ("current namespace %qD does not enclose strongly used namespace %qD",
3531 current_namespace, name_space);
3532 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3533 = tree_cons (current_namespace, 0,
3534 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3538 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3542 /* Like pushdecl, only it places X in the global scope if appropriate.
3543 Calls cp_finish_decl to register the variable, initializing it with
3544 *INIT, if INIT is non-NULL. */
3547 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3549 timevar_push (TV_NAME_LOOKUP);
3550 push_to_top_level ();
3551 x = pushdecl_namespace_level (x, is_friend);
3553 finish_decl (x, *init, NULL_TREE);
3554 pop_from_top_level ();
3555 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3558 /* Like pushdecl, only it places X in the global scope if appropriate. */
3561 pushdecl_top_level (tree x)
3563 return pushdecl_top_level_1 (x, NULL, false);
3566 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3569 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3571 return pushdecl_top_level_1 (x, NULL, is_friend);
3574 /* Like pushdecl, only it places X in the global scope if
3575 appropriate. Calls cp_finish_decl to register the variable,
3576 initializing it with INIT. */
3579 pushdecl_top_level_and_finish (tree x, tree init)
3581 return pushdecl_top_level_1 (x, &init, false);
3584 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3585 duplicates. The first list becomes the tail of the result.
3587 The algorithm is O(n^2). We could get this down to O(n log n) by
3588 doing a sort on the addresses of the functions, if that becomes
3592 merge_functions (tree s1, tree s2)
3594 for (; s2; s2 = OVL_NEXT (s2))
3596 tree fn2 = OVL_CURRENT (s2);
3599 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3601 tree fn1 = OVL_CURRENT (fns1);
3603 /* If the function from S2 is already in S1, there is no
3604 need to add it again. For `extern "C"' functions, we
3605 might have two FUNCTION_DECLs for the same function, in
3606 different namespaces, but let's leave them in in case
3607 they have different default arguments. */
3612 /* If we exhausted all of the functions in S1, FN2 is new. */
3614 s1 = build_overload (fn2, s1);
3619 /* This should return an error not all definitions define functions.
3620 It is not an error if we find two functions with exactly the
3621 same signature, only if these are selected in overload resolution.
3622 old is the current set of bindings, new_binding the freshly-found binding.
3623 XXX Do we want to give *all* candidates in case of ambiguity?
3624 XXX In what way should I treat extern declarations?
3625 XXX I don't want to repeat the entire duplicate_decls here */
3628 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3631 gcc_assert (old != NULL);
3633 /* Copy the type. */
3634 type = new_binding->type;
3635 if (LOOKUP_NAMESPACES_ONLY (flags)
3636 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3639 /* Copy the value. */
3640 val = new_binding->value;
3643 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3646 switch (TREE_CODE (val))
3649 /* If we expect types or namespaces, and not templates,
3650 or this is not a template class. */
3651 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3652 && !DECL_CLASS_TEMPLATE_P (val)))
3656 if (LOOKUP_NAMESPACES_ONLY (flags)
3657 || (type && (flags & LOOKUP_PREFER_TYPES)))
3660 case NAMESPACE_DECL:
3661 if (LOOKUP_TYPES_ONLY (flags))
3665 /* Ignore built-in functions that are still anticipated. */
3666 if (LOOKUP_QUALIFIERS_ONLY (flags))
3670 if (LOOKUP_QUALIFIERS_ONLY (flags))
3675 /* If val is hidden, shift down any class or enumeration name. */
3684 else if (val && val != old->value)
3686 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3687 old->value = merge_functions (old->value, val);
3690 old->value = tree_cons (NULL_TREE, old->value,
3691 build_tree_list (NULL_TREE, val));
3692 TREE_TYPE (old->value) = error_mark_node;
3698 else if (type && old->type != type)
3700 old->type = tree_cons (NULL_TREE, old->type,
3701 build_tree_list (NULL_TREE, type));
3702 TREE_TYPE (old->type) = error_mark_node;
3706 /* Return the declarations that are members of the namespace NS. */
3709 cp_namespace_decls (tree ns)
3711 return NAMESPACE_LEVEL (ns)->names;
3714 /* Combine prefer_type and namespaces_only into flags. */
3717 lookup_flags (int prefer_type, int namespaces_only)
3719 if (namespaces_only)
3720 return LOOKUP_PREFER_NAMESPACES;
3721 if (prefer_type > 1)
3722 return LOOKUP_PREFER_TYPES;
3723 if (prefer_type > 0)
3724 return LOOKUP_PREFER_BOTH;
3728 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3729 ignore it or not. Subroutine of lookup_name_real and
3730 lookup_type_scope. */
3733 qualify_lookup (tree val, int flags)
3735 if (val == NULL_TREE)
3737 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3739 if ((flags & LOOKUP_PREFER_TYPES)
3740 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3742 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3747 /* Given a lookup that returned VAL, decide if we want to ignore it or
3748 not based on DECL_ANTICIPATED. */
3751 hidden_name_p (tree val)
3754 && DECL_LANG_SPECIFIC (val)
3755 && DECL_ANTICIPATED (val))
3760 /* Remove any hidden friend functions from a possibly overloaded set
3764 remove_hidden_names (tree fns)
3769 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3771 else if (TREE_CODE (fns) == OVERLOAD)
3775 for (o = fns; o; o = OVL_NEXT (o))
3776 if (hidden_name_p (OVL_CURRENT (o)))
3782 for (o = fns; o; o = OVL_NEXT (o))
3783 if (!hidden_name_p (OVL_CURRENT (o)))
3784 n = build_overload (OVL_CURRENT (o), n);
3792 /* Unscoped lookup of a global: iterate over current namespaces,
3793 considering using-directives. */
3796 unqualified_namespace_lookup (tree name, int flags)
3798 tree initial = current_decl_namespace ();
3799 tree scope = initial;
3801 struct cp_binding_level *level;
3802 tree val = NULL_TREE;
3804 timevar_push (TV_NAME_LOOKUP);
3806 for (; !val; scope = CP_DECL_CONTEXT (scope))
3808 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3810 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3813 ambiguous_decl (&binding, b, flags);
3815 /* Add all _DECLs seen through local using-directives. */
3816 for (level = current_binding_level;
3817 level->kind != sk_namespace;
3818 level = level->level_chain)
3819 if (!lookup_using_namespace (name, &binding, level->using_directives,
3821 /* Give up because of error. */
3822 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3824 /* Add all _DECLs seen through global using-directives. */
3825 /* XXX local and global using lists should work equally. */
3829 if (!lookup_using_namespace (name, &binding,
3830 DECL_NAMESPACE_USING (siter),
3832 /* Give up because of error. */
3833 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3834 if (siter == scope) break;
3835 siter = CP_DECL_CONTEXT (siter);
3838 val = binding.value;
3839 if (scope == global_namespace)
3842 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3845 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3846 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3849 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3850 declaration found. If no suitable declaration can be found,
3851 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3852 neither a class-type nor a namespace a diagnostic is issued. */
3855 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3860 if (TREE_CODE (scope) == NAMESPACE_DECL)
3862 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3864 flags |= LOOKUP_COMPLAIN;
3866 flags |= LOOKUP_PREFER_TYPES;
3867 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3870 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3871 t = lookup_enumerator (scope, name);
3872 else if (is_class_type (scope, complain))
3873 t = lookup_member (scope, name, 2, is_type_p);
3876 return error_mark_node;
3880 /* Subroutine of unqualified_namespace_lookup:
3881 Add the bindings of NAME in used namespaces to VAL.
3882 We are currently looking for names in namespace SCOPE, so we
3883 look through USINGS for using-directives of namespaces
3884 which have SCOPE as a common ancestor with the current scope.
3885 Returns false on errors. */
3888 lookup_using_namespace (tree name, struct scope_binding *val,
3889 tree usings, tree scope, int flags)
3892 timevar_push (TV_NAME_LOOKUP);
3893 /* Iterate over all used namespaces in current, searching for using
3894 directives of scope. */
3895 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3896 if (TREE_VALUE (iter) == scope)
3898 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3900 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3901 /* Resolve ambiguities. */
3903 ambiguous_decl (val, val1, flags);
3905 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3908 /* Returns true iff VEC contains TARGET. */
3911 tree_vec_contains (VEC(tree,gc)* vec, tree target)
3915 for (i = 0; VEC_iterate(tree,vec,i,elt); ++i)
3922 Accepts the NAME to lookup and its qualifying SCOPE.
3923 Returns the name/type pair found into the cxx_binding *RESULT,
3924 or false on error. */
3927 qualified_lookup_using_namespace (tree name, tree scope,
3928 struct scope_binding *result, int flags)
3930 /* Maintain a list of namespaces visited... */
3931 VEC(tree,gc) *seen = NULL;
3932 VEC(tree,gc) *seen_inline = NULL;
3933 /* ... and a list of namespace yet to see. */
3934 VEC(tree,gc) *todo = NULL;
3935 VEC(tree,gc) *todo_maybe = NULL;
3936 VEC(tree,gc) *todo_inline = NULL;
3938 timevar_push (TV_NAME_LOOKUP);
3939 /* Look through namespace aliases. */
3940 scope = ORIGINAL_NAMESPACE (scope);
3942 /* Algorithm: Starting with SCOPE, walk through the the set of used
3943 namespaces. For each used namespace, look through its inline
3944 namespace set for any bindings and usings. If no bindings are found,
3945 add any usings seen to the set of used namespaces. */
3946 VEC_safe_push (tree, gc, todo, scope);
3948 while (VEC_length (tree, todo))
3951 scope = VEC_pop (tree, todo);
3952 if (tree_vec_contains (seen, scope))
3954 VEC_safe_push (tree, gc, seen, scope);
3955 VEC_safe_push (tree, gc, todo_inline, scope);
3958 while (VEC_length (tree, todo_inline))
3960 cxx_binding *binding;
3962 scope = VEC_pop (tree, todo_inline);
3963 if (tree_vec_contains (seen_inline, scope))
3965 VEC_safe_push (tree, gc, seen_inline, scope);
3968 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3972 ambiguous_decl (result, binding, flags);
3975 for (usings = DECL_NAMESPACE_USING (scope); usings;
3976 usings = TREE_CHAIN (usings))
3977 if (!TREE_INDIRECT_USING (usings))
3979 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
3980 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
3982 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
3987 VEC_truncate (tree, todo_maybe, 0);
3989 while (VEC_length (tree, todo_maybe))
3990 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
3992 VEC_free (tree,gc,todo);
3993 VEC_free (tree,gc,todo_maybe);
3994 VEC_free (tree,gc,todo_inline);
3995 VEC_free (tree,gc,seen);
3996 VEC_free (tree,gc,seen_inline);
3997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
4000 /* Subroutine of outer_binding.
4002 Returns TRUE if BINDING is a binding to a template parameter of
4003 SCOPE. In that case SCOPE is the scope of a primary template
4004 parameter -- in the sense of G++, i.e, a template that has its own
4007 Returns FALSE otherwise. */
4010 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4015 if (!binding || !scope)
4018 binding_value = binding->value ? binding->value : binding->type;
4021 && scope->this_entity
4022 && get_template_info (scope->this_entity)
4023 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4024 (get_template_info (scope->this_entity)))
4025 && parameter_of_template_p (binding_value,
4026 TI_TEMPLATE (get_template_info \
4027 (scope->this_entity))));
4030 /* Return the innermost non-namespace binding for NAME from a scope
4031 containing BINDING, or, if BINDING is NULL, the current scope.
4032 Please note that for a given template, the template parameters are
4033 considered to be in the scope containing the current scope.
4034 If CLASS_P is false, then class bindings are ignored. */
4037 outer_binding (tree name,
4038 cxx_binding *binding,
4043 cxx_scope *outer_scope;
4047 scope = binding->scope->level_chain;
4048 outer = binding->previous;
4052 scope = current_binding_level;
4053 outer = IDENTIFIER_BINDING (name);
4055 outer_scope = outer ? outer->scope : NULL;
4057 /* Because we create class bindings lazily, we might be missing a
4058 class binding for NAME. If there are any class binding levels
4059 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4060 declared, we must lookup NAME in those class scopes. */
4062 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4064 if (scope->kind == sk_class)
4066 cxx_binding *class_binding;
4068 class_binding = get_class_binding (name, scope);
4071 /* Thread this new class-scope binding onto the
4072 IDENTIFIER_BINDING list so that future lookups
4074 class_binding->previous = outer;
4076 binding->previous = class_binding;
4078 IDENTIFIER_BINDING (name) = class_binding;
4079 return class_binding;
4082 /* If we are in a member template, the template parms of the member
4083 template are considered to be inside the scope of the containing
4084 class, but within G++ the class bindings are all pushed between the
4085 template parms and the function body. So if the outer binding is
4086 a template parm for the current scope, return it now rather than
4087 look for a class binding. */
4088 if (outer_scope && outer_scope->kind == sk_template_parms
4089 && binding_to_template_parms_of_scope_p (outer, scope))
4092 scope = scope->level_chain;
4098 /* Return the innermost block-scope or class-scope value binding for
4099 NAME, or NULL_TREE if there is no such binding. */
4102 innermost_non_namespace_value (tree name)
4104 cxx_binding *binding;
4105 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4106 return binding ? binding->value : NULL_TREE;
4109 /* Look up NAME in the current binding level and its superiors in the
4110 namespace of variables, functions and typedefs. Return a ..._DECL
4111 node of some kind representing its definition if there is only one
4112 such declaration, or return a TREE_LIST with all the overloaded
4113 definitions if there are many, or return 0 if it is undefined.
4114 Hidden name, either friend declaration or built-in function, are
4117 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4118 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4119 Otherwise we prefer non-TYPE_DECLs.
4121 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4122 BLOCK_P is false, bindings in block scopes are ignored. */
4125 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4126 int namespaces_only, int flags)
4129 tree val = NULL_TREE;
4131 timevar_push (TV_NAME_LOOKUP);
4132 /* Conversion operators are handled specially because ordinary
4133 unqualified name lookup will not find template conversion
4135 if (IDENTIFIER_TYPENAME_P (name))
4137 struct cp_binding_level *level;
4139 for (level = current_binding_level;
4140 level && level->kind != sk_namespace;
4141 level = level->level_chain)
4146 /* A conversion operator can only be declared in a class
4148 if (level->kind != sk_class)
4151 /* Lookup the conversion operator in the class. */
4152 class_type = level->this_entity;
4153 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4155 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4158 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4161 flags |= lookup_flags (prefer_type, namespaces_only);
4163 /* First, look in non-namespace scopes. */
4165 if (current_class_type == NULL_TREE)
4168 if (block_p || !nonclass)
4169 for (iter = outer_binding (name, NULL, !nonclass);
4171 iter = outer_binding (name, iter, !nonclass))
4175 /* Skip entities we don't want. */
4176 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4179 /* If this is the kind of thing we're looking for, we're done. */
4180 if (qualify_lookup (iter->value, flags))
4181 binding = iter->value;
4182 else if ((flags & LOOKUP_PREFER_TYPES)
4183 && qualify_lookup (iter->type, flags))
4184 binding = iter->type;
4186 binding = NULL_TREE;
4190 if (hidden_name_p (binding))
4192 /* A non namespace-scope binding can only be hidden in the
4193 presence of a local class, due to friend declarations.
4195 In particular, consider:
4203 B* b; // error: B is hidden
4204 C* c; // OK, finds ::C
4207 B *b; // error: B is hidden
4208 C *c; // OK, finds ::C
4213 The standard says that "B" is a local class in "f"
4214 (but not nested within "A") -- but that name lookup
4215 for "B" does not find this declaration until it is
4216 declared directly with "f".
4222 If a friend declaration appears in a local class and
4223 the name specified is an unqualified name, a prior
4224 declaration is looked up without considering scopes
4225 that are outside the innermost enclosing non-class
4226 scope. For a friend function declaration, if there is
4227 no prior declaration, the program is ill-formed. For a
4228 friend class declaration, if there is no prior
4229 declaration, the class that is specified belongs to the
4230 innermost enclosing non-class scope, but if it is
4231 subsequently referenced, its name is not found by name
4232 lookup until a matching declaration is provided in the
4233 innermost enclosing nonclass scope.
4235 So just keep looking for a non-hidden binding.
4237 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4245 /* Now lookup in namespace scopes. */
4247 val = unqualified_namespace_lookup (name, flags);
4249 /* If we have a single function from a using decl, pull it out. */
4250 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4251 val = OVL_FUNCTION (val);
4253 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4257 lookup_name_nonclass (tree name)
4259 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4263 lookup_function_nonclass (tree name, tree args, bool block_p)
4266 lookup_arg_dependent (name,
4267 lookup_name_real (name, 0, 1, block_p, 0,
4273 lookup_name (tree name)
4275 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4279 lookup_name_prefer_type (tree name, int prefer_type)
4281 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4282 0, LOOKUP_COMPLAIN);
4285 /* Look up NAME for type used in elaborated name specifier in
4286 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4287 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4288 name, more scopes are checked if cleanup or template parameter
4289 scope is encountered.
4291 Unlike lookup_name_real, we make sure that NAME is actually
4292 declared in the desired scope, not from inheritance, nor using
4293 directive. For using declaration, there is DR138 still waiting
4294 to be resolved. Hidden name coming from an earlier friend
4295 declaration is also returned.
4297 A TYPE_DECL best matching the NAME is returned. Catching error
4298 and issuing diagnostics are caller's responsibility. */
4301 lookup_type_scope (tree name, tag_scope scope)
4303 cxx_binding *iter = NULL;
4304 tree val = NULL_TREE;
4306 timevar_push (TV_NAME_LOOKUP);
4308 /* Look in non-namespace scope first. */
4309 if (current_binding_level->kind != sk_namespace)
4310 iter = outer_binding (name, NULL, /*class_p=*/ true);
4311 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4313 /* Check if this is the kind of thing we're looking for.
4314 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4315 base class. For ITER->VALUE, we can simply use
4316 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4319 We check ITER->TYPE before ITER->VALUE in order to handle
4320 typedef struct C {} C;
4323 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4324 && (scope != ts_current
4325 || LOCAL_BINDING_P (iter)
4326 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4328 else if ((scope != ts_current
4329 || !INHERITED_VALUE_BINDING_P (iter))
4330 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4337 /* Look in namespace scope. */
4340 iter = cxx_scope_find_binding_for_name
4341 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4345 /* If this is the kind of thing we're looking for, we're done. */
4346 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4348 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4354 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4355 and template parameter scopes. */
4358 struct cp_binding_level *b = current_binding_level;
4361 if (iter->scope == b)
4362 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4364 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4365 || b->kind == sk_function_parms)
4367 else if (b->kind == sk_class
4368 && scope == ts_within_enclosing_non_class)
4375 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4378 /* Similar to `lookup_name' but look only in the innermost non-class
4382 lookup_name_innermost_nonclass_level (tree name)
4384 struct cp_binding_level *b;
4387 timevar_push (TV_NAME_LOOKUP);
4388 b = innermost_nonclass_level ();
4390 if (b->kind == sk_namespace)
4392 t = IDENTIFIER_NAMESPACE_VALUE (name);
4394 /* extern "C" function() */
4395 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4398 else if (IDENTIFIER_BINDING (name)
4399 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4401 cxx_binding *binding;
4402 binding = IDENTIFIER_BINDING (name);
4405 if (binding->scope == b
4406 && !(TREE_CODE (binding->value) == VAR_DECL
4407 && DECL_DEAD_FOR_LOCAL (binding->value)))
4408 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4410 if (b->kind == sk_cleanup)
4417 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4420 /* Like lookup_name_innermost_nonclass_level, but for types. */
4423 lookup_type_current_level (tree name)
4427 timevar_push (TV_NAME_LOOKUP);
4428 gcc_assert (current_binding_level->kind != sk_namespace);
4430 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4431 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4433 struct cp_binding_level *b = current_binding_level;
4436 if (purpose_member (name, b->type_shadowed))
4437 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4438 REAL_IDENTIFIER_TYPE_VALUE (name));
4439 if (b->kind == sk_cleanup)
4446 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4449 /* [basic.lookup.koenig] */
4450 /* A nonzero return value in the functions below indicates an error. */
4461 static bool arg_assoc (struct arg_lookup*, tree);
4462 static bool arg_assoc_args (struct arg_lookup*, tree);
4463 static bool arg_assoc_type (struct arg_lookup*, tree);
4464 static bool add_function (struct arg_lookup *, tree);
4465 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4466 static bool arg_assoc_class (struct arg_lookup *, tree);
4467 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4469 /* Add a function to the lookup structure.
4470 Returns true on error. */
4473 add_function (struct arg_lookup *k, tree fn)
4475 /* We used to check here to see if the function was already in the list,
4476 but that's O(n^2), which is just too expensive for function lookup.
4477 Now we deal with the occasional duplicate in joust. In doing this, we
4478 assume that the number of duplicates will be small compared to the
4479 total number of functions being compared, which should usually be the
4482 /* We must find only functions, or exactly one non-function. */
4485 else if (fn == k->functions)
4487 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4488 k->functions = build_overload (fn, k->functions);
4491 tree f1 = OVL_CURRENT (k->functions);
4493 if (is_overloaded_fn (f1))
4495 fn = f1; f1 = f2; f2 = fn;
4497 error ("%q+D is not a function,", f1);
4498 error (" conflict with %q+D", f2);
4499 error (" in call to %qD", k->name);
4506 /* Returns true iff CURRENT has declared itself to be an associated
4507 namespace of SCOPE via a strong using-directive (or transitive chain
4508 thereof). Both are namespaces. */
4511 is_associated_namespace (tree current, tree scope)
4513 tree seen = NULL_TREE;
4514 tree todo = NULL_TREE;
4518 if (scope == current)
4520 seen = tree_cons (scope, NULL_TREE, seen);
4521 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4522 if (!purpose_member (TREE_PURPOSE (t), seen))
4523 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4526 scope = TREE_PURPOSE (todo);
4527 todo = TREE_CHAIN (todo);
4534 /* Return whether FN is a friend of an associated class of ARG. */
4537 friend_of_associated_class_p (tree arg, tree fn)
4543 else if (type_unknown_p (arg))
4546 type = TREE_TYPE (arg);
4548 /* If TYPE is a class, the class itself and all base classes are
4549 associated classes. */
4550 if (CLASS_TYPE_P (type))
4552 if (is_friend (type, fn))
4555 if (TYPE_BINFO (type))
4557 tree binfo, base_binfo;
4560 for (binfo = TYPE_BINFO (type), i = 0;
4561 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4563 if (is_friend (BINFO_TYPE (base_binfo), fn))
4568 /* If TYPE is a class member, the class of which it is a member is
4569 an associated class. */
4570 if ((CLASS_TYPE_P (type)
4571 || TREE_CODE (type) == UNION_TYPE
4572 || TREE_CODE (type) == ENUMERAL_TYPE)
4573 && TYPE_CONTEXT (type)
4574 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4575 && is_friend (TYPE_CONTEXT (type), fn))
4581 /* Add functions of a namespace to the lookup structure.
4582 Returns true on error. */
4585 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4589 if (purpose_member (scope, k->namespaces))
4591 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4593 /* Check out our super-users. */
4594 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4595 value = TREE_CHAIN (value))
4596 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4599 /* Also look down into inline namespaces. */
4600 for (value = DECL_NAMESPACE_USING (scope); value;
4601 value = TREE_CHAIN (value))
4602 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4603 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4606 value = namespace_binding (k->name, scope);
4610 for (; value; value = OVL_NEXT (value))
4612 /* We don't want to find arbitrary hidden functions via argument
4613 dependent lookup. We only want to find friends of associated
4615 if (hidden_name_p (OVL_CURRENT (value)))
4619 for (args = k->args; args; args = TREE_CHAIN (args))
4620 if (friend_of_associated_class_p (TREE_VALUE (args),
4621 OVL_CURRENT (value)))
4627 if (add_function (k, OVL_CURRENT (value)))
4634 /* Adds everything associated with a template argument to the lookup
4635 structure. Returns true on error. */
4638 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4640 /* [basic.lookup.koenig]
4642 If T is a template-id, its associated namespaces and classes are
4643 ... the namespaces and classes associated with the types of the
4644 template arguments provided for template type parameters
4645 (excluding template template parameters); the namespaces in which
4646 any template template arguments are defined; and the classes in
4647 which any member templates used as template template arguments
4648 are defined. [Note: non-type template arguments do not
4649 contribute to the set of associated namespaces. ] */
4651 /* Consider first template template arguments. */
4652 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4653 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4655 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4657 tree ctx = CP_DECL_CONTEXT (arg);
4659 /* It's not a member template. */
4660 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4661 return arg_assoc_namespace (k, ctx);
4662 /* Otherwise, it must be member template. */
4664 return arg_assoc_class (k, ctx);
4666 /* It's an argument pack; handle it recursively. */
4667 else if (ARGUMENT_PACK_P (arg))
4669 tree args = ARGUMENT_PACK_ARGS (arg);
4670 int i, len = TREE_VEC_LENGTH (args);
4671 for (i = 0; i < len; ++i)
4672 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4677 /* It's not a template template argument, but it is a type template
4679 else if (TYPE_P (arg))
4680 return arg_assoc_type (k, arg);
4681 /* It's a non-type template argument. */
4686 /* Adds everything associated with class to the lookup structure.
4687 Returns true on error. */
4690 arg_assoc_class (struct arg_lookup *k, tree type)
4692 tree list, friends, context;
4695 /* Backend build structures, such as __builtin_va_list, aren't
4696 affected by all this. */
4697 if (!CLASS_TYPE_P (type))
4700 if (purpose_member (type, k->classes))
4702 k->classes = tree_cons (type, NULL_TREE, k->classes);
4704 context = decl_namespace_context (type);
4705 if (arg_assoc_namespace (k, context))
4708 if (TYPE_BINFO (type))
4710 /* Process baseclasses. */
4711 tree binfo, base_binfo;
4713 for (binfo = TYPE_BINFO (type), i = 0;
4714 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4715 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4719 /* Process friends. */
4720 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4721 list = TREE_CHAIN (list))
4722 if (k->name == FRIEND_NAME (list))
4723 for (friends = FRIEND_DECLS (list); friends;
4724 friends = TREE_CHAIN (friends))
4726 tree fn = TREE_VALUE (friends);
4728 /* Only interested in global functions with potentially hidden
4729 (i.e. unqualified) declarations. */
4730 if (CP_DECL_CONTEXT (fn) != context)
4732 /* Template specializations are never found by name lookup.
4733 (Templates themselves can be found, but not template
4734 specializations.) */
4735 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4737 if (add_function (k, fn))
4741 /* Process template arguments. */
4742 if (CLASSTYPE_TEMPLATE_INFO (type)
4743 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4745 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4746 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4747 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4753 /* Adds everything associated with a given type.
4754 Returns 1 on error. */
4757 arg_assoc_type (struct arg_lookup *k, tree type)
4759 /* As we do not get the type of non-type dependent expressions
4760 right, we can end up with such things without a type. */
4764 if (TYPE_PTRMEM_P (type))
4766 /* Pointer to member: associate class type and value type. */
4767 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4769 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4771 else switch (TREE_CODE (type))
4781 case FIXED_POINT_TYPE:
4785 if (TYPE_PTRMEMFUNC_P (type))
4786 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4787 return arg_assoc_class (k, type);
4789 case REFERENCE_TYPE:
4791 return arg_assoc_type (k, TREE_TYPE (type));
4794 return arg_assoc_namespace (k, decl_namespace_context (type));
4796 /* The basetype is referenced in the first arg type, so just
4799 /* Associate the parameter types. */
4800 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4802 /* Associate the return type. */
4803 return arg_assoc_type (k, TREE_TYPE (type));
4804 case TEMPLATE_TYPE_PARM:
4805 case BOUND_TEMPLATE_TEMPLATE_PARM:
4810 gcc_assert (type == unknown_type_node
4811 || type == init_list_type_node);
4813 case TYPE_PACK_EXPANSION:
4814 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4822 /* Adds everything associated with arguments. Returns true on error. */
4825 arg_assoc_args (struct arg_lookup *k, tree args)
4827 for (; args; args = TREE_CHAIN (args))
4828 if (arg_assoc (k, TREE_VALUE (args)))
4833 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4836 arg_assoc (struct arg_lookup *k, tree n)
4838 if (n == error_mark_node)
4842 return arg_assoc_type (k, n);
4844 if (! type_unknown_p (n))
4845 return arg_assoc_type (k, TREE_TYPE (n));
4847 if (TREE_CODE (n) == ADDR_EXPR)
4848 n = TREE_OPERAND (n, 0);
4849 if (TREE_CODE (n) == COMPONENT_REF)
4850 n = TREE_OPERAND (n, 1);
4851 if (TREE_CODE (n) == OFFSET_REF)
4852 n = TREE_OPERAND (n, 1);
4853 while (TREE_CODE (n) == TREE_LIST)
4855 if (TREE_CODE (n) == BASELINK)
4856 n = BASELINK_FUNCTIONS (n);
4858 if (TREE_CODE (n) == FUNCTION_DECL)
4859 return arg_assoc_type (k, TREE_TYPE (n));
4860 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4862 /* [basic.lookup.koenig]
4864 If T is a template-id, its associated namespaces and classes
4865 are the namespace in which the template is defined; for
4866 member templates, the member template's class... */
4867 tree templ = TREE_OPERAND (n, 0);
4868 tree args = TREE_OPERAND (n, 1);
4872 if (TREE_CODE (templ) == COMPONENT_REF)
4873 templ = TREE_OPERAND (templ, 1);
4875 /* First, the template. There may actually be more than one if
4876 this is an overloaded function template. But, in that case,
4877 we only need the first; all the functions will be in the same
4879 templ = OVL_CURRENT (templ);
4881 ctx = CP_DECL_CONTEXT (templ);
4883 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4885 if (arg_assoc_namespace (k, ctx) == 1)
4888 /* It must be a member template. */
4889 else if (arg_assoc_class (k, ctx) == 1)
4892 /* Now the arguments. */
4894 for (ix = TREE_VEC_LENGTH (args); ix--;)
4895 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4898 else if (TREE_CODE (n) == OVERLOAD)
4900 for (; n; n = OVL_CHAIN (n))
4901 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4908 /* Performs Koenig lookup depending on arguments, where fns
4909 are the functions found in normal lookup. */
4912 lookup_arg_dependent (tree name, tree fns, tree args)
4914 struct arg_lookup k;
4916 timevar_push (TV_NAME_LOOKUP);
4918 /* Remove any hidden friend functions from the list of functions
4919 found so far. They will be added back by arg_assoc_class as
4921 fns = remove_hidden_names (fns);
4926 k.classes = NULL_TREE;
4928 /* We previously performed an optimization here by setting
4929 NAMESPACES to the current namespace when it was safe. However, DR
4930 164 says that namespaces that were already searched in the first
4931 stage of template processing are searched again (potentially
4932 picking up later definitions) in the second stage. */
4933 k.namespaces = NULL_TREE;
4935 arg_assoc_args (&k, args);
4940 && TREE_CODE (fns) != VAR_DECL
4941 && !is_overloaded_fn (fns))
4943 error ("argument dependent lookup finds %q+D", fns);
4944 error (" in call to %qD", name);
4945 fns = error_mark_node;
4948 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4951 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4952 changed (i.e. there was already a directive), or the fresh
4953 TREE_LIST otherwise. */
4956 push_using_directive (tree used)
4958 tree ud = current_binding_level->using_directives;
4959 tree iter, ancestor;
4961 timevar_push (TV_NAME_LOOKUP);
4962 /* Check if we already have this. */
4963 if (purpose_member (used, ud) != NULL_TREE)
4964 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4966 ancestor = namespace_ancestor (current_decl_namespace (), used);
4967 ud = current_binding_level->using_directives;
4968 ud = tree_cons (used, ancestor, ud);
4969 current_binding_level->using_directives = ud;
4971 /* Recursively add all namespaces used. */
4972 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4973 push_using_directive (TREE_PURPOSE (iter));
4975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4978 /* The type TYPE is being declared. If it is a class template, or a
4979 specialization of a class template, do any processing required and
4980 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4981 being declared a friend. B is the binding level at which this TYPE
4984 Returns the TYPE_DECL for TYPE, which may have been altered by this
4988 maybe_process_template_type_declaration (tree type, int is_friend,
4991 tree decl = TYPE_NAME (type);
4993 if (processing_template_parmlist)
4994 /* You can't declare a new template type in a template parameter
4995 list. But, you can declare a non-template type:
4997 template <class A*> struct S;
4999 is a forward-declaration of `A'. */
5001 else if (b->kind == sk_namespace
5002 && current_binding_level->kind != sk_namespace)
5003 /* If this new type is being injected into a containing scope,
5004 then it's not a template type. */
5008 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5009 || TREE_CODE (type) == ENUMERAL_TYPE);
5011 if (processing_template_decl)
5013 /* This may change after the call to
5014 push_template_decl_real, but we want the original value. */
5015 tree name = DECL_NAME (decl);
5017 decl = push_template_decl_real (decl, is_friend);
5018 if (decl == error_mark_node)
5019 return error_mark_node;
5021 /* If the current binding level is the binding level for the
5022 template parameters (see the comment in
5023 begin_template_parm_list) and the enclosing level is a class
5024 scope, and we're not looking at a friend, push the
5025 declaration of the member class into the class scope. In the
5026 friend case, push_template_decl will already have put the
5027 friend into global scope, if appropriate. */
5028 if (TREE_CODE (type) != ENUMERAL_TYPE
5029 && !is_friend && b->kind == sk_template_parms
5030 && b->level_chain->kind == sk_class)
5032 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5034 if (!COMPLETE_TYPE_P (current_class_type))
5036 maybe_add_class_template_decl_list (current_class_type,
5037 type, /*friend_p=*/0);
5038 /* Put this UTD in the table of UTDs for the class. */
5039 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5040 CLASSTYPE_NESTED_UTDS (current_class_type) =
5041 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5043 binding_table_insert
5044 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5053 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5054 that the NAME is a class template, the tag is processed but not pushed.
5056 The pushed scope depend on the SCOPE parameter:
5057 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5059 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5060 non-template-parameter scope. This case is needed for forward
5062 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5063 TS_GLOBAL case except that names within template-parameter scopes
5064 are not pushed at all.
5066 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5069 pushtag (tree name, tree type, tag_scope scope)
5071 struct cp_binding_level *b;
5074 timevar_push (TV_NAME_LOOKUP);
5075 b = current_binding_level;
5076 while (/* Cleanup scopes are not scopes from the point of view of
5078 b->kind == sk_cleanup
5079 /* Neither are function parameter scopes. */
5080 || b->kind == sk_function_parms
5081 /* Neither are the scopes used to hold template parameters
5082 for an explicit specialization. For an ordinary template
5083 declaration, these scopes are not scopes from the point of
5084 view of the language. */
5085 || (b->kind == sk_template_parms
5086 && (b->explicit_spec_p || scope == ts_global))
5087 || (b->kind == sk_class
5088 && (scope != ts_current
5089 /* We may be defining a new type in the initializer
5090 of a static member variable. We allow this when
5091 not pedantic, and it is particularly useful for
5092 type punning via an anonymous union. */
5093 || COMPLETE_TYPE_P (b->this_entity))))
5096 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5098 /* Do C++ gratuitous typedefing. */
5099 if (IDENTIFIER_TYPE_VALUE (name) != type)
5103 tree context = TYPE_CONTEXT (type);
5107 tree cs = current_scope ();
5109 if (scope == ts_current)
5111 else if (cs != NULL_TREE && TYPE_P (cs))
5112 /* When declaring a friend class of a local class, we want
5113 to inject the newly named class into the scope
5114 containing the local class, not the namespace
5116 context = decl_function_context (get_type_decl (cs));
5119 context = current_namespace;
5121 if (b->kind == sk_class
5122 || (b->kind == sk_template_parms
5123 && b->level_chain->kind == sk_class))
5126 if (current_lang_name == lang_name_java)
5127 TYPE_FOR_JAVA (type) = 1;
5129 tdef = create_implicit_typedef (name, type);
5130 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5131 if (scope == ts_within_enclosing_non_class)
5133 /* This is a friend. Make this TYPE_DECL node hidden from
5134 ordinary name lookup. Its corresponding TEMPLATE_DECL
5135 will be marked in push_template_decl_real. */
5136 retrofit_lang_decl (tdef);
5137 DECL_ANTICIPATED (tdef) = 1;
5138 DECL_FRIEND_P (tdef) = 1;
5141 decl = maybe_process_template_type_declaration
5142 (type, scope == ts_within_enclosing_non_class, b);
5143 if (decl == error_mark_node)
5144 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5146 if (b->kind == sk_class)
5148 if (!TYPE_BEING_DEFINED (current_class_type))
5149 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5151 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5152 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5153 class. But if it's a member template class, we want
5154 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5156 finish_member_declaration (decl);
5158 pushdecl_class_level (decl);
5160 else if (b->kind != sk_template_parms)
5162 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5163 if (decl == error_mark_node)
5164 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5168 set_identifier_type_value_with_scope (name, tdef, b);
5170 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5172 /* If this is a local class, keep track of it. We need this
5173 information for name-mangling, and so that it is possible to
5174 find all function definitions in a translation unit in a
5175 convenient way. (It's otherwise tricky to find a member
5176 function definition it's only pointed to from within a local
5178 if (TYPE_CONTEXT (type)
5179 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5180 VEC_safe_push (tree, gc, local_classes, type);
5182 if (b->kind == sk_class
5183 && !COMPLETE_TYPE_P (current_class_type))
5185 maybe_add_class_template_decl_list (current_class_type,
5186 type, /*friend_p=*/0);
5188 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5189 CLASSTYPE_NESTED_UTDS (current_class_type)
5190 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5192 binding_table_insert
5193 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5196 decl = TYPE_NAME (type);
5197 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5198 TYPE_STUB_DECL (type) = decl;
5200 /* Set type visibility now if this is a forward declaration. */
5201 TREE_PUBLIC (decl) = 1;
5202 determine_visibility (decl);
5204 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5207 /* Subroutines for reverting temporarily to top-level for instantiation
5208 of templates and such. We actually need to clear out the class- and
5209 local-value slots of all identifiers, so that only the global values
5210 are at all visible. Simply setting current_binding_level to the global
5211 scope isn't enough, because more binding levels may be pushed. */
5212 struct saved_scope *scope_chain;
5214 /* If ID has not already been marked, add an appropriate binding to
5218 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5220 cxx_saved_binding *saved;
5222 if (!id || !IDENTIFIER_BINDING (id))
5225 if (IDENTIFIER_MARKED (id))
5228 IDENTIFIER_MARKED (id) = 1;
5230 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5231 saved->identifier = id;
5232 saved->binding = IDENTIFIER_BINDING (id);
5233 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5234 IDENTIFIER_BINDING (id) = NULL;
5238 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5242 timevar_push (TV_NAME_LOOKUP);
5243 for (t = names; t; t = TREE_CHAIN (t))
5247 if (TREE_CODE (t) == TREE_LIST)
5248 id = TREE_PURPOSE (t);
5252 store_binding (id, old_bindings);
5254 timevar_pop (TV_NAME_LOOKUP);
5257 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5258 objects, rather than a TREE_LIST. */
5261 store_class_bindings (VEC(cp_class_binding,gc) *names,
5262 VEC(cxx_saved_binding,gc) **old_bindings)
5265 cp_class_binding *cb;
5267 timevar_push (TV_NAME_LOOKUP);
5268 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5269 store_binding (cb->identifier, old_bindings);
5270 timevar_pop (TV_NAME_LOOKUP);
5274 push_to_top_level (void)
5276 struct saved_scope *s;
5277 struct cp_binding_level *b;
5278 cxx_saved_binding *sb;
5282 timevar_push (TV_NAME_LOOKUP);
5283 s = GGC_CNEW (struct saved_scope);
5285 b = scope_chain ? current_binding_level : 0;
5287 /* If we're in the middle of some function, save our state. */
5291 push_function_context ();
5296 if (scope_chain && previous_class_level)
5297 store_class_bindings (previous_class_level->class_shadowed,
5300 /* Have to include the global scope, because class-scope decls
5301 aren't listed anywhere useful. */
5302 for (; b; b = b->level_chain)
5306 /* Template IDs are inserted into the global level. If they were
5307 inserted into namespace level, finish_file wouldn't find them
5308 when doing pending instantiations. Therefore, don't stop at
5309 namespace level, but continue until :: . */
5310 if (global_scope_p (b))
5313 store_bindings (b->names, &s->old_bindings);
5314 /* We also need to check class_shadowed to save class-level type
5315 bindings, since pushclass doesn't fill in b->names. */
5316 if (b->kind == sk_class)
5317 store_class_bindings (b->class_shadowed, &s->old_bindings);
5319 /* Unwind type-value slots back to top level. */
5320 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5321 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5324 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5325 IDENTIFIER_MARKED (sb->identifier) = 0;
5327 s->prev = scope_chain;
5329 s->need_pop_function_context = need_pop;
5330 s->function_decl = current_function_decl;
5331 s->skip_evaluation = skip_evaluation;
5334 current_function_decl = NULL_TREE;
5335 current_lang_base = VEC_alloc (tree, gc, 10);
5336 current_lang_name = lang_name_cplusplus;
5337 current_namespace = global_namespace;
5338 push_class_stack ();
5339 skip_evaluation = 0;
5340 timevar_pop (TV_NAME_LOOKUP);
5344 pop_from_top_level (void)
5346 struct saved_scope *s = scope_chain;
5347 cxx_saved_binding *saved;
5350 timevar_push (TV_NAME_LOOKUP);
5351 /* Clear out class-level bindings cache. */
5352 if (previous_class_level)
5353 invalidate_class_lookup_cache ();
5356 current_lang_base = 0;
5358 scope_chain = s->prev;
5359 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5361 tree id = saved->identifier;
5363 IDENTIFIER_BINDING (id) = saved->binding;
5364 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5367 /* If we were in the middle of compiling a function, restore our
5369 if (s->need_pop_function_context)
5370 pop_function_context ();
5371 current_function_decl = s->function_decl;
5372 skip_evaluation = s->skip_evaluation;
5373 timevar_pop (TV_NAME_LOOKUP);
5376 /* Pop off extraneous binding levels left over due to syntax errors.
5378 We don't pop past namespaces, as they might be valid. */
5381 pop_everything (void)
5383 if (ENABLE_SCOPE_CHECKING)
5384 verbatim ("XXX entering pop_everything ()\n");
5385 while (!toplevel_bindings_p ())
5387 if (current_binding_level->kind == sk_class)
5388 pop_nested_class ();
5392 if (ENABLE_SCOPE_CHECKING)
5393 verbatim ("XXX leaving pop_everything ()\n");
5396 /* Emit debugging information for using declarations and directives.
5397 If input tree is overloaded fn then emit debug info for all
5401 cp_emit_debug_info_for_using (tree t, tree context)
5403 /* Don't try to emit any debug information if we have errors. */
5404 if (sorrycount || errorcount)
5407 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5408 of a builtin function. */
5409 if (TREE_CODE (t) == FUNCTION_DECL
5410 && DECL_EXTERNAL (t)
5411 && DECL_BUILT_IN (t))
5414 /* Do not supply context to imported_module_or_decl, if
5415 it is a global namespace. */
5416 if (context == global_namespace)
5417 context = NULL_TREE;
5420 t = BASELINK_FUNCTIONS (t);
5422 /* FIXME: Handle TEMPLATE_DECLs. */
5423 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5424 if (TREE_CODE (t) != TEMPLATE_DECL)
5426 if (building_stmt_tree ())
5427 add_stmt (build_stmt (USING_STMT, t));
5429 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5433 #include "gt-cp-name-lookup.h"