1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding {
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope *innermost_nonclass_level (void);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree push_overloaded_decl (tree, int, bool);
47 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
49 static bool qualified_lookup_using_namespace (tree, tree,
50 struct scope_binding *, int);
51 static tree lookup_type_current_level (tree);
52 static tree push_using_directive (tree);
53 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name(void)
68 if (!anonymous_namespace_name)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73 anonymous_namespace_name = get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable)) binding_entry free_binding_entry = NULL;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name, tree type)
99 if (free_binding_entry)
101 entry = free_binding_entry;
102 free_binding_entry = entry->chain;
105 entry = GGC_NEW (struct binding_entry_s);
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry)
121 entry->chain = free_binding_entry;
122 free_binding_entry = entry;
126 /* The datatype used to implement the mapping from names to types at
128 struct binding_table_s GTY(())
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = GGC_NEW (struct binding_table_s);
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = GGC_NEW (cxx_binding);
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 if (VEC_length (cp_class_binding, scope->class_shadowed))
324 cp_class_binding *old_base;
325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
328 /* Fixup the current bindings, as they might have moved. */
332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
336 b = &IDENTIFIER_BINDING (cb->identifier);
337 while (*b != &old_base[i].base)
338 b = &((*b)->previous);
342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
347 cb->identifier = name;
349 binding->scope = scope;
350 cxx_binding_init (binding, value, type);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id, tree decl, cxx_scope* level)
360 cxx_binding *binding;
362 if (level != class_binding_level)
364 binding = cxx_binding_make (decl, NULL_TREE);
365 binding->scope = level;
368 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
370 /* Now, fill in the binding information. */
371 binding->previous = IDENTIFIER_BINDING (id);
372 INHERITED_VALUE_BINDING_P (binding) = 0;
373 LOCAL_BINDING_P (binding) = (level != class_binding_level);
375 /* And put it on the front of the list of bindings for ID. */
376 IDENTIFIER_BINDING (id) = binding;
379 /* Remove the binding for DECL which should be the innermost binding
383 pop_binding (tree id, tree decl)
385 cxx_binding *binding;
388 /* It's easiest to write the loops that call this function without
389 checking whether or not the entities involved have names. We
390 get here for such an entity. */
393 /* Get the innermost binding for ID. */
394 binding = IDENTIFIER_BINDING (id);
396 /* The name should be bound. */
397 gcc_assert (binding != NULL);
399 /* The DECL will be either the ordinary binding or the type
400 binding for this identifier. Remove that binding. */
401 if (binding->value == decl)
402 binding->value = NULL_TREE;
405 gcc_assert (binding->type == decl);
406 binding->type = NULL_TREE;
409 if (!binding->value && !binding->type)
411 /* We're completely done with the innermost binding for this
412 identifier. Unhook it from the list of bindings. */
413 IDENTIFIER_BINDING (id) = binding->previous;
415 /* Add it to the free list. */
416 cxx_binding_free (binding);
420 /* BINDING records an existing declaration for a name in the current scope.
421 But, DECL is another declaration for that same identifier in the
422 same scope. This is the `struct stat' hack whereby a non-typedef
423 class name or enum-name can be bound at the same level as some other
427 A class name (9.1) or enumeration name (7.2) can be hidden by the
428 name of an object, function, or enumerator declared in the same scope.
429 If a class or enumeration name and an object, function, or enumerator
430 are declared in the same scope (in any order) with the same name, the
431 class or enumeration name is hidden wherever the object, function, or
432 enumerator name is visible.
434 It's the responsibility of the caller to check that
435 inserting this name is valid here. Returns nonzero if the new binding
439 supplement_binding (cxx_binding *binding, tree decl)
441 tree bval = binding->value;
444 timevar_push (TV_NAME_LOOKUP);
445 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
446 /* The new name is the type name. */
447 binding->type = decl;
448 else if (/* BVAL is null when push_class_level_binding moves an
449 inherited type-binding out of the way to make room for a
450 new value binding. */
452 /* BVAL is error_mark_node when DECL's name has been used
453 in a non-class scope prior declaration. In that case,
454 we should have already issued a diagnostic; for graceful
455 error recovery purpose, pretend this was the intended
456 declaration for that name. */
457 || bval == error_mark_node
458 /* If BVAL is anticipated but has not yet been declared,
459 pretend it is not there at all. */
460 || (TREE_CODE (bval) == FUNCTION_DECL
461 && DECL_ANTICIPATED (bval)
462 && !DECL_HIDDEN_FRIEND_P (bval)))
463 binding->value = decl;
464 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
466 /* The old binding was a type name. It was placed in
467 VALUE field because it was thought, at the point it was
468 declared, to be the only entity with such a name. Move the
469 type name into the type slot; it is now hidden by the new
471 binding->type = bval;
472 binding->value = decl;
473 binding->value_is_inherited = false;
475 else if (TREE_CODE (bval) == TYPE_DECL
476 && TREE_CODE (decl) == TYPE_DECL
477 && DECL_NAME (decl) == DECL_NAME (bval)
478 && binding->scope->kind != sk_class
479 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
480 /* If either type involves template parameters, we must
481 wait until instantiation. */
482 || uses_template_parms (TREE_TYPE (decl))
483 || uses_template_parms (TREE_TYPE (bval))))
484 /* We have two typedef-names, both naming the same type to have
485 the same name. In general, this is OK because of:
489 In a given scope, a typedef specifier can be used to redefine
490 the name of any type declared in that scope to refer to the
491 type to which it already refers.
493 However, in class scopes, this rule does not apply due to the
494 stricter language in [class.mem] prohibiting redeclarations of
497 /* There can be two block-scope declarations of the same variable,
498 so long as they are `extern' declarations. However, there cannot
499 be two declarations of the same static data member:
503 A member shall not be declared twice in the
504 member-specification. */
505 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
506 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
507 && !DECL_CLASS_SCOPE_P (decl))
509 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
512 else if (TREE_CODE (decl) == NAMESPACE_DECL
513 && TREE_CODE (bval) == NAMESPACE_DECL
514 && DECL_NAMESPACE_ALIAS (decl)
515 && DECL_NAMESPACE_ALIAS (bval)
516 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
519 In a declarative region, a namespace-alias-definition can be
520 used to redefine a namespace-alias declared in that declarative
521 region to refer only to the namespace to which it already
526 error ("declaration of %q#D", decl);
527 error ("conflicts with previous declaration %q+#D", bval);
531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
534 /* Add DECL to the list of things declared in B. */
537 add_decl_to_level (tree decl, cxx_scope *b)
539 /* We used to record virtual tables as if they were ordinary
540 variables, but no longer do so. */
541 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
543 if (TREE_CODE (decl) == NAMESPACE_DECL
544 && !DECL_NAMESPACE_ALIAS (decl))
546 TREE_CHAIN (decl) = b->namespaces;
547 b->namespaces = decl;
551 /* We build up the list in reverse order, and reverse it later if
553 TREE_CHAIN (decl) = b->names;
557 /* If appropriate, add decl to separate list of statics. We
558 include extern variables because they might turn out to be
559 static later. It's OK for this list to contain a few false
561 if (b->kind == sk_namespace)
562 if ((TREE_CODE (decl) == VAR_DECL
563 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
564 || (TREE_CODE (decl) == FUNCTION_DECL
565 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
566 VEC_safe_push (tree, gc, b->static_decls, decl);
570 /* Record a decl-node X as belonging to the current lexical scope.
571 Check for errors (such as an incompatible declaration for the same
572 name already seen in the same scope). IS_FRIEND is true if X is
573 declared as a friend.
575 Returns either X or an old decl for the same name.
576 If an old decl is returned, it may have been smashed
577 to agree with what X says. */
580 pushdecl_maybe_friend (tree x, bool is_friend)
584 int need_new_binding;
586 timevar_push (TV_NAME_LOOKUP);
588 if (x == error_mark_node)
589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
591 need_new_binding = 1;
593 if (DECL_TEMPLATE_PARM_P (x))
594 /* Template parameters have no context; they are not X::T even
595 when declared within a class or namespace. */
599 if (current_function_decl && x != current_function_decl
600 /* A local declaration for a function doesn't constitute
602 && TREE_CODE (x) != FUNCTION_DECL
603 /* A local declaration for an `extern' variable is in the
604 scope of the current namespace, not the current
606 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
607 /* When parsing the parameter list of a function declarator,
608 don't set DECL_CONTEXT to an enclosing function. When we
609 push the PARM_DECLs in order to process the function body,
610 current_binding_level->this_entity will be set. */
611 && !(TREE_CODE (x) == PARM_DECL
612 && current_binding_level->kind == sk_function_parms
613 && current_binding_level->this_entity == NULL)
614 && !DECL_CONTEXT (x))
615 DECL_CONTEXT (x) = current_function_decl;
617 /* If this is the declaration for a namespace-scope function,
618 but the declaration itself is in a local scope, mark the
620 if (TREE_CODE (x) == FUNCTION_DECL
621 && DECL_NAMESPACE_SCOPE_P (x)
622 && current_function_decl
623 && x != current_function_decl)
624 DECL_LOCAL_FUNCTION_P (x) = 1;
627 name = DECL_NAME (x);
630 int different_binding_level = 0;
632 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
633 name = TREE_OPERAND (name, 0);
635 /* In case this decl was explicitly namespace-qualified, look it
636 up in its namespace context. */
637 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
638 t = namespace_binding (name, DECL_CONTEXT (x));
640 t = lookup_name_innermost_nonclass_level (name);
642 /* [basic.link] If there is a visible declaration of an entity
643 with linkage having the same name and type, ignoring entities
644 declared outside the innermost enclosing namespace scope, the
645 block scope declaration declares that same entity and
646 receives the linkage of the previous declaration. */
647 if (! t && current_function_decl && x != current_function_decl
648 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
649 && DECL_EXTERNAL (x))
651 /* Look in block scope. */
652 t = innermost_non_namespace_value (name);
653 /* Or in the innermost namespace. */
655 t = namespace_binding (name, DECL_CONTEXT (x));
656 /* Does it have linkage? Note that if this isn't a DECL, it's an
657 OVERLOAD, which is OK. */
658 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
661 different_binding_level = 1;
664 /* If we are declaring a function, and the result of name-lookup
665 was an OVERLOAD, look for an overloaded instance that is
666 actually the same as the function we are declaring. (If
667 there is one, we have to merge our declaration with the
668 previous declaration.) */
669 if (t && TREE_CODE (t) == OVERLOAD)
673 if (TREE_CODE (x) == FUNCTION_DECL)
674 for (match = t; match; match = OVL_NEXT (match))
676 if (decls_match (OVL_CURRENT (match), x))
680 /* Just choose one. */
684 t = OVL_CURRENT (match);
689 if (t && t != error_mark_node)
691 if (different_binding_level)
693 if (decls_match (x, t))
694 /* The standard only says that the local extern
695 inherits linkage from the previous decl; in
696 particular, default args are not shared. Add
697 the decl into a hash table to make sure only
698 the previous decl in this case is seen by the
701 struct cxx_int_tree_map *h;
704 TREE_PUBLIC (x) = TREE_PUBLIC (t);
706 if (cp_function_chain->extern_decl_map == NULL)
707 cp_function_chain->extern_decl_map
708 = htab_create_ggc (20, cxx_int_tree_map_hash,
709 cxx_int_tree_map_eq, NULL);
711 h = GGC_NEW (struct cxx_int_tree_map);
712 h->uid = DECL_UID (x);
714 loc = htab_find_slot_with_hash
715 (cp_function_chain->extern_decl_map, h,
717 *(struct cxx_int_tree_map **) loc = h;
720 else if (TREE_CODE (t) == PARM_DECL)
722 /* Check for duplicate params. */
723 tree d = duplicate_decls (x, t, is_friend);
725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
727 else if ((DECL_EXTERN_C_FUNCTION_P (x)
728 || DECL_FUNCTION_TEMPLATE_P (x))
729 && is_overloaded_fn (t))
730 /* Don't do anything just yet. */;
731 else if (t == wchar_decl_node)
733 if (! DECL_IN_SYSTEM_HEADER (x))
734 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
737 /* Throw away the redeclaration. */
738 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
742 tree olddecl = duplicate_decls (x, t, is_friend);
744 /* If the redeclaration failed, we can stop at this
746 if (olddecl == error_mark_node)
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
751 if (TREE_CODE (t) == TYPE_DECL)
752 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
756 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
758 /* A redeclaration of main, but not a duplicate of the
763 This function shall not be overloaded. */
764 error ("invalid redeclaration of %q+D", t);
766 /* We don't try to push this declaration since that
768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
773 /* If x has C linkage-specification, (extern "C"),
774 lookup its binding, in case it's already bound to an object.
775 The lookup is done in all namespaces.
776 If we find an existing binding, make sure it has the same
777 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
778 if ((TREE_CODE (x) == FUNCTION_DECL)
779 && DECL_EXTERN_C_P (x)
780 /* We should ignore declarations happening in system headers. */
781 && !DECL_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 (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
844 check_default_args (x);
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);
3909 Accepts the NAME to lookup and its qualifying SCOPE.
3910 Returns the name/type pair found into the cxx_binding *RESULT,
3911 or false on error. */
3914 qualified_lookup_using_namespace (tree name, tree scope,
3915 struct scope_binding *result, int flags)
3917 /* Maintain a list of namespaces visited... */
3918 tree seen = NULL_TREE;
3919 /* ... and a list of namespace yet to see. */
3920 tree todo = NULL_TREE;
3921 tree todo_maybe = NULL_TREE;
3923 timevar_push (TV_NAME_LOOKUP);
3924 /* Look through namespace aliases. */
3925 scope = ORIGINAL_NAMESPACE (scope);
3926 while (scope && result->value != error_mark_node)
3928 cxx_binding *binding =
3929 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3930 seen = tree_cons (scope, NULL_TREE, seen);
3932 ambiguous_decl (result, binding, flags);
3934 /* Consider strong using directives always, and non-strong ones
3935 if we haven't found a binding yet. ??? Shouldn't we consider
3936 non-strong ones if the initial RESULT is non-NULL, but the
3937 binding in the given namespace is? */
3938 for (usings = DECL_NAMESPACE_USING (scope); usings;
3939 usings = TREE_CHAIN (usings))
3940 /* If this was a real directive, and we have not seen it. */
3941 if (!TREE_INDIRECT_USING (usings))
3943 /* Try to avoid queuing the same namespace more than once,
3944 the exception being when a namespace was already
3945 enqueued for todo_maybe and then a strong using is
3946 found for it. We could try to remove it from
3947 todo_maybe, but it's probably not worth the effort. */
3948 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3949 && !purpose_member (TREE_PURPOSE (usings), seen)
3950 && !purpose_member (TREE_PURPOSE (usings), todo))
3951 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3952 else if ((!result->value && !result->type)
3953 && !purpose_member (TREE_PURPOSE (usings), seen)
3954 && !purpose_member (TREE_PURPOSE (usings), todo)
3955 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3956 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3961 scope = TREE_PURPOSE (todo);
3962 todo = TREE_CHAIN (todo);
3965 && (!result->value && !result->type))
3967 scope = TREE_PURPOSE (todo_maybe);
3968 todo = TREE_CHAIN (todo_maybe);
3969 todo_maybe = NULL_TREE;
3972 scope = NULL_TREE; /* If there never was a todo list. */
3974 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3977 /* Subroutine of outer_binding.
3978 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
3982 binding_to_template_parms_of_scope_p (cxx_binding *binding,
3987 if (!binding || !scope)
3990 binding_value = binding->value ? binding->value : binding->type;
3993 && scope->this_entity
3994 && get_template_info (scope->this_entity)
3995 && parameter_of_template_p (binding_value,
3996 TI_TEMPLATE (get_template_info \
3997 (scope->this_entity))));
4000 /* Return the innermost non-namespace binding for NAME from a scope
4001 containing BINDING, or, if BINDING is NULL, the current scope.
4002 Please note that for a given template, the template parameters are
4003 considered to be in the scope containing the current scope.
4004 If CLASS_P is false, then class bindings are ignored. */
4007 outer_binding (tree name,
4008 cxx_binding *binding,
4013 cxx_scope *outer_scope;
4017 scope = binding->scope->level_chain;
4018 outer = binding->previous;
4022 scope = current_binding_level;
4023 outer = IDENTIFIER_BINDING (name);
4025 outer_scope = outer ? outer->scope : NULL;
4027 /* Because we create class bindings lazily, we might be missing a
4028 class binding for NAME. If there are any class binding levels
4029 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4030 declared, we must lookup NAME in those class scopes. */
4032 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4034 if (scope->kind == sk_class)
4036 cxx_binding *class_binding;
4038 class_binding = get_class_binding (name, scope);
4041 /* Thread this new class-scope binding onto the
4042 IDENTIFIER_BINDING list so that future lookups
4044 class_binding->previous = outer;
4046 binding->previous = class_binding;
4048 IDENTIFIER_BINDING (name) = class_binding;
4049 return class_binding;
4052 /* If we are in a member template, the template parms of the member
4053 template are considered to be inside the scope of the containing
4054 class, but within G++ the class bindings are all pushed between the
4055 template parms and the function body. So if the outer binding is
4056 a template parm for the current scope, return it now rather than
4057 look for a class binding. */
4058 if (outer_scope && outer_scope->kind == sk_template_parms
4059 && binding_to_template_parms_of_scope_p (outer, scope))
4062 scope = scope->level_chain;
4068 /* Return the innermost block-scope or class-scope value binding for
4069 NAME, or NULL_TREE if there is no such binding. */
4072 innermost_non_namespace_value (tree name)
4074 cxx_binding *binding;
4075 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4076 return binding ? binding->value : NULL_TREE;
4079 /* Look up NAME in the current binding level and its superiors in the
4080 namespace of variables, functions and typedefs. Return a ..._DECL
4081 node of some kind representing its definition if there is only one
4082 such declaration, or return a TREE_LIST with all the overloaded
4083 definitions if there are many, or return 0 if it is undefined.
4084 Hidden name, either friend declaration or built-in function, are
4087 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4088 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4089 Otherwise we prefer non-TYPE_DECLs.
4091 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4092 BLOCK_P is false, bindings in block scopes are ignored. */
4095 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4096 int namespaces_only, int flags)
4099 tree val = NULL_TREE;
4101 timevar_push (TV_NAME_LOOKUP);
4102 /* Conversion operators are handled specially because ordinary
4103 unqualified name lookup will not find template conversion
4105 if (IDENTIFIER_TYPENAME_P (name))
4107 struct cp_binding_level *level;
4109 for (level = current_binding_level;
4110 level && level->kind != sk_namespace;
4111 level = level->level_chain)
4116 /* A conversion operator can only be declared in a class
4118 if (level->kind != sk_class)
4121 /* Lookup the conversion operator in the class. */
4122 class_type = level->this_entity;
4123 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4125 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4128 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4131 flags |= lookup_flags (prefer_type, namespaces_only);
4133 /* First, look in non-namespace scopes. */
4135 if (current_class_type == NULL_TREE)
4138 if (block_p || !nonclass)
4139 for (iter = outer_binding (name, NULL, !nonclass);
4141 iter = outer_binding (name, iter, !nonclass))
4145 /* Skip entities we don't want. */
4146 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4149 /* If this is the kind of thing we're looking for, we're done. */
4150 if (qualify_lookup (iter->value, flags))
4151 binding = iter->value;
4152 else if ((flags & LOOKUP_PREFER_TYPES)
4153 && qualify_lookup (iter->type, flags))
4154 binding = iter->type;
4156 binding = NULL_TREE;
4160 if (hidden_name_p (binding))
4162 /* A non namespace-scope binding can only be hidden in the
4163 presence of a local class, due to friend declarations.
4165 In particular, consider:
4173 B* b; // error: B is hidden
4174 C* c; // OK, finds ::C
4177 B *b; // error: B is hidden
4178 C *c; // OK, finds ::C
4183 The standard says that "B" is a local class in "f"
4184 (but not nested within "A") -- but that name lookup
4185 for "B" does not find this declaration until it is
4186 declared directly with "f".
4192 If a friend declaration appears in a local class and
4193 the name specified is an unqualified name, a prior
4194 declaration is looked up without considering scopes
4195 that are outside the innermost enclosing non-class
4196 scope. For a friend function declaration, if there is
4197 no prior declaration, the program is ill-formed. For a
4198 friend class declaration, if there is no prior
4199 declaration, the class that is specified belongs to the
4200 innermost enclosing non-class scope, but if it is
4201 subsequently referenced, its name is not found by name
4202 lookup until a matching declaration is provided in the
4203 innermost enclosing nonclass scope.
4205 So just keep looking for a non-hidden binding.
4207 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4215 /* Now lookup in namespace scopes. */
4217 val = unqualified_namespace_lookup (name, flags);
4219 /* If we have a single function from a using decl, pull it out. */
4220 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4221 val = OVL_FUNCTION (val);
4223 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4227 lookup_name_nonclass (tree name)
4229 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4233 lookup_function_nonclass (tree name, tree args, bool block_p)
4236 lookup_arg_dependent (name,
4237 lookup_name_real (name, 0, 1, block_p, 0,
4243 lookup_name (tree name)
4245 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4249 lookup_name_prefer_type (tree name, int prefer_type)
4251 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4252 0, LOOKUP_COMPLAIN);
4255 /* Look up NAME for type used in elaborated name specifier in
4256 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4257 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4258 name, more scopes are checked if cleanup or template parameter
4259 scope is encountered.
4261 Unlike lookup_name_real, we make sure that NAME is actually
4262 declared in the desired scope, not from inheritance, nor using
4263 directive. For using declaration, there is DR138 still waiting
4264 to be resolved. Hidden name coming from an earlier friend
4265 declaration is also returned.
4267 A TYPE_DECL best matching the NAME is returned. Catching error
4268 and issuing diagnostics are caller's responsibility. */
4271 lookup_type_scope (tree name, tag_scope scope)
4273 cxx_binding *iter = NULL;
4274 tree val = NULL_TREE;
4276 timevar_push (TV_NAME_LOOKUP);
4278 /* Look in non-namespace scope first. */
4279 if (current_binding_level->kind != sk_namespace)
4280 iter = outer_binding (name, NULL, /*class_p=*/ true);
4281 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4283 /* Check if this is the kind of thing we're looking for.
4284 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4285 base class. For ITER->VALUE, we can simply use
4286 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4289 We check ITER->TYPE before ITER->VALUE in order to handle
4290 typedef struct C {} C;
4293 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4294 && (scope != ts_current
4295 || LOCAL_BINDING_P (iter)
4296 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4298 else if ((scope != ts_current
4299 || !INHERITED_VALUE_BINDING_P (iter))
4300 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4307 /* Look in namespace scope. */
4310 iter = cxx_scope_find_binding_for_name
4311 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4315 /* If this is the kind of thing we're looking for, we're done. */
4316 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4318 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4324 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4325 and template parameter scopes. */
4328 struct cp_binding_level *b = current_binding_level;
4331 if (iter->scope == b)
4332 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4334 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4335 || b->kind == sk_function_parms)
4337 else if (b->kind == sk_class
4338 && scope == ts_within_enclosing_non_class)
4345 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4348 /* Similar to `lookup_name' but look only in the innermost non-class
4352 lookup_name_innermost_nonclass_level (tree name)
4354 struct cp_binding_level *b;
4357 timevar_push (TV_NAME_LOOKUP);
4358 b = innermost_nonclass_level ();
4360 if (b->kind == sk_namespace)
4362 t = IDENTIFIER_NAMESPACE_VALUE (name);
4364 /* extern "C" function() */
4365 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4368 else if (IDENTIFIER_BINDING (name)
4369 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4371 cxx_binding *binding;
4372 binding = IDENTIFIER_BINDING (name);
4375 if (binding->scope == b
4376 && !(TREE_CODE (binding->value) == VAR_DECL
4377 && DECL_DEAD_FOR_LOCAL (binding->value)))
4378 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4380 if (b->kind == sk_cleanup)
4387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4390 /* Like lookup_name_innermost_nonclass_level, but for types. */
4393 lookup_type_current_level (tree name)
4397 timevar_push (TV_NAME_LOOKUP);
4398 gcc_assert (current_binding_level->kind != sk_namespace);
4400 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4401 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4403 struct cp_binding_level *b = current_binding_level;
4406 if (purpose_member (name, b->type_shadowed))
4407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4408 REAL_IDENTIFIER_TYPE_VALUE (name));
4409 if (b->kind == sk_cleanup)
4416 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4419 /* [basic.lookup.koenig] */
4420 /* A nonzero return value in the functions below indicates an error. */
4431 static bool arg_assoc (struct arg_lookup*, tree);
4432 static bool arg_assoc_args (struct arg_lookup*, tree);
4433 static bool arg_assoc_type (struct arg_lookup*, tree);
4434 static bool add_function (struct arg_lookup *, tree);
4435 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4436 static bool arg_assoc_class (struct arg_lookup *, tree);
4437 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4439 /* Add a function to the lookup structure.
4440 Returns true on error. */
4443 add_function (struct arg_lookup *k, tree fn)
4445 /* We used to check here to see if the function was already in the list,
4446 but that's O(n^2), which is just too expensive for function lookup.
4447 Now we deal with the occasional duplicate in joust. In doing this, we
4448 assume that the number of duplicates will be small compared to the
4449 total number of functions being compared, which should usually be the
4452 /* We must find only functions, or exactly one non-function. */
4455 else if (fn == k->functions)
4457 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4458 k->functions = build_overload (fn, k->functions);
4461 tree f1 = OVL_CURRENT (k->functions);
4463 if (is_overloaded_fn (f1))
4465 fn = f1; f1 = f2; f2 = fn;
4467 error ("%q+D is not a function,", f1);
4468 error (" conflict with %q+D", f2);
4469 error (" in call to %qD", k->name);
4476 /* Returns true iff CURRENT has declared itself to be an associated
4477 namespace of SCOPE via a strong using-directive (or transitive chain
4478 thereof). Both are namespaces. */
4481 is_associated_namespace (tree current, tree scope)
4483 tree seen = NULL_TREE;
4484 tree todo = NULL_TREE;
4488 if (scope == current)
4490 seen = tree_cons (scope, NULL_TREE, seen);
4491 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4492 if (!purpose_member (TREE_PURPOSE (t), seen))
4493 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4496 scope = TREE_PURPOSE (todo);
4497 todo = TREE_CHAIN (todo);
4504 /* Return whether FN is a friend of an associated class of ARG. */
4507 friend_of_associated_class_p (tree arg, tree fn)
4513 else if (type_unknown_p (arg))
4516 type = TREE_TYPE (arg);
4518 /* If TYPE is a class, the class itself and all base classes are
4519 associated classes. */
4520 if (CLASS_TYPE_P (type))
4522 if (is_friend (type, fn))
4525 if (TYPE_BINFO (type))
4527 tree binfo, base_binfo;
4530 for (binfo = TYPE_BINFO (type), i = 0;
4531 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4533 if (is_friend (BINFO_TYPE (base_binfo), fn))
4538 /* If TYPE is a class member, the class of which it is a member is
4539 an associated class. */
4540 if ((CLASS_TYPE_P (type)
4541 || TREE_CODE (type) == UNION_TYPE
4542 || TREE_CODE (type) == ENUMERAL_TYPE)
4543 && TYPE_CONTEXT (type)
4544 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4545 && is_friend (TYPE_CONTEXT (type), fn))
4551 /* Add functions of a namespace to the lookup structure.
4552 Returns true on error. */
4555 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4559 if (purpose_member (scope, k->namespaces))
4561 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4563 /* Check out our super-users. */
4564 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4565 value = TREE_CHAIN (value))
4566 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4569 /* Also look down into inline namespaces. */
4570 for (value = DECL_NAMESPACE_USING (scope); value;
4571 value = TREE_CHAIN (value))
4572 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4573 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4576 value = namespace_binding (k->name, scope);
4580 for (; value; value = OVL_NEXT (value))
4582 /* We don't want to find arbitrary hidden functions via argument
4583 dependent lookup. We only want to find friends of associated
4585 if (hidden_name_p (OVL_CURRENT (value)))
4589 for (args = k->args; args; args = TREE_CHAIN (args))
4590 if (friend_of_associated_class_p (TREE_VALUE (args),
4591 OVL_CURRENT (value)))
4597 if (add_function (k, OVL_CURRENT (value)))
4604 /* Adds everything associated with a template argument to the lookup
4605 structure. Returns true on error. */
4608 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4610 /* [basic.lookup.koenig]
4612 If T is a template-id, its associated namespaces and classes are
4613 ... the namespaces and classes associated with the types of the
4614 template arguments provided for template type parameters
4615 (excluding template template parameters); the namespaces in which
4616 any template template arguments are defined; and the classes in
4617 which any member templates used as template template arguments
4618 are defined. [Note: non-type template arguments do not
4619 contribute to the set of associated namespaces. ] */
4621 /* Consider first template template arguments. */
4622 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4623 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4625 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4627 tree ctx = CP_DECL_CONTEXT (arg);
4629 /* It's not a member template. */
4630 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4631 return arg_assoc_namespace (k, ctx);
4632 /* Otherwise, it must be member template. */
4634 return arg_assoc_class (k, ctx);
4636 /* It's an argument pack; handle it recursively. */
4637 else if (ARGUMENT_PACK_P (arg))
4639 tree args = ARGUMENT_PACK_ARGS (arg);
4640 int i, len = TREE_VEC_LENGTH (args);
4641 for (i = 0; i < len; ++i)
4642 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4647 /* It's not a template template argument, but it is a type template
4649 else if (TYPE_P (arg))
4650 return arg_assoc_type (k, arg);
4651 /* It's a non-type template argument. */
4656 /* Adds everything associated with class to the lookup structure.
4657 Returns true on error. */
4660 arg_assoc_class (struct arg_lookup *k, tree type)
4662 tree list, friends, context;
4665 /* Backend build structures, such as __builtin_va_list, aren't
4666 affected by all this. */
4667 if (!CLASS_TYPE_P (type))
4670 if (purpose_member (type, k->classes))
4672 k->classes = tree_cons (type, NULL_TREE, k->classes);
4674 context = decl_namespace_context (type);
4675 if (arg_assoc_namespace (k, context))
4678 if (TYPE_BINFO (type))
4680 /* Process baseclasses. */
4681 tree binfo, base_binfo;
4683 for (binfo = TYPE_BINFO (type), i = 0;
4684 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4685 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4689 /* Process friends. */
4690 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4691 list = TREE_CHAIN (list))
4692 if (k->name == FRIEND_NAME (list))
4693 for (friends = FRIEND_DECLS (list); friends;
4694 friends = TREE_CHAIN (friends))
4696 tree fn = TREE_VALUE (friends);
4698 /* Only interested in global functions with potentially hidden
4699 (i.e. unqualified) declarations. */
4700 if (CP_DECL_CONTEXT (fn) != context)
4702 /* Template specializations are never found by name lookup.
4703 (Templates themselves can be found, but not template
4704 specializations.) */
4705 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4707 if (add_function (k, fn))
4711 /* Process template arguments. */
4712 if (CLASSTYPE_TEMPLATE_INFO (type)
4713 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4715 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4716 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4717 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4723 /* Adds everything associated with a given type.
4724 Returns 1 on error. */
4727 arg_assoc_type (struct arg_lookup *k, tree type)
4729 /* As we do not get the type of non-type dependent expressions
4730 right, we can end up with such things without a type. */
4734 if (TYPE_PTRMEM_P (type))
4736 /* Pointer to member: associate class type and value type. */
4737 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4739 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4741 else switch (TREE_CODE (type))
4751 case FIXED_POINT_TYPE:
4755 if (TYPE_PTRMEMFUNC_P (type))
4756 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4757 return arg_assoc_class (k, type);
4759 case REFERENCE_TYPE:
4761 return arg_assoc_type (k, TREE_TYPE (type));
4764 return arg_assoc_namespace (k, decl_namespace_context (type));
4766 /* The basetype is referenced in the first arg type, so just
4769 /* Associate the parameter types. */
4770 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4772 /* Associate the return type. */
4773 return arg_assoc_type (k, TREE_TYPE (type));
4774 case TEMPLATE_TYPE_PARM:
4775 case BOUND_TEMPLATE_TEMPLATE_PARM:
4780 gcc_assert (type == unknown_type_node
4781 || type == init_list_type_node);
4783 case TYPE_PACK_EXPANSION:
4784 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4792 /* Adds everything associated with arguments. Returns true on error. */
4795 arg_assoc_args (struct arg_lookup *k, tree args)
4797 for (; args; args = TREE_CHAIN (args))
4798 if (arg_assoc (k, TREE_VALUE (args)))
4803 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4806 arg_assoc (struct arg_lookup *k, tree n)
4808 if (n == error_mark_node)
4812 return arg_assoc_type (k, n);
4814 if (! type_unknown_p (n))
4815 return arg_assoc_type (k, TREE_TYPE (n));
4817 if (TREE_CODE (n) == ADDR_EXPR)
4818 n = TREE_OPERAND (n, 0);
4819 if (TREE_CODE (n) == COMPONENT_REF)
4820 n = TREE_OPERAND (n, 1);
4821 if (TREE_CODE (n) == OFFSET_REF)
4822 n = TREE_OPERAND (n, 1);
4823 while (TREE_CODE (n) == TREE_LIST)
4825 if (TREE_CODE (n) == BASELINK)
4826 n = BASELINK_FUNCTIONS (n);
4828 if (TREE_CODE (n) == FUNCTION_DECL)
4829 return arg_assoc_type (k, TREE_TYPE (n));
4830 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4832 /* [basic.lookup.koenig]
4834 If T is a template-id, its associated namespaces and classes
4835 are the namespace in which the template is defined; for
4836 member templates, the member template's class... */
4837 tree templ = TREE_OPERAND (n, 0);
4838 tree args = TREE_OPERAND (n, 1);
4842 if (TREE_CODE (templ) == COMPONENT_REF)
4843 templ = TREE_OPERAND (templ, 1);
4845 /* First, the template. There may actually be more than one if
4846 this is an overloaded function template. But, in that case,
4847 we only need the first; all the functions will be in the same
4849 templ = OVL_CURRENT (templ);
4851 ctx = CP_DECL_CONTEXT (templ);
4853 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4855 if (arg_assoc_namespace (k, ctx) == 1)
4858 /* It must be a member template. */
4859 else if (arg_assoc_class (k, ctx) == 1)
4862 /* Now the arguments. */
4864 for (ix = TREE_VEC_LENGTH (args); ix--;)
4865 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4868 else if (TREE_CODE (n) == OVERLOAD)
4870 for (; n; n = OVL_CHAIN (n))
4871 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4878 /* Performs Koenig lookup depending on arguments, where fns
4879 are the functions found in normal lookup. */
4882 lookup_arg_dependent (tree name, tree fns, tree args)
4884 struct arg_lookup k;
4886 timevar_push (TV_NAME_LOOKUP);
4888 /* Remove any hidden friend functions from the list of functions
4889 found so far. They will be added back by arg_assoc_class as
4891 fns = remove_hidden_names (fns);
4896 k.classes = NULL_TREE;
4898 /* We previously performed an optimization here by setting
4899 NAMESPACES to the current namespace when it was safe. However, DR
4900 164 says that namespaces that were already searched in the first
4901 stage of template processing are searched again (potentially
4902 picking up later definitions) in the second stage. */
4903 k.namespaces = NULL_TREE;
4905 arg_assoc_args (&k, args);
4910 && TREE_CODE (fns) != VAR_DECL
4911 && !is_overloaded_fn (fns))
4913 error ("argument dependent lookup finds %q+D", fns);
4914 error (" in call to %qD", name);
4915 fns = error_mark_node;
4918 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4921 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4922 changed (i.e. there was already a directive), or the fresh
4923 TREE_LIST otherwise. */
4926 push_using_directive (tree used)
4928 tree ud = current_binding_level->using_directives;
4929 tree iter, ancestor;
4931 timevar_push (TV_NAME_LOOKUP);
4932 /* Check if we already have this. */
4933 if (purpose_member (used, ud) != NULL_TREE)
4934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4936 ancestor = namespace_ancestor (current_decl_namespace (), used);
4937 ud = current_binding_level->using_directives;
4938 ud = tree_cons (used, ancestor, ud);
4939 current_binding_level->using_directives = ud;
4941 /* Recursively add all namespaces used. */
4942 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4943 push_using_directive (TREE_PURPOSE (iter));
4945 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4948 /* The type TYPE is being declared. If it is a class template, or a
4949 specialization of a class template, do any processing required and
4950 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4951 being declared a friend. B is the binding level at which this TYPE
4954 Returns the TYPE_DECL for TYPE, which may have been altered by this
4958 maybe_process_template_type_declaration (tree type, int is_friend,
4961 tree decl = TYPE_NAME (type);
4963 if (processing_template_parmlist)
4964 /* You can't declare a new template type in a template parameter
4965 list. But, you can declare a non-template type:
4967 template <class A*> struct S;
4969 is a forward-declaration of `A'. */
4971 else if (b->kind == sk_namespace
4972 && current_binding_level->kind != sk_namespace)
4973 /* If this new type is being injected into a containing scope,
4974 then it's not a template type. */
4978 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4979 || TREE_CODE (type) == ENUMERAL_TYPE);
4981 if (processing_template_decl)
4983 /* This may change after the call to
4984 push_template_decl_real, but we want the original value. */
4985 tree name = DECL_NAME (decl);
4987 decl = push_template_decl_real (decl, is_friend);
4988 if (decl == error_mark_node)
4989 return error_mark_node;
4991 /* If the current binding level is the binding level for the
4992 template parameters (see the comment in
4993 begin_template_parm_list) and the enclosing level is a class
4994 scope, and we're not looking at a friend, push the
4995 declaration of the member class into the class scope. In the
4996 friend case, push_template_decl will already have put the
4997 friend into global scope, if appropriate. */
4998 if (TREE_CODE (type) != ENUMERAL_TYPE
4999 && !is_friend && b->kind == sk_template_parms
5000 && b->level_chain->kind == sk_class)
5002 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5004 if (!COMPLETE_TYPE_P (current_class_type))
5006 maybe_add_class_template_decl_list (current_class_type,
5007 type, /*friend_p=*/0);
5008 /* Put this UTD in the table of UTDs for the class. */
5009 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5010 CLASSTYPE_NESTED_UTDS (current_class_type) =
5011 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5013 binding_table_insert
5014 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5023 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5024 that the NAME is a class template, the tag is processed but not pushed.
5026 The pushed scope depend on the SCOPE parameter:
5027 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5029 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5030 non-template-parameter scope. This case is needed for forward
5032 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5033 TS_GLOBAL case except that names within template-parameter scopes
5034 are not pushed at all.
5036 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5039 pushtag (tree name, tree type, tag_scope scope)
5041 struct cp_binding_level *b;
5044 timevar_push (TV_NAME_LOOKUP);
5045 b = current_binding_level;
5046 while (/* Cleanup scopes are not scopes from the point of view of
5048 b->kind == sk_cleanup
5049 /* Neither are function parameter scopes. */
5050 || b->kind == sk_function_parms
5051 /* Neither are the scopes used to hold template parameters
5052 for an explicit specialization. For an ordinary template
5053 declaration, these scopes are not scopes from the point of
5054 view of the language. */
5055 || (b->kind == sk_template_parms
5056 && (b->explicit_spec_p || scope == ts_global))
5057 || (b->kind == sk_class
5058 && (scope != ts_current
5059 /* We may be defining a new type in the initializer
5060 of a static member variable. We allow this when
5061 not pedantic, and it is particularly useful for
5062 type punning via an anonymous union. */
5063 || COMPLETE_TYPE_P (b->this_entity))))
5066 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5068 /* Do C++ gratuitous typedefing. */
5069 if (IDENTIFIER_TYPE_VALUE (name) != type)
5073 tree context = TYPE_CONTEXT (type);
5077 tree cs = current_scope ();
5079 if (scope == ts_current)
5081 else if (cs != NULL_TREE && TYPE_P (cs))
5082 /* When declaring a friend class of a local class, we want
5083 to inject the newly named class into the scope
5084 containing the local class, not the namespace
5086 context = decl_function_context (get_type_decl (cs));
5089 context = current_namespace;
5091 if (b->kind == sk_class
5092 || (b->kind == sk_template_parms
5093 && b->level_chain->kind == sk_class))
5096 if (current_lang_name == lang_name_java)
5097 TYPE_FOR_JAVA (type) = 1;
5099 tdef = create_implicit_typedef (name, type);
5100 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5101 if (scope == ts_within_enclosing_non_class)
5103 /* This is a friend. Make this TYPE_DECL node hidden from
5104 ordinary name lookup. Its corresponding TEMPLATE_DECL
5105 will be marked in push_template_decl_real. */
5106 retrofit_lang_decl (tdef);
5107 DECL_ANTICIPATED (tdef) = 1;
5108 DECL_FRIEND_P (tdef) = 1;
5111 decl = maybe_process_template_type_declaration
5112 (type, scope == ts_within_enclosing_non_class, b);
5113 if (decl == error_mark_node)
5114 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5116 if (b->kind == sk_class)
5118 if (!TYPE_BEING_DEFINED (current_class_type))
5119 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5121 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5122 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5123 class. But if it's a member template class, we want
5124 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5126 finish_member_declaration (decl);
5128 pushdecl_class_level (decl);
5130 else if (b->kind != sk_template_parms)
5132 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5133 if (decl == error_mark_node)
5134 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5138 set_identifier_type_value_with_scope (name, tdef, b);
5140 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5142 /* If this is a local class, keep track of it. We need this
5143 information for name-mangling, and so that it is possible to
5144 find all function definitions in a translation unit in a
5145 convenient way. (It's otherwise tricky to find a member
5146 function definition it's only pointed to from within a local
5148 if (TYPE_CONTEXT (type)
5149 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5150 VEC_safe_push (tree, gc, local_classes, type);
5152 if (b->kind == sk_class
5153 && !COMPLETE_TYPE_P (current_class_type))
5155 maybe_add_class_template_decl_list (current_class_type,
5156 type, /*friend_p=*/0);
5158 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5159 CLASSTYPE_NESTED_UTDS (current_class_type)
5160 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5162 binding_table_insert
5163 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5166 decl = TYPE_NAME (type);
5167 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5168 TYPE_STUB_DECL (type) = decl;
5170 /* Set type visibility now if this is a forward declaration. */
5171 TREE_PUBLIC (decl) = 1;
5172 determine_visibility (decl);
5174 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5177 /* Subroutines for reverting temporarily to top-level for instantiation
5178 of templates and such. We actually need to clear out the class- and
5179 local-value slots of all identifiers, so that only the global values
5180 are at all visible. Simply setting current_binding_level to the global
5181 scope isn't enough, because more binding levels may be pushed. */
5182 struct saved_scope *scope_chain;
5184 /* If ID has not already been marked, add an appropriate binding to
5188 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5190 cxx_saved_binding *saved;
5192 if (!id || !IDENTIFIER_BINDING (id))
5195 if (IDENTIFIER_MARKED (id))
5198 IDENTIFIER_MARKED (id) = 1;
5200 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5201 saved->identifier = id;
5202 saved->binding = IDENTIFIER_BINDING (id);
5203 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5204 IDENTIFIER_BINDING (id) = NULL;
5208 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5212 timevar_push (TV_NAME_LOOKUP);
5213 for (t = names; t; t = TREE_CHAIN (t))
5217 if (TREE_CODE (t) == TREE_LIST)
5218 id = TREE_PURPOSE (t);
5222 store_binding (id, old_bindings);
5224 timevar_pop (TV_NAME_LOOKUP);
5227 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5228 objects, rather than a TREE_LIST. */
5231 store_class_bindings (VEC(cp_class_binding,gc) *names,
5232 VEC(cxx_saved_binding,gc) **old_bindings)
5235 cp_class_binding *cb;
5237 timevar_push (TV_NAME_LOOKUP);
5238 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5239 store_binding (cb->identifier, old_bindings);
5240 timevar_pop (TV_NAME_LOOKUP);
5244 push_to_top_level (void)
5246 struct saved_scope *s;
5247 struct cp_binding_level *b;
5248 cxx_saved_binding *sb;
5252 timevar_push (TV_NAME_LOOKUP);
5253 s = GGC_CNEW (struct saved_scope);
5255 b = scope_chain ? current_binding_level : 0;
5257 /* If we're in the middle of some function, save our state. */
5261 push_function_context ();
5266 if (scope_chain && previous_class_level)
5267 store_class_bindings (previous_class_level->class_shadowed,
5270 /* Have to include the global scope, because class-scope decls
5271 aren't listed anywhere useful. */
5272 for (; b; b = b->level_chain)
5276 /* Template IDs are inserted into the global level. If they were
5277 inserted into namespace level, finish_file wouldn't find them
5278 when doing pending instantiations. Therefore, don't stop at
5279 namespace level, but continue until :: . */
5280 if (global_scope_p (b))
5283 store_bindings (b->names, &s->old_bindings);
5284 /* We also need to check class_shadowed to save class-level type
5285 bindings, since pushclass doesn't fill in b->names. */
5286 if (b->kind == sk_class)
5287 store_class_bindings (b->class_shadowed, &s->old_bindings);
5289 /* Unwind type-value slots back to top level. */
5290 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5291 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5294 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5295 IDENTIFIER_MARKED (sb->identifier) = 0;
5297 s->prev = scope_chain;
5299 s->need_pop_function_context = need_pop;
5300 s->function_decl = current_function_decl;
5301 s->skip_evaluation = skip_evaluation;
5304 current_function_decl = NULL_TREE;
5305 current_lang_base = VEC_alloc (tree, gc, 10);
5306 current_lang_name = lang_name_cplusplus;
5307 current_namespace = global_namespace;
5308 push_class_stack ();
5309 skip_evaluation = 0;
5310 timevar_pop (TV_NAME_LOOKUP);
5314 pop_from_top_level (void)
5316 struct saved_scope *s = scope_chain;
5317 cxx_saved_binding *saved;
5320 timevar_push (TV_NAME_LOOKUP);
5321 /* Clear out class-level bindings cache. */
5322 if (previous_class_level)
5323 invalidate_class_lookup_cache ();
5326 current_lang_base = 0;
5328 scope_chain = s->prev;
5329 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5331 tree id = saved->identifier;
5333 IDENTIFIER_BINDING (id) = saved->binding;
5334 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5337 /* If we were in the middle of compiling a function, restore our
5339 if (s->need_pop_function_context)
5340 pop_function_context ();
5341 current_function_decl = s->function_decl;
5342 skip_evaluation = s->skip_evaluation;
5343 timevar_pop (TV_NAME_LOOKUP);
5346 /* Pop off extraneous binding levels left over due to syntax errors.
5348 We don't pop past namespaces, as they might be valid. */
5351 pop_everything (void)
5353 if (ENABLE_SCOPE_CHECKING)
5354 verbatim ("XXX entering pop_everything ()\n");
5355 while (!toplevel_bindings_p ())
5357 if (current_binding_level->kind == sk_class)
5358 pop_nested_class ();
5362 if (ENABLE_SCOPE_CHECKING)
5363 verbatim ("XXX leaving pop_everything ()\n");
5366 /* Emit debugging information for using declarations and directives.
5367 If input tree is overloaded fn then emit debug info for all
5371 cp_emit_debug_info_for_using (tree t, tree context)
5373 /* Don't try to emit any debug information if we have errors. */
5374 if (sorrycount || errorcount)
5377 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5378 of a builtin function. */
5379 if (TREE_CODE (t) == FUNCTION_DECL
5380 && DECL_EXTERNAL (t)
5381 && DECL_BUILT_IN (t))
5384 /* Do not supply context to imported_module_or_decl, if
5385 it is a global namespace. */
5386 if (context == global_namespace)
5387 context = NULL_TREE;
5390 t = BASELINK_FUNCTIONS (t);
5392 /* FIXME: Handle TEMPLATE_DECLs. */
5393 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5394 if (TREE_CODE (t) != TEMPLATE_DECL)
5396 if (building_stmt_tree ())
5397 add_stmt (build_stmt (USING_STMT, t));
5399 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5403 #include "gt-cp-name-lookup.h"