1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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 && !DECL_CONTEXT (x))
608 DECL_CONTEXT (x) = current_function_decl;
610 /* If this is the declaration for a namespace-scope function,
611 but the declaration itself is in a local scope, mark the
613 if (TREE_CODE (x) == FUNCTION_DECL
614 && DECL_NAMESPACE_SCOPE_P (x)
615 && current_function_decl
616 && x != current_function_decl)
617 DECL_LOCAL_FUNCTION_P (x) = 1;
620 name = DECL_NAME (x);
623 int different_binding_level = 0;
625 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
626 name = TREE_OPERAND (name, 0);
628 /* In case this decl was explicitly namespace-qualified, look it
629 up in its namespace context. */
630 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
631 t = namespace_binding (name, DECL_CONTEXT (x));
633 t = lookup_name_innermost_nonclass_level (name);
635 /* [basic.link] If there is a visible declaration of an entity
636 with linkage having the same name and type, ignoring entities
637 declared outside the innermost enclosing namespace scope, the
638 block scope declaration declares that same entity and
639 receives the linkage of the previous declaration. */
640 if (! t && current_function_decl && x != current_function_decl
641 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
642 && DECL_EXTERNAL (x))
644 /* Look in block scope. */
645 t = innermost_non_namespace_value (name);
646 /* Or in the innermost namespace. */
648 t = namespace_binding (name, DECL_CONTEXT (x));
649 /* Does it have linkage? Note that if this isn't a DECL, it's an
650 OVERLOAD, which is OK. */
651 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
654 different_binding_level = 1;
657 /* If we are declaring a function, and the result of name-lookup
658 was an OVERLOAD, look for an overloaded instance that is
659 actually the same as the function we are declaring. (If
660 there is one, we have to merge our declaration with the
661 previous declaration.) */
662 if (t && TREE_CODE (t) == OVERLOAD)
666 if (TREE_CODE (x) == FUNCTION_DECL)
667 for (match = t; match; match = OVL_NEXT (match))
669 if (decls_match (OVL_CURRENT (match), x))
673 /* Just choose one. */
677 t = OVL_CURRENT (match);
682 if (t && t != error_mark_node)
684 if (different_binding_level)
686 if (decls_match (x, t))
687 /* The standard only says that the local extern
688 inherits linkage from the previous decl; in
689 particular, default args are not shared. Add
690 the decl into a hash table to make sure only
691 the previous decl in this case is seen by the
694 struct cxx_int_tree_map *h;
697 TREE_PUBLIC (x) = TREE_PUBLIC (t);
699 if (cp_function_chain->extern_decl_map == NULL)
700 cp_function_chain->extern_decl_map
701 = htab_create_ggc (20, cxx_int_tree_map_hash,
702 cxx_int_tree_map_eq, NULL);
704 h = GGC_NEW (struct cxx_int_tree_map);
705 h->uid = DECL_UID (x);
707 loc = htab_find_slot_with_hash
708 (cp_function_chain->extern_decl_map, h,
710 *(struct cxx_int_tree_map **) loc = h;
713 else if (TREE_CODE (t) == PARM_DECL)
715 gcc_assert (DECL_CONTEXT (t));
717 /* Check for duplicate params. */
718 if (duplicate_decls (x, t, is_friend))
719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
721 else if ((DECL_EXTERN_C_FUNCTION_P (x)
722 || DECL_FUNCTION_TEMPLATE_P (x))
723 && is_overloaded_fn (t))
724 /* Don't do anything just yet. */;
725 else if (t == wchar_decl_node)
727 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
728 pedwarn ("redeclaration of %<wchar_t%> as %qT",
731 /* Throw away the redeclaration. */
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
736 tree olddecl = duplicate_decls (x, t, is_friend);
738 /* If the redeclaration failed, we can stop at this
740 if (olddecl == error_mark_node)
741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
745 if (TREE_CODE (t) == TYPE_DECL)
746 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
750 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
752 /* A redeclaration of main, but not a duplicate of the
757 This function shall not be overloaded. */
758 error ("invalid redeclaration of %q+D", t);
760 /* We don't try to push this declaration since that
762 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
767 /* If x has C linkage-specification, (extern "C"),
768 lookup its binding, in case it's already bound to an object.
769 The lookup is done in all namespaces.
770 If we find an existing binding, make sure it has the same
771 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
772 if ((TREE_CODE (x) == FUNCTION_DECL)
773 && DECL_EXTERN_C_P (x)
774 /* We should ignore declarations happening in system headers. */
775 && !DECL_IN_SYSTEM_HEADER (x))
777 cxx_binding *function_binding =
778 lookup_extern_c_fun_binding_in_all_ns (x);
780 && !DECL_IN_SYSTEM_HEADER (function_binding->value))
782 tree previous = function_binding->value;
784 /* In case either x or previous is declared to throw an exception,
785 make sure both exception specifications are equal. */
786 if (decls_match (x, previous))
788 tree x_exception_spec = NULL_TREE;
789 tree previous_exception_spec = NULL_TREE;
792 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
793 previous_exception_spec =
794 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
795 if (!comp_except_specs (previous_exception_spec,
799 pedwarn ("declaration of %q#D with C language linkage", x);
800 pedwarn ("conflicts with previous declaration %q+#D",
802 pedwarn ("due to different exception specifications");
803 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
809 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
810 check_default_args (x);
812 check_template_shadow (x);
814 /* If this is a function conjured up by the back end, massage it
815 so it looks friendly. */
816 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
818 retrofit_lang_decl (x);
819 SET_DECL_LANGUAGE (x, lang_c);
822 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
824 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
826 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
827 if (!namespace_bindings_p ())
828 /* We do not need to create a binding for this name;
829 push_overloaded_decl will have already done so if
831 need_new_binding = 0;
833 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
835 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
837 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
838 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
841 /* If declaring a type as a typedef, copy the type (unless we're
842 at line 0), and install this TYPE_DECL as the new type's typedef
843 name. See the extensive comment in ../c-decl.c (pushdecl). */
844 if (TREE_CODE (x) == TYPE_DECL)
846 tree type = TREE_TYPE (x);
847 if (DECL_IS_BUILTIN (x))
849 if (TYPE_NAME (type) == 0)
850 TYPE_NAME (type) = x;
852 else if (type != error_mark_node && TYPE_NAME (type) != x
853 /* We don't want to copy the type when all we're
854 doing is making a TYPE_DECL for the purposes of
856 && (!TYPE_NAME (type)
857 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
859 DECL_ORIGINAL_TYPE (x) = type;
860 type = build_variant_type_copy (type);
861 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
862 TYPE_NAME (type) = x;
863 TREE_TYPE (x) = type;
866 if (type != error_mark_node
868 && TYPE_IDENTIFIER (type))
869 set_identifier_type_value (DECL_NAME (x), x);
872 /* Multiple external decls of the same identifier ought to match.
874 We get warnings about inline functions where they are defined.
875 We get warnings about other functions from push_overloaded_decl.
877 Avoid duplicate warnings where they are used. */
878 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
882 decl = IDENTIFIER_NAMESPACE_VALUE (name);
883 if (decl && TREE_CODE (decl) == OVERLOAD)
884 decl = OVL_FUNCTION (decl);
886 if (decl && decl != error_mark_node
887 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
888 /* If different sort of thing, we already gave an error. */
889 && TREE_CODE (decl) == TREE_CODE (x)
890 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
892 permerror ("type mismatch with previous external decl of %q#D", x);
893 permerror ("previous external decl of %q+#D", decl);
897 if (TREE_CODE (x) == FUNCTION_DECL
899 && !flag_friend_injection)
901 /* This is a new declaration of a friend function, so hide
902 it from ordinary function lookup. */
903 DECL_ANTICIPATED (x) = 1;
904 DECL_HIDDEN_FRIEND_P (x) = 1;
907 /* This name is new in its binding level.
908 Install the new declaration and return it. */
909 if (namespace_bindings_p ())
911 /* Install a global value. */
913 /* If the first global decl has external linkage,
914 warn if we later see static one. */
915 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
916 TREE_PUBLIC (name) = 1;
918 /* Bind the name for the entity. */
919 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
921 && (TREE_CODE (x) == TYPE_DECL
922 || TREE_CODE (x) == VAR_DECL
923 || TREE_CODE (x) == NAMESPACE_DECL
924 || TREE_CODE (x) == CONST_DECL
925 || TREE_CODE (x) == TEMPLATE_DECL))
926 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
928 /* If new decl is `static' and an `extern' was seen previously,
930 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
931 warn_extern_redeclared_static (x, t);
935 /* Here to install a non-global value. */
936 tree oldlocal = innermost_non_namespace_value (name);
937 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
939 if (need_new_binding)
941 push_local_binding (name, x, 0);
942 /* Because push_local_binding will hook X on to the
943 current_binding_level's name list, we don't want to
944 do that again below. */
945 need_new_binding = 0;
948 /* If this is a TYPE_DECL, push it into the type value slot. */
949 if (TREE_CODE (x) == TYPE_DECL)
950 set_identifier_type_value (name, x);
952 /* Clear out any TYPE_DECL shadowed by a namespace so that
953 we won't think this is a type. The C struct hack doesn't
954 go through namespaces. */
955 if (TREE_CODE (x) == NAMESPACE_DECL)
956 set_identifier_type_value (name, NULL_TREE);
963 && TREE_CODE (oldlocal) == VAR_DECL
964 && DECL_DEAD_FOR_LOCAL (oldlocal))
965 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
967 if (oldlocal == NULL_TREE)
968 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
971 /* If this is an extern function declaration, see if we
972 have a global definition or declaration for the function. */
973 if (oldlocal == NULL_TREE
975 && oldglobal != NULL_TREE
976 && TREE_CODE (x) == FUNCTION_DECL
977 && TREE_CODE (oldglobal) == FUNCTION_DECL)
979 /* We have one. Their types must agree. */
980 if (decls_match (x, oldglobal))
984 warning (0, "extern declaration of %q#D doesn't match", x);
985 warning (0, "global declaration %q+#D", oldglobal);
988 /* If we have a local external declaration,
989 and no file-scope declaration has yet been seen,
990 then if we later have a file-scope decl it must not be static. */
991 if (oldlocal == NULL_TREE
992 && oldglobal == NULL_TREE
995 TREE_PUBLIC (name) = 1;
997 /* Warn if shadowing an argument at the top level of the body. */
998 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
999 /* Inline decls shadow nothing. */
1000 && !DECL_FROM_INLINE (x)
1001 && TREE_CODE (oldlocal) == PARM_DECL
1002 /* Don't check the `this' parameter. */
1003 && !DECL_ARTIFICIAL (oldlocal))
1007 /* Don't complain if it's from an enclosing function. */
1008 if (DECL_CONTEXT (oldlocal) == current_function_decl
1009 && TREE_CODE (x) != PARM_DECL)
1011 /* Go to where the parms should be and see if we find
1013 struct cp_binding_level *b = current_binding_level->level_chain;
1015 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1016 /* Skip the ctor/dtor cleanup level. */
1020 if (b->kind == sk_function_parms)
1022 error ("declaration of %q#D shadows a parameter", x);
1027 if (warn_shadow && !err)
1029 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
1030 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1034 /* Maybe warn if shadowing something else. */
1035 else if (warn_shadow && !DECL_EXTERNAL (x)
1036 /* No shadow warnings for internally generated vars. */
1037 && ! DECL_ARTIFICIAL (x)
1038 /* No shadow warnings for vars made for inlining. */
1039 && ! DECL_FROM_INLINE (x))
1043 if (current_class_ptr)
1044 member = lookup_member (current_class_type,
1047 /*want_type=*/false);
1051 if (member && !TREE_STATIC (member))
1053 /* Location of previous decl is not useful in this case. */
1054 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1057 else if (oldlocal != NULL_TREE
1058 && TREE_CODE (oldlocal) == VAR_DECL)
1060 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1061 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1063 else if (oldglobal != NULL_TREE
1064 && TREE_CODE (oldglobal) == VAR_DECL)
1065 /* XXX shadow warnings in outer-more namespaces */
1067 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1069 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1074 if (TREE_CODE (x) == VAR_DECL)
1075 maybe_register_incomplete_var (x);
1078 if (need_new_binding)
1079 add_decl_to_level (x,
1080 DECL_NAMESPACE_SCOPE_P (x)
1081 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1082 : current_binding_level);
1084 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1087 /* Record a decl-node X as belonging to the current lexical scope. */
1092 return pushdecl_maybe_friend (x, false);
1095 /* Enter DECL into the symbol table, if that's appropriate. Returns
1096 DECL, or a modified version thereof. */
1099 maybe_push_decl (tree decl)
1101 tree type = TREE_TYPE (decl);
1103 /* Add this decl to the current binding level, but not if it comes
1104 from another scope, e.g. a static member variable. TEM may equal
1105 DECL or it may be a previous decl of the same name. */
1106 if (decl == error_mark_node
1107 || (TREE_CODE (decl) != PARM_DECL
1108 && DECL_CONTEXT (decl) != NULL_TREE
1109 /* Definitions of namespace members outside their namespace are
1111 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1112 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1113 || TREE_CODE (type) == UNKNOWN_TYPE
1114 /* The declaration of a template specialization does not affect
1115 the functions available for overload resolution, so we do not
1117 || (TREE_CODE (decl) == FUNCTION_DECL
1118 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1121 return pushdecl (decl);
1124 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1125 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1126 doesn't really belong to this binding level, that it got here
1127 through a using-declaration. */
1130 push_local_binding (tree id, tree decl, int flags)
1132 struct cp_binding_level *b;
1134 /* Skip over any local classes. This makes sense if we call
1135 push_local_binding with a friend decl of a local class. */
1136 b = innermost_nonclass_level ();
1138 if (lookup_name_innermost_nonclass_level (id))
1140 /* Supplement the existing binding. */
1141 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1142 /* It didn't work. Something else must be bound at this
1143 level. Do not add DECL to the list of things to pop
1148 /* Create a new binding. */
1149 push_binding (id, decl, b);
1151 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1152 /* We must put the OVERLOAD into a TREE_LIST since the
1153 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1154 decls that got here through a using-declaration. */
1155 decl = build_tree_list (NULL_TREE, decl);
1157 /* And put DECL on the list of things declared by the current
1159 add_decl_to_level (decl, b);
1162 /* Check to see whether or not DECL is a variable that would have been
1163 in scope under the ARM, but is not in scope under the ANSI/ISO
1164 standard. If so, issue an error message. If name lookup would
1165 work in both cases, but return a different result, this function
1166 returns the result of ANSI/ISO lookup. Otherwise, it returns
1170 check_for_out_of_scope_variable (tree decl)
1174 /* We only care about out of scope variables. */
1175 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1178 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1179 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1180 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1181 && DECL_DEAD_FOR_LOCAL (shadowed))
1182 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1183 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1185 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1188 if (!DECL_ERROR_REPORTED (decl))
1190 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1191 warning (0, " matches this %q+D under ISO standard rules",
1193 warning (0, " matches this %q+D under old rules", decl);
1194 DECL_ERROR_REPORTED (decl) = 1;
1199 /* If we have already complained about this declaration, there's no
1200 need to do it again. */
1201 if (DECL_ERROR_REPORTED (decl))
1204 DECL_ERROR_REPORTED (decl) = 1;
1206 if (TREE_TYPE (decl) == error_mark_node)
1209 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1211 error ("name lookup of %qD changed for ISO %<for%> scoping",
1213 error (" cannot use obsolete binding at %q+D because "
1214 "it has a destructor", decl);
1215 return error_mark_node;
1219 permerror ("name lookup of %qD changed for ISO %<for%> scoping",
1221 if (flag_permissive)
1222 permerror (" using obsolete binding at %q+D", decl);
1228 inform ("(if you use %<-fpermissive%> G++ will accept your code)");
1237 /* true means unconditionally make a BLOCK for the next level pushed. */
1239 static bool keep_next_level_flag;
1241 static int binding_depth = 0;
1242 static int is_class_level = 0;
1249 for (i = 0; i < depth * 2; i++)
1253 /* Return a string describing the kind of SCOPE we have. */
1255 cxx_scope_descriptor (cxx_scope *scope)
1257 /* The order of this table must match the "scope_kind"
1259 static const char* scope_kind_names[] = {
1265 "function-parameter-scope",
1268 "template-parameter-scope",
1269 "template-explicit-spec-scope"
1271 const scope_kind kind = scope->explicit_spec_p
1272 ? sk_template_spec : scope->kind;
1274 return scope_kind_names[kind];
1277 /* Output a debugging information about SCOPE when performing
1280 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1282 const char *desc = cxx_scope_descriptor (scope);
1283 if (scope->this_entity)
1284 verbatim ("%s %s(%E) %p %d\n", action, desc,
1285 scope->this_entity, (void *) scope, line);
1287 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1290 /* Return the estimated initial size of the hashtable of a NAMESPACE
1293 static inline size_t
1294 namespace_scope_ht_size (tree ns)
1296 tree name = DECL_NAME (ns);
1298 return name == std_identifier
1299 ? NAMESPACE_STD_HT_SIZE
1300 : (name == global_scope_name
1301 ? GLOBAL_SCOPE_HT_SIZE
1302 : NAMESPACE_ORDINARY_HT_SIZE);
1305 /* A chain of binding_level structures awaiting reuse. */
1307 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1309 /* Insert SCOPE as the innermost binding level. */
1312 push_binding_level (struct cp_binding_level *scope)
1314 /* Add it to the front of currently active scopes stack. */
1315 scope->level_chain = current_binding_level;
1316 current_binding_level = scope;
1317 keep_next_level_flag = false;
1319 if (ENABLE_SCOPE_CHECKING)
1321 scope->binding_depth = binding_depth;
1322 indent (binding_depth);
1323 cxx_scope_debug (scope, input_line, "push");
1329 /* Create a new KIND scope and make it the top of the active scopes stack.
1330 ENTITY is the scope of the associated C++ entity (namespace, class,
1331 function); it is NULL otherwise. */
1334 begin_scope (scope_kind kind, tree entity)
1338 /* Reuse or create a struct for this binding level. */
1339 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1341 scope = free_binding_level;
1342 memset (scope, 0, sizeof (cxx_scope));
1343 free_binding_level = scope->level_chain;
1346 scope = GGC_CNEW (cxx_scope);
1348 scope->this_entity = entity;
1349 scope->more_cleanups_ok = true;
1356 case sk_template_spec:
1357 scope->explicit_spec_p = true;
1358 kind = sk_template_parms;
1360 case sk_template_parms:
1366 case sk_function_parms:
1368 scope->keep = keep_next_level_flag;
1372 NAMESPACE_LEVEL (entity) = scope;
1373 scope->static_decls =
1374 VEC_alloc (tree, gc,
1375 DECL_NAME (entity) == std_identifier
1376 || DECL_NAME (entity) == global_scope_name
1381 /* Should not happen. */
1387 push_binding_level (scope);
1392 /* We're about to leave current scope. Pop the top of the stack of
1393 currently active scopes. Return the enclosing scope, now active. */
1398 cxx_scope *scope = current_binding_level;
1400 if (scope->kind == sk_namespace && class_binding_level)
1401 current_binding_level = class_binding_level;
1403 /* We cannot leave a scope, if there are none left. */
1404 if (NAMESPACE_LEVEL (global_namespace))
1405 gcc_assert (!global_scope_p (scope));
1407 if (ENABLE_SCOPE_CHECKING)
1409 indent (--binding_depth);
1410 cxx_scope_debug (scope, input_line, "leave");
1411 if (is_class_level != (scope == class_binding_level))
1413 indent (binding_depth);
1414 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1419 /* Move one nesting level up. */
1420 current_binding_level = scope->level_chain;
1422 /* Namespace-scopes are left most probably temporarily, not
1423 completely; they can be reopened later, e.g. in namespace-extension
1424 or any name binding activity that requires us to resume a
1425 namespace. For classes, we cache some binding levels. For other
1426 scopes, we just make the structure available for reuse. */
1427 if (scope->kind != sk_namespace
1428 && scope->kind != sk_class)
1430 scope->level_chain = free_binding_level;
1431 gcc_assert (!ENABLE_SCOPE_CHECKING
1432 || scope->binding_depth == binding_depth);
1433 free_binding_level = scope;
1436 /* Find the innermost enclosing class scope, and reset
1437 CLASS_BINDING_LEVEL appropriately. */
1438 if (scope->kind == sk_class)
1440 class_binding_level = NULL;
1441 for (scope = current_binding_level; scope; scope = scope->level_chain)
1442 if (scope->kind == sk_class)
1444 class_binding_level = scope;
1449 return current_binding_level;
1453 resume_scope (struct cp_binding_level* b)
1455 /* Resuming binding levels is meant only for namespaces,
1456 and those cannot nest into classes. */
1457 gcc_assert (!class_binding_level);
1458 /* Also, resuming a non-directly nested namespace is a no-no. */
1459 gcc_assert (b->level_chain == current_binding_level);
1460 current_binding_level = b;
1461 if (ENABLE_SCOPE_CHECKING)
1463 b->binding_depth = binding_depth;
1464 indent (binding_depth);
1465 cxx_scope_debug (b, input_line, "resume");
1471 /* Return the innermost binding level that is not for a class scope. */
1474 innermost_nonclass_level (void)
1478 b = current_binding_level;
1479 while (b->kind == sk_class)
1485 /* We're defining an object of type TYPE. If it needs a cleanup, but
1486 we're not allowed to add any more objects with cleanups to the current
1487 scope, create a new binding level. */
1490 maybe_push_cleanup_level (tree type)
1492 if (type != error_mark_node
1493 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1494 && current_binding_level->more_cleanups_ok == 0)
1496 begin_scope (sk_cleanup, NULL);
1497 current_binding_level->statement_list = push_stmt_list ();
1501 /* Nonzero if we are currently in the global binding level. */
1504 global_bindings_p (void)
1506 return global_scope_p (current_binding_level);
1509 /* True if we are currently in a toplevel binding level. This
1510 means either the global binding level or a namespace in a toplevel
1511 binding level. Since there are no non-toplevel namespace levels,
1512 this really means any namespace or template parameter level. We
1513 also include a class whose context is toplevel. */
1516 toplevel_bindings_p (void)
1518 struct cp_binding_level *b = innermost_nonclass_level ();
1520 return b->kind == sk_namespace || b->kind == sk_template_parms;
1523 /* True if this is a namespace scope, or if we are defining a class
1524 which is itself at namespace scope, or whose enclosing class is
1525 such a class, etc. */
1528 namespace_bindings_p (void)
1530 struct cp_binding_level *b = innermost_nonclass_level ();
1532 return b->kind == sk_namespace;
1535 /* True if the current level needs to have a BLOCK made. */
1540 return (current_binding_level->blocks != NULL_TREE
1541 || current_binding_level->keep
1542 || current_binding_level->kind == sk_cleanup
1543 || current_binding_level->names != NULL_TREE);
1546 /* Returns the kind of the innermost scope. */
1549 innermost_scope_kind (void)
1551 return current_binding_level->kind;
1554 /* Returns true if this scope was created to store template parameters. */
1557 template_parm_scope_p (void)
1559 return innermost_scope_kind () == sk_template_parms;
1562 /* If KEEP is true, make a BLOCK node for the next binding level,
1563 unconditionally. Otherwise, use the normal logic to decide whether
1564 or not to create a BLOCK. */
1567 keep_next_level (bool keep)
1569 keep_next_level_flag = keep;
1572 /* Return the list of declarations of the current level.
1573 Note that this list is in reverse order unless/until
1574 you nreverse it; and when you do nreverse it, you must
1575 store the result back using `storedecls' or you will lose. */
1580 return current_binding_level->names;
1583 /* For debugging. */
1584 static int no_print_functions = 0;
1585 static int no_print_builtins = 0;
1588 print_binding_level (struct cp_binding_level* lvl)
1592 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1593 if (lvl->more_cleanups_ok)
1594 fprintf (stderr, " more-cleanups-ok");
1595 if (lvl->have_cleanups)
1596 fprintf (stderr, " have-cleanups");
1597 fprintf (stderr, "\n");
1600 fprintf (stderr, " names:\t");
1601 /* We can probably fit 3 names to a line? */
1602 for (t = lvl->names; t; t = TREE_CHAIN (t))
1604 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1606 if (no_print_builtins
1607 && (TREE_CODE (t) == TYPE_DECL)
1608 && DECL_IS_BUILTIN (t))
1611 /* Function decls tend to have longer names. */
1612 if (TREE_CODE (t) == FUNCTION_DECL)
1619 fprintf (stderr, "\n\t");
1622 print_node_brief (stderr, "", t, 0);
1623 if (t == error_mark_node)
1627 fprintf (stderr, "\n");
1629 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1632 cp_class_binding *b;
1633 fprintf (stderr, " class-shadowed:");
1635 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1637 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1638 fprintf (stderr, "\n");
1640 if (lvl->type_shadowed)
1642 fprintf (stderr, " type-shadowed:");
1643 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1645 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1647 fprintf (stderr, "\n");
1652 print_other_binding_stack (struct cp_binding_level *stack)
1654 struct cp_binding_level *level;
1655 for (level = stack; !global_scope_p (level); level = level->level_chain)
1657 fprintf (stderr, "binding level %p\n", (void *) level);
1658 print_binding_level (level);
1663 print_binding_stack (void)
1665 struct cp_binding_level *b;
1666 fprintf (stderr, "current_binding_level=%p\n"
1667 "class_binding_level=%p\n"
1668 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1669 (void *) current_binding_level, (void *) class_binding_level,
1670 (void *) NAMESPACE_LEVEL (global_namespace));
1671 if (class_binding_level)
1673 for (b = class_binding_level; b; b = b->level_chain)
1674 if (b == current_binding_level)
1677 b = class_binding_level;
1679 b = current_binding_level;
1682 b = current_binding_level;
1683 print_other_binding_stack (b);
1684 fprintf (stderr, "global:\n");
1685 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1688 /* Return the type associated with id. */
1691 identifier_type_value (tree id)
1693 timevar_push (TV_NAME_LOOKUP);
1694 /* There is no type with that name, anywhere. */
1695 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1697 /* This is not the type marker, but the real thing. */
1698 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1699 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1700 /* Have to search for it. It must be on the global level, now.
1701 Ask lookup_name not to return non-types. */
1702 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1704 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1708 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1709 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1712 identifier_global_value (tree t)
1714 return IDENTIFIER_GLOBAL_VALUE (t);
1717 /* Push a definition of struct, union or enum tag named ID. into
1718 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1719 the tag ID is not already defined. */
1722 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1726 if (b->kind != sk_namespace)
1728 /* Shadow the marker, not the real thing, so that the marker
1729 gets restored later. */
1730 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1732 = tree_cons (id, old_type_value, b->type_shadowed);
1733 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1734 TREE_TYPE (b->type_shadowed) = type;
1738 cxx_binding *binding =
1739 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1742 supplement_binding (binding, decl);
1744 binding->value = decl;
1746 /* Store marker instead of real type. */
1747 type = global_type_node;
1749 SET_IDENTIFIER_TYPE_VALUE (id, type);
1752 /* As set_identifier_type_value_with_scope, but using
1753 current_binding_level. */
1756 set_identifier_type_value (tree id, tree decl)
1758 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1761 /* Return the name for the constructor (or destructor) for the
1762 specified class TYPE. When given a template, this routine doesn't
1763 lose the specialization. */
1766 constructor_name_full (tree type)
1768 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1771 /* Return the name for the constructor (or destructor) for the
1772 specified class. When given a template, return the plain
1773 unspecialized name. */
1776 constructor_name (tree type)
1779 name = constructor_name_full (type);
1780 if (IDENTIFIER_TEMPLATE (name))
1781 name = IDENTIFIER_TEMPLATE (name);
1785 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1786 which must be a class type. */
1789 constructor_name_p (tree name, tree type)
1793 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1798 if (TREE_CODE (name) != IDENTIFIER_NODE)
1801 ctor_name = constructor_name_full (type);
1802 if (name == ctor_name)
1804 if (IDENTIFIER_TEMPLATE (ctor_name)
1805 && name == IDENTIFIER_TEMPLATE (ctor_name))
1810 /* Counter used to create anonymous type names. */
1812 static GTY(()) int anon_cnt;
1814 /* Return an IDENTIFIER which can be used as a name for
1815 anonymous structs and unions. */
1818 make_anon_name (void)
1822 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1823 return get_identifier (buf);
1826 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1828 static inline cxx_binding *
1829 find_binding (cxx_scope *scope, cxx_binding *binding)
1831 timevar_push (TV_NAME_LOOKUP);
1833 for (; binding != NULL; binding = binding->previous)
1834 if (binding->scope == scope)
1835 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1837 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1840 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1842 static inline cxx_binding *
1843 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1845 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1848 /* Fold-in case where NAME is used only once. */
1849 if (scope == b->scope && b->previous == NULL)
1851 return find_binding (scope, b);
1856 /* Always returns a binding for name in scope. If no binding is
1857 found, make a new one. */
1859 static cxx_binding *
1860 binding_for_name (cxx_scope *scope, tree name)
1862 cxx_binding *result;
1864 result = cxx_scope_find_binding_for_name (scope, name);
1867 /* Not found, make a new one. */
1868 result = cxx_binding_make (NULL, NULL);
1869 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1870 result->scope = scope;
1871 result->is_local = false;
1872 result->value_is_inherited = false;
1873 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1877 /* Walk through the bindings associated to the name of FUNCTION,
1878 and return the first binding that declares a function with a
1879 "C" linkage specification, a.k.a 'extern "C"'.
1880 This function looks for the binding, regardless of which scope it
1881 has been defined in. It basically looks in all the known scopes.
1882 Note that this function does not lookup for bindings of builtin functions
1883 or for functions declared in system headers. */
1885 lookup_extern_c_fun_binding_in_all_ns (tree function)
1890 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1892 name = DECL_NAME (function);
1893 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1895 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1897 iter = iter->previous)
1900 && TREE_CODE (iter->value) == FUNCTION_DECL
1901 && DECL_EXTERN_C_P (iter->value)
1902 && !DECL_ARTIFICIAL (iter->value))
1910 /* Insert another USING_DECL into the current binding level, returning
1911 this declaration. If this is a redeclaration, do nothing, and
1912 return NULL_TREE if this not in namespace scope (in namespace
1913 scope, a using decl might extend any previous bindings). */
1916 push_using_decl (tree scope, tree name)
1920 timevar_push (TV_NAME_LOOKUP);
1921 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1922 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1923 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1924 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1927 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1928 namespace_bindings_p () ? decl : NULL_TREE);
1929 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1930 USING_DECL_SCOPE (decl) = scope;
1931 TREE_CHAIN (decl) = current_binding_level->usings;
1932 current_binding_level->usings = decl;
1933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1936 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1937 caller to set DECL_CONTEXT properly. */
1940 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1942 struct cp_binding_level *b;
1943 tree function_decl = current_function_decl;
1945 timevar_push (TV_NAME_LOOKUP);
1946 current_function_decl = NULL_TREE;
1947 if (level->kind == sk_class)
1949 b = class_binding_level;
1950 class_binding_level = level;
1951 pushdecl_class_level (x);
1952 class_binding_level = b;
1956 b = current_binding_level;
1957 current_binding_level = level;
1958 x = pushdecl_maybe_friend (x, is_friend);
1959 current_binding_level = b;
1961 current_function_decl = function_decl;
1962 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1965 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1966 other definitions already in place. We get around this by making
1967 the value of the identifier point to a list of all the things that
1968 want to be referenced by that name. It is then up to the users of
1969 that name to decide what to do with that list.
1971 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1972 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1974 FLAGS is a bitwise-or of the following values:
1975 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1977 PUSH_USING: DECL is being pushed as the result of a using
1980 IS_FRIEND is true if this is a friend declaration.
1982 The value returned may be a previous declaration if we guessed wrong
1983 about what language DECL should belong to (C or C++). Otherwise,
1984 it's always DECL (and never something that's not a _DECL). */
1987 push_overloaded_decl (tree decl, int flags, bool is_friend)
1989 tree name = DECL_NAME (decl);
1992 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1994 timevar_push (TV_NAME_LOOKUP);
1996 old = namespace_binding (name, DECL_CONTEXT (decl));
1998 old = lookup_name_innermost_nonclass_level (name);
2002 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2004 tree t = TREE_TYPE (old);
2005 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2006 && (! DECL_IN_SYSTEM_HEADER (decl)
2007 || ! DECL_IN_SYSTEM_HEADER (old)))
2008 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2011 else if (is_overloaded_fn (old))
2015 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2017 tree fn = OVL_CURRENT (tmp);
2020 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2021 && !(flags & PUSH_USING)
2022 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2023 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2024 && ! decls_match (fn, decl))
2025 error ("%q#D conflicts with previous using declaration %q#D",
2028 dup = duplicate_decls (decl, fn, is_friend);
2029 /* If DECL was a redeclaration of FN -- even an invalid
2030 one -- pass that information along to our caller. */
2031 if (dup == fn || dup == error_mark_node)
2032 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2035 /* We don't overload implicit built-ins. duplicate_decls()
2036 may fail to merge the decls if the new decl is e.g. a
2037 template function. */
2038 if (TREE_CODE (old) == FUNCTION_DECL
2039 && DECL_ANTICIPATED (old)
2040 && !DECL_HIDDEN_FRIEND_P (old))
2043 else if (old == error_mark_node)
2044 /* Ignore the undefined symbol marker. */
2048 error ("previous non-function declaration %q+#D", old);
2049 error ("conflicts with function declaration %q#D", decl);
2050 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2054 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2055 /* If it's a using declaration, we always need to build an OVERLOAD,
2056 because it's the only way to remember that the declaration comes
2057 from 'using', and have the lookup behave correctly. */
2058 || (flags & PUSH_USING))
2060 if (old && TREE_CODE (old) != OVERLOAD)
2061 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2063 new_binding = ovl_cons (decl, old);
2064 if (flags & PUSH_USING)
2065 OVL_USED (new_binding) = 1;
2068 /* NAME is not ambiguous. */
2072 set_namespace_binding (name, current_namespace, new_binding);
2075 /* We only create an OVERLOAD if there was a previous binding at
2076 this level, or if decl is a template. In the former case, we
2077 need to remove the old binding and replace it with the new
2078 binding. We must also run through the NAMES on the binding
2079 level where the name was bound to update the chain. */
2081 if (TREE_CODE (new_binding) == OVERLOAD && old)
2085 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2087 d = &TREE_CHAIN (*d))
2089 || (TREE_CODE (*d) == TREE_LIST
2090 && TREE_VALUE (*d) == old))
2092 if (TREE_CODE (*d) == TREE_LIST)
2093 /* Just replace the old binding with the new. */
2094 TREE_VALUE (*d) = new_binding;
2096 /* Build a TREE_LIST to wrap the OVERLOAD. */
2097 *d = tree_cons (NULL_TREE, new_binding,
2100 /* And update the cxx_binding node. */
2101 IDENTIFIER_BINDING (name)->value = new_binding;
2102 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2105 /* We should always find a previous binding in this case. */
2109 /* Install the new binding. */
2110 push_local_binding (name, new_binding, flags);
2113 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2116 /* Check a non-member using-declaration. Return the name and scope
2117 being used, and the USING_DECL, or NULL_TREE on failure. */
2120 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2122 /* [namespace.udecl]
2123 A using-declaration for a class member shall be a
2124 member-declaration. */
2127 error ("%qT is not a namespace", scope);
2130 else if (scope == error_mark_node)
2133 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2136 A using-declaration shall not name a template-id. */
2137 error ("a using-declaration cannot specify a template-id. "
2138 "Try %<using %D%>", name);
2142 if (TREE_CODE (decl) == NAMESPACE_DECL)
2144 error ("namespace %qD not allowed in using-declaration", decl);
2148 if (TREE_CODE (decl) == SCOPE_REF)
2150 /* It's a nested name with template parameter dependent scope.
2151 This can only be using-declaration for class member. */
2152 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2156 if (is_overloaded_fn (decl))
2157 decl = get_first_fn (decl);
2159 gcc_assert (DECL_P (decl));
2161 /* Make a USING_DECL. */
2162 return push_using_decl (scope, name);
2165 /* Process local and global using-declarations. */
2168 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2169 tree *newval, tree *newtype)
2171 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2173 *newval = *newtype = NULL_TREE;
2174 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2178 if (!decls.value && !decls.type)
2180 error ("%qD not declared", name);
2184 /* Shift the old and new bindings around so we're comparing class and
2185 enumeration names to each other. */
2186 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2192 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2194 decls.type = decls.value;
2195 decls.value = NULL_TREE;
2198 /* It is impossible to overload a built-in function; any explicit
2199 declaration eliminates the built-in declaration. So, if OLDVAL
2200 is a built-in, then we can just pretend it isn't there. */
2202 && TREE_CODE (oldval) == FUNCTION_DECL
2203 && DECL_ANTICIPATED (oldval)
2204 && !DECL_HIDDEN_FRIEND_P (oldval))
2209 /* Check for using functions. */
2210 if (is_overloaded_fn (decls.value))
2214 if (oldval && !is_overloaded_fn (oldval))
2216 error ("%qD is already declared in this scope", name);
2221 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2223 tree new_fn = OVL_CURRENT (tmp);
2225 /* [namespace.udecl]
2227 If a function declaration in namespace scope or block
2228 scope has the same name and the same parameter types as a
2229 function introduced by a using declaration the program is
2231 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2233 tree old_fn = OVL_CURRENT (tmp1);
2235 if (new_fn == old_fn)
2236 /* The function already exists in the current namespace. */
2238 else if (OVL_USED (tmp1))
2239 continue; /* this is a using decl */
2240 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2241 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2243 gcc_assert (!DECL_ANTICIPATED (old_fn)
2244 || DECL_HIDDEN_FRIEND_P (old_fn));
2246 /* There was already a non-using declaration in
2247 this scope with the same parameter types. If both
2248 are the same extern "C" functions, that's ok. */
2249 if (decls_match (new_fn, old_fn))
2253 error ("%qD is already declared in this scope", name);
2259 /* If we broke out of the loop, there's no reason to add
2260 this function to the using declarations for this
2265 /* If we are adding to an existing OVERLOAD, then we no
2266 longer know the type of the set of functions. */
2267 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2268 TREE_TYPE (*newval) = unknown_type_node;
2269 /* Add this new function to the set. */
2270 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2271 /* If there is only one function, then we use its type. (A
2272 using-declaration naming a single function can be used in
2273 contexts where overload resolution cannot be
2275 if (TREE_CODE (*newval) != OVERLOAD)
2277 *newval = ovl_cons (*newval, NULL_TREE);
2278 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2280 OVL_USED (*newval) = 1;
2285 *newval = decls.value;
2286 if (oldval && !decls_match (*newval, oldval))
2287 error ("%qD is already declared in this scope", name);
2293 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2295 error ("reference to %qD is ambiguous", name);
2296 print_candidates (decls.type);
2300 *newtype = decls.type;
2301 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2302 error ("%qD is already declared in this scope", name);
2305 /* If *newval is empty, shift any class or enumeration name down. */
2309 *newtype = NULL_TREE;
2313 /* Process a using-declaration at function scope. */
2316 do_local_using_decl (tree decl, tree scope, tree name)
2318 tree oldval, oldtype, newval, newtype;
2319 tree orig_decl = decl;
2321 decl = validate_nonmember_using_decl (decl, scope, name);
2322 if (decl == NULL_TREE)
2325 if (building_stmt_tree ()
2326 && at_function_scope_p ())
2327 add_decl_expr (decl);
2329 oldval = lookup_name_innermost_nonclass_level (name);
2330 oldtype = lookup_type_current_level (name);
2332 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2336 if (is_overloaded_fn (newval))
2340 /* We only need to push declarations for those functions
2341 that were not already bound in the current level.
2342 The old value might be NULL_TREE, it might be a single
2343 function, or an OVERLOAD. */
2344 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2345 term = OVL_FUNCTION (oldval);
2348 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2350 push_overloaded_decl (OVL_CURRENT (fn),
2351 PUSH_LOCAL | PUSH_USING,
2355 push_local_binding (name, newval, PUSH_USING);
2359 push_local_binding (name, newtype, PUSH_USING);
2360 set_identifier_type_value (name, newtype);
2363 /* Emit debug info. */
2364 if (!processing_template_decl)
2365 cp_emit_debug_info_for_using (orig_decl, current_scope());
2368 /* Returns true if ROOT (a namespace, class, or function) encloses
2369 CHILD. CHILD may be either a class type or a namespace. */
2372 is_ancestor (tree root, tree child)
2374 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2375 || TREE_CODE (root) == FUNCTION_DECL
2376 || CLASS_TYPE_P (root)));
2377 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2378 || CLASS_TYPE_P (child)));
2380 /* The global namespace encloses everything. */
2381 if (root == global_namespace)
2386 /* If we've run out of scopes, stop. */
2389 /* If we've reached the ROOT, it encloses CHILD. */
2392 /* Go out one level. */
2394 child = TYPE_NAME (child);
2395 child = DECL_CONTEXT (child);
2399 /* Enter the class or namespace scope indicated by T suitable for name
2400 lookup. T can be arbitrary scope, not necessary nested inside the
2401 current scope. Returns a non-null scope to pop iff pop_scope
2402 should be called later to exit this scope. */
2407 if (TREE_CODE (t) == NAMESPACE_DECL)
2408 push_decl_namespace (t);
2409 else if (CLASS_TYPE_P (t))
2411 if (!at_class_scope_p ()
2412 || !same_type_p (current_class_type, t))
2413 push_nested_class (t);
2415 /* T is the same as the current scope. There is therefore no
2416 need to re-enter the scope. Since we are not actually
2417 pushing a new scope, our caller should not call
2425 /* Leave scope pushed by push_scope. */
2430 if (TREE_CODE (t) == NAMESPACE_DECL)
2431 pop_decl_namespace ();
2432 else if CLASS_TYPE_P (t)
2433 pop_nested_class ();
2436 /* Subroutine of push_inner_scope. */
2439 push_inner_scope_r (tree outer, tree inner)
2444 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2447 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2449 push_inner_scope_r (outer, prev);
2450 if (TREE_CODE (inner) == NAMESPACE_DECL)
2452 struct cp_binding_level *save_template_parm = 0;
2453 /* Temporary take out template parameter scopes. They are saved
2454 in reversed order in save_template_parm. */
2455 while (current_binding_level->kind == sk_template_parms)
2457 struct cp_binding_level *b = current_binding_level;
2458 current_binding_level = b->level_chain;
2459 b->level_chain = save_template_parm;
2460 save_template_parm = b;
2463 resume_scope (NAMESPACE_LEVEL (inner));
2464 current_namespace = inner;
2466 /* Restore template parameter scopes. */
2467 while (save_template_parm)
2469 struct cp_binding_level *b = save_template_parm;
2470 save_template_parm = b->level_chain;
2471 b->level_chain = current_binding_level;
2472 current_binding_level = b;
2479 /* Enter the scope INNER from current scope. INNER must be a scope
2480 nested inside current scope. This works with both name lookup and
2481 pushing name into scope. In case a template parameter scope is present,
2482 namespace is pushed under the template parameter scope according to
2483 name lookup rule in 14.6.1/6.
2485 Return the former current scope suitable for pop_inner_scope. */
2488 push_inner_scope (tree inner)
2490 tree outer = current_scope ();
2492 outer = current_namespace;
2494 push_inner_scope_r (outer, inner);
2498 /* Exit the current scope INNER back to scope OUTER. */
2501 pop_inner_scope (tree outer, tree inner)
2504 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2507 while (outer != inner)
2509 if (TREE_CODE (inner) == NAMESPACE_DECL)
2511 struct cp_binding_level *save_template_parm = 0;
2512 /* Temporary take out template parameter scopes. They are saved
2513 in reversed order in save_template_parm. */
2514 while (current_binding_level->kind == sk_template_parms)
2516 struct cp_binding_level *b = current_binding_level;
2517 current_binding_level = b->level_chain;
2518 b->level_chain = save_template_parm;
2519 save_template_parm = b;
2524 /* Restore template parameter scopes. */
2525 while (save_template_parm)
2527 struct cp_binding_level *b = save_template_parm;
2528 save_template_parm = b->level_chain;
2529 b->level_chain = current_binding_level;
2530 current_binding_level = b;
2536 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2540 /* Do a pushlevel for class declarations. */
2543 pushlevel_class (void)
2545 if (ENABLE_SCOPE_CHECKING)
2548 class_binding_level = begin_scope (sk_class, current_class_type);
2551 /* ...and a poplevel for class declarations. */
2554 poplevel_class (void)
2556 struct cp_binding_level *level = class_binding_level;
2557 cp_class_binding *cb;
2561 timevar_push (TV_NAME_LOOKUP);
2562 gcc_assert (level != 0);
2564 /* If we're leaving a toplevel class, cache its binding level. */
2565 if (current_class_depth == 1)
2566 previous_class_level = level;
2567 for (shadowed = level->type_shadowed;
2569 shadowed = TREE_CHAIN (shadowed))
2570 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2572 /* Remove the bindings for all of the class-level declarations. */
2573 if (level->class_shadowed)
2576 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2578 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2579 ggc_free (level->class_shadowed);
2580 level->class_shadowed = NULL;
2583 /* Now, pop out of the binding level which we created up in the
2584 `pushlevel_class' routine. */
2585 if (ENABLE_SCOPE_CHECKING)
2589 timevar_pop (TV_NAME_LOOKUP);
2592 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2593 appropriate. DECL is the value to which a name has just been
2594 bound. CLASS_TYPE is the class in which the lookup occurred. */
2597 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2600 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2604 if (TREE_CODE (decl) == OVERLOAD)
2605 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2608 gcc_assert (DECL_P (decl));
2609 context = context_for_name_lookup (decl);
2612 if (is_properly_derived_from (class_type, context))
2613 INHERITED_VALUE_BINDING_P (binding) = 1;
2615 INHERITED_VALUE_BINDING_P (binding) = 0;
2617 else if (binding->value == decl)
2618 /* We only encounter a TREE_LIST when there is an ambiguity in the
2619 base classes. Such an ambiguity can be overridden by a
2620 definition in this class. */
2621 INHERITED_VALUE_BINDING_P (binding) = 1;
2623 INHERITED_VALUE_BINDING_P (binding) = 0;
2626 /* Make the declaration of X appear in CLASS scope. */
2629 pushdecl_class_level (tree x)
2632 bool is_valid = true;
2634 timevar_push (TV_NAME_LOOKUP);
2635 /* Get the name of X. */
2636 if (TREE_CODE (x) == OVERLOAD)
2637 name = DECL_NAME (get_first_fn (x));
2639 name = DECL_NAME (x);
2643 is_valid = push_class_level_binding (name, x);
2644 if (TREE_CODE (x) == TYPE_DECL)
2645 set_identifier_type_value (name, x);
2647 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2649 /* If X is an anonymous aggregate, all of its members are
2650 treated as if they were members of the class containing the
2651 aggregate, for naming purposes. */
2654 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2656 location_t save_location = input_location;
2657 input_location = DECL_SOURCE_LOCATION (f);
2658 if (!pushdecl_class_level (f))
2660 input_location = save_location;
2663 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2666 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2667 scope. If the value returned is non-NULL, and the PREVIOUS field
2668 is not set, callers must set the PREVIOUS field explicitly. */
2670 static cxx_binding *
2671 get_class_binding (tree name, cxx_scope *scope)
2676 cxx_binding *binding;
2678 class_type = scope->this_entity;
2680 /* Get the type binding. */
2681 type_binding = lookup_member (class_type, name,
2682 /*protect=*/2, /*want_type=*/true);
2683 /* Get the value binding. */
2684 value_binding = lookup_member (class_type, name,
2685 /*protect=*/2, /*want_type=*/false);
2688 && (TREE_CODE (value_binding) == TYPE_DECL
2689 || DECL_CLASS_TEMPLATE_P (value_binding)
2690 || (TREE_CODE (value_binding) == TREE_LIST
2691 && TREE_TYPE (value_binding) == error_mark_node
2692 && (TREE_CODE (TREE_VALUE (value_binding))
2694 /* We found a type binding, even when looking for a non-type
2695 binding. This means that we already processed this binding
2698 else if (value_binding)
2700 if (TREE_CODE (value_binding) == TREE_LIST
2701 && TREE_TYPE (value_binding) == error_mark_node)
2702 /* NAME is ambiguous. */
2704 else if (BASELINK_P (value_binding))
2705 /* NAME is some overloaded functions. */
2706 value_binding = BASELINK_FUNCTIONS (value_binding);
2709 /* If we found either a type binding or a value binding, create a
2710 new binding object. */
2711 if (type_binding || value_binding)
2713 binding = new_class_binding (name,
2717 /* This is a class-scope binding, not a block-scope binding. */
2718 LOCAL_BINDING_P (binding) = 0;
2719 set_inherited_value_binding_p (binding, value_binding, class_type);
2727 /* Make the declaration(s) of X appear in CLASS scope under the name
2728 NAME. Returns true if the binding is valid. */
2731 push_class_level_binding (tree name, tree x)
2733 cxx_binding *binding;
2737 timevar_push (TV_NAME_LOOKUP);
2738 /* The class_binding_level will be NULL if x is a template
2739 parameter name in a member template. */
2740 if (!class_binding_level)
2741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2743 if (name == error_mark_node)
2744 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2746 /* Check for invalid member names. */
2747 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2748 /* We could have been passed a tree list if this is an ambiguous
2749 declaration. If so, pull the declaration out because
2750 check_template_shadow will not handle a TREE_LIST. */
2751 if (TREE_CODE (decl) == TREE_LIST
2752 && TREE_TYPE (decl) == error_mark_node)
2753 decl = TREE_VALUE (decl);
2755 check_template_shadow (decl);
2759 If T is the name of a class, then each of the following shall
2760 have a name different from T:
2762 -- every static data member of class T;
2764 -- every member of class T that is itself a type;
2766 -- every enumerator of every member of class T that is an
2769 -- every member of every anonymous union that is a member of
2772 (Non-static data members were also forbidden to have the same
2773 name as T until TC1.) */
2774 if ((TREE_CODE (x) == VAR_DECL
2775 || TREE_CODE (x) == CONST_DECL
2776 || (TREE_CODE (x) == TYPE_DECL
2777 && !DECL_SELF_REFERENCE_P (x))
2778 /* A data member of an anonymous union. */
2779 || (TREE_CODE (x) == FIELD_DECL
2780 && DECL_CONTEXT (x) != current_class_type))
2781 && DECL_NAME (x) == constructor_name (current_class_type))
2783 tree scope = context_for_name_lookup (x);
2784 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2786 error ("%qD has the same name as the class in which it is "
2789 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2793 /* Get the current binding for NAME in this class, if any. */
2794 binding = IDENTIFIER_BINDING (name);
2795 if (!binding || binding->scope != class_binding_level)
2797 binding = get_class_binding (name, class_binding_level);
2798 /* If a new binding was created, put it at the front of the
2799 IDENTIFIER_BINDING list. */
2802 binding->previous = IDENTIFIER_BINDING (name);
2803 IDENTIFIER_BINDING (name) = binding;
2807 /* If there is already a binding, then we may need to update the
2809 if (binding && binding->value)
2811 tree bval = binding->value;
2812 tree old_decl = NULL_TREE;
2814 if (INHERITED_VALUE_BINDING_P (binding))
2816 /* If the old binding was from a base class, and was for a
2817 tag name, slide it over to make room for the new binding.
2818 The old binding is still visible if explicitly qualified
2819 with a class-key. */
2820 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2821 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2823 old_decl = binding->type;
2824 binding->type = bval;
2825 binding->value = NULL_TREE;
2826 INHERITED_VALUE_BINDING_P (binding) = 0;
2831 /* Any inherited type declaration is hidden by the type
2832 declaration in the derived class. */
2833 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2834 binding->type = NULL_TREE;
2837 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2839 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2840 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2841 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2843 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2844 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2846 if (old_decl && binding->scope == class_binding_level)
2849 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2850 here. This function is only used to register bindings
2851 from with the class definition itself. */
2852 INHERITED_VALUE_BINDING_P (binding) = 0;
2853 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2857 /* Note that we declared this value so that we can issue an error if
2858 this is an invalid redeclaration of a name already used for some
2860 note_name_declared_in_class (name, decl);
2862 /* If we didn't replace an existing binding, put the binding on the
2863 stack of bindings for the identifier, and update the shadowed
2865 if (binding && binding->scope == class_binding_level)
2866 /* Supplement the existing binding. */
2867 ok = supplement_binding (binding, decl);
2870 /* Create a new binding. */
2871 push_binding (name, decl, class_binding_level);
2875 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2878 /* Process "using SCOPE::NAME" in a class scope. Return the
2879 USING_DECL created. */
2882 do_class_using_decl (tree scope, tree name)
2884 /* The USING_DECL returned by this function. */
2886 /* The declaration (or declarations) name by this using
2887 declaration. NULL if we are in a template and cannot figure out
2888 what has been named. */
2890 /* True if SCOPE is a dependent type. */
2891 bool scope_dependent_p;
2892 /* True if SCOPE::NAME is dependent. */
2893 bool name_dependent_p;
2894 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2895 bool bases_dependent_p;
2900 if (name == error_mark_node)
2903 if (!scope || !TYPE_P (scope))
2905 error ("using-declaration for non-member at class scope");
2909 /* Make sure the name is not invalid */
2910 if (TREE_CODE (name) == BIT_NOT_EXPR)
2912 error ("%<%T::%D%> names destructor", scope, name);
2915 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2917 error ("%<%T::%D%> names constructor", scope, name);
2920 if (constructor_name_p (name, current_class_type))
2922 error ("%<%T::%D%> names constructor in %qT",
2923 scope, name, current_class_type);
2927 scope_dependent_p = dependent_type_p (scope);
2928 name_dependent_p = (scope_dependent_p
2929 || (IDENTIFIER_TYPENAME_P (name)
2930 && dependent_type_p (TREE_TYPE (name))));
2932 bases_dependent_p = false;
2933 if (processing_template_decl)
2934 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2935 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2937 if (dependent_type_p (TREE_TYPE (base_binfo)))
2939 bases_dependent_p = true;
2945 /* From [namespace.udecl]:
2947 A using-declaration used as a member-declaration shall refer to a
2948 member of a base class of the class being defined.
2950 In general, we cannot check this constraint in a template because
2951 we do not know the entire set of base classes of the current
2952 class type. However, if all of the base classes are
2953 non-dependent, then we can avoid delaying the check until
2955 if (!scope_dependent_p)
2958 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2959 if (b_kind < bk_proper_base)
2961 if (!bases_dependent_p)
2963 error_not_base_type (scope, current_class_type);
2967 else if (!name_dependent_p)
2969 decl = lookup_member (binfo, name, 0, false);
2972 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2976 /* The binfo from which the functions came does not matter. */
2977 if (BASELINK_P (decl))
2978 decl = BASELINK_FUNCTIONS (decl);
2982 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2983 USING_DECL_DECLS (value) = decl;
2984 USING_DECL_SCOPE (value) = scope;
2985 DECL_DEPENDENT_P (value) = !decl;
2991 /* Return the binding value for name in scope. */
2994 namespace_binding (tree name, tree scope)
2996 cxx_binding *binding;
2999 scope = global_namespace;
3001 /* Unnecessary for the global namespace because it can't be an alias. */
3002 scope = ORIGINAL_NAMESPACE (scope);
3004 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3006 return binding ? binding->value : NULL_TREE;
3009 /* Set the binding value for name in scope. */
3012 set_namespace_binding (tree name, tree scope, tree val)
3016 timevar_push (TV_NAME_LOOKUP);
3017 if (scope == NULL_TREE)
3018 scope = global_namespace;
3019 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3020 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3023 supplement_binding (b, val);
3024 timevar_pop (TV_NAME_LOOKUP);
3027 /* Set the context of a declaration to scope. Complain if we are not
3031 set_decl_namespace (tree decl, tree scope, bool friendp)
3035 /* Get rid of namespace aliases. */
3036 scope = ORIGINAL_NAMESPACE (scope);
3038 /* It is ok for friends to be qualified in parallel space. */
3039 if (!friendp && !is_ancestor (current_namespace, scope))
3040 error ("declaration of %qD not in a namespace surrounding %qD",
3042 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3044 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3045 if (scope == current_namespace)
3047 if (at_namespace_scope_p ())
3048 error ("explicit qualification in declaration of %qD",
3053 /* See whether this has been declared in the namespace. */
3054 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3055 if (old == error_mark_node)
3056 /* No old declaration at all. */
3058 if (!is_overloaded_fn (decl))
3059 /* Don't compare non-function decls with decls_match here, since
3060 it can't check for the correct constness at this
3061 point. pushdecl will find those errors later. */
3063 /* Since decl is a function, old should contain a function decl. */
3064 if (!is_overloaded_fn (old))
3066 fn = OVL_CURRENT (old);
3067 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3069 /* A template can be explicitly specialized in any namespace. */
3070 if (processing_explicit_instantiation)
3072 if (processing_template_decl || processing_specialization)
3073 /* We have not yet called push_template_decl to turn a
3074 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3075 match. But, we'll check later, when we construct the
3078 /* Instantiations or specializations of templates may be declared as
3079 friends in any namespace. */
3080 if (friendp && DECL_USE_TEMPLATE (decl))
3082 if (is_overloaded_fn (old))
3084 for (; old; old = OVL_NEXT (old))
3085 if (decls_match (decl, OVL_CURRENT (old)))
3088 else if (decls_match (decl, old))
3091 error ("%qD should have been declared inside %qD", decl, scope);
3094 /* Return the namespace where the current declaration is declared. */
3097 current_decl_namespace (void)
3100 /* If we have been pushed into a different namespace, use it. */
3101 if (decl_namespace_list)
3102 return TREE_PURPOSE (decl_namespace_list);
3104 if (current_class_type)
3105 result = decl_namespace_context (current_class_type);
3106 else if (current_function_decl)
3107 result = decl_namespace_context (current_function_decl);
3109 result = current_namespace;
3113 /* Process any ATTRIBUTES on a namespace definition. Currently only
3114 attribute visibility is meaningful, which is a property of the syntactic
3115 block rather than the namespace as a whole, so we don't touch the
3116 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3119 handle_namespace_attrs (tree ns, tree attributes)
3122 bool saw_vis = false;
3124 for (d = attributes; d; d = TREE_CHAIN (d))
3126 tree name = TREE_PURPOSE (d);
3127 tree args = TREE_VALUE (d);
3129 #ifdef HANDLE_PRAGMA_VISIBILITY
3130 if (is_attribute_p ("visibility", name))
3132 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3133 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3135 warning (OPT_Wattributes,
3136 "%qD attribute requires a single NTBS argument",
3141 if (!TREE_PUBLIC (ns))
3142 warning (OPT_Wattributes,
3143 "%qD attribute is meaningless since members of the "
3144 "anonymous namespace get local symbols", name);
3146 push_visibility (TREE_STRING_POINTER (x));
3152 warning (OPT_Wattributes, "%qD attribute directive ignored",
3161 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3162 select a name that is unique to this compilation unit. */
3165 push_namespace (tree name)
3169 int implicit_use = 0;
3172 timevar_push (TV_NAME_LOOKUP);
3174 /* We should not get here if the global_namespace is not yet constructed
3175 nor if NAME designates the global namespace: The global scope is
3176 constructed elsewhere. */
3177 gcc_assert (global_namespace != NULL && name != global_scope_name);
3181 name = get_anonymous_namespace_name();
3182 d = IDENTIFIER_NAMESPACE_VALUE (name);
3184 /* Reopening anonymous namespace. */
3190 /* Check whether this is an extended namespace definition. */
3191 d = IDENTIFIER_NAMESPACE_VALUE (name);
3192 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3195 if (DECL_NAMESPACE_ALIAS (d))
3197 error ("namespace alias %qD not allowed here, assuming %qD",
3198 d, DECL_NAMESPACE_ALIAS (d));
3199 d = DECL_NAMESPACE_ALIAS (d);
3206 /* Make a new namespace, binding the name to it. */
3207 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3208 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3209 /* The name of this namespace is not visible to other translation
3210 units if it is an anonymous namespace or member thereof. */
3211 if (anon || decl_anon_ns_mem_p (current_namespace))
3212 TREE_PUBLIC (d) = 0;
3214 TREE_PUBLIC (d) = 1;
3218 /* Clear DECL_NAME for the benefit of debugging back ends. */
3219 SET_DECL_ASSEMBLER_NAME (d, name);
3220 DECL_NAME (d) = NULL_TREE;
3222 begin_scope (sk_namespace, d);
3225 resume_scope (NAMESPACE_LEVEL (d));
3228 do_using_directive (d);
3229 /* Enter the name space. */
3230 current_namespace = d;
3232 timevar_pop (TV_NAME_LOOKUP);
3235 /* Pop from the scope of the current namespace. */
3238 pop_namespace (void)
3240 gcc_assert (current_namespace != global_namespace);
3241 current_namespace = CP_DECL_CONTEXT (current_namespace);
3242 /* The binding level is not popped, as it might be re-opened later. */
3246 /* Push into the scope of the namespace NS, even if it is deeply
3247 nested within another namespace. */
3250 push_nested_namespace (tree ns)
3252 if (ns == global_namespace)
3253 push_to_top_level ();
3256 push_nested_namespace (CP_DECL_CONTEXT (ns));
3257 push_namespace (DECL_NAME (ns));
3261 /* Pop back from the scope of the namespace NS, which was previously
3262 entered with push_nested_namespace. */
3265 pop_nested_namespace (tree ns)
3267 timevar_push (TV_NAME_LOOKUP);
3268 while (ns != global_namespace)
3271 ns = CP_DECL_CONTEXT (ns);
3274 pop_from_top_level ();
3275 timevar_pop (TV_NAME_LOOKUP);
3278 /* Temporarily set the namespace for the current declaration. */
3281 push_decl_namespace (tree decl)
3283 if (TREE_CODE (decl) != NAMESPACE_DECL)
3284 decl = decl_namespace_context (decl);
3285 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3286 NULL_TREE, decl_namespace_list);
3289 /* [namespace.memdef]/2 */
3292 pop_decl_namespace (void)
3294 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3297 /* Return the namespace that is the common ancestor
3298 of two given namespaces. */
3301 namespace_ancestor (tree ns1, tree ns2)
3303 timevar_push (TV_NAME_LOOKUP);
3304 if (is_ancestor (ns1, ns2))
3305 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3306 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3307 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3310 /* Process a namespace-alias declaration. */
3313 do_namespace_alias (tree alias, tree name_space)
3315 if (name_space == error_mark_node)
3318 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3320 name_space = ORIGINAL_NAMESPACE (name_space);
3322 /* Build the alias. */
3323 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3324 DECL_NAMESPACE_ALIAS (alias) = name_space;
3325 DECL_EXTERNAL (alias) = 1;
3326 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3329 /* Emit debug info for namespace alias. */
3330 (*debug_hooks->global_decl) (alias);
3333 /* Like pushdecl, only it places X in the current namespace,
3337 pushdecl_namespace_level (tree x, bool is_friend)
3339 struct cp_binding_level *b = current_binding_level;
3342 timevar_push (TV_NAME_LOOKUP);
3343 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3345 /* Now, the type_shadowed stack may screw us. Munge it so it does
3347 if (TREE_CODE (t) == TYPE_DECL)
3349 tree name = DECL_NAME (t);
3351 tree *ptr = (tree *)0;
3352 for (; !global_scope_p (b); b = b->level_chain)
3354 tree shadowed = b->type_shadowed;
3355 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3356 if (TREE_PURPOSE (shadowed) == name)
3358 ptr = &TREE_VALUE (shadowed);
3359 /* Can't break out of the loop here because sometimes
3360 a binding level will have duplicate bindings for
3361 PT names. It's gross, but I haven't time to fix it. */
3364 newval = TREE_TYPE (t);
3365 if (ptr == (tree *)0)
3367 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3368 up here if this is changed to an assertion. --KR */
3369 SET_IDENTIFIER_TYPE_VALUE (name, t);
3376 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3379 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3380 directive is not directly from the source. Also find the common
3381 ancestor and let our users know about the new namespace */
3383 add_using_namespace (tree user, tree used, bool indirect)
3386 timevar_push (TV_NAME_LOOKUP);
3387 /* Using oneself is a no-op. */
3390 timevar_pop (TV_NAME_LOOKUP);
3393 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3394 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3395 /* Check if we already have this. */
3396 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3400 /* Promote to direct usage. */
3401 TREE_INDIRECT_USING (t) = 0;
3402 timevar_pop (TV_NAME_LOOKUP);
3406 /* Add used to the user's using list. */
3407 DECL_NAMESPACE_USING (user)
3408 = tree_cons (used, namespace_ancestor (user, used),
3409 DECL_NAMESPACE_USING (user));
3411 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3413 /* Add user to the used's users list. */
3414 DECL_NAMESPACE_USERS (used)
3415 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3417 /* Recursively add all namespaces used. */
3418 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3419 /* indirect usage */
3420 add_using_namespace (user, TREE_PURPOSE (t), 1);
3422 /* Tell everyone using us about the new used namespaces. */
3423 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3424 add_using_namespace (TREE_PURPOSE (t), used, 1);
3425 timevar_pop (TV_NAME_LOOKUP);
3428 /* Process a using-declaration not appearing in class or local scope. */
3431 do_toplevel_using_decl (tree decl, tree scope, tree name)
3433 tree oldval, oldtype, newval, newtype;
3434 tree orig_decl = decl;
3435 cxx_binding *binding;
3437 decl = validate_nonmember_using_decl (decl, scope, name);
3438 if (decl == NULL_TREE)
3441 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3443 oldval = binding->value;
3444 oldtype = binding->type;
3446 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3448 /* Emit debug info. */
3449 if (!processing_template_decl)
3450 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3452 /* Copy declarations found. */
3454 binding->value = newval;
3456 binding->type = newtype;
3459 /* Process a using-directive. */
3462 do_using_directive (tree name_space)
3464 tree context = NULL_TREE;
3466 if (name_space == error_mark_node)
3469 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3471 if (building_stmt_tree ())
3472 add_stmt (build_stmt (USING_STMT, name_space));
3473 name_space = ORIGINAL_NAMESPACE (name_space);
3475 if (!toplevel_bindings_p ())
3477 push_using_directive (name_space);
3478 context = current_scope ();
3483 add_using_namespace (current_namespace, name_space, 0);
3484 if (current_namespace != global_namespace)
3485 context = current_namespace;
3488 /* Emit debugging info. */
3489 if (!processing_template_decl)
3490 (*debug_hooks->imported_module_or_decl) (name_space, context);
3493 /* Deal with a using-directive seen by the parser. Currently we only
3494 handle attributes here, since they cannot appear inside a template. */
3497 parse_using_directive (tree name_space, tree attribs)
3501 do_using_directive (name_space);
3503 for (a = attribs; a; a = TREE_CHAIN (a))
3505 tree name = TREE_PURPOSE (a);
3506 if (is_attribute_p ("strong", name))
3508 if (!toplevel_bindings_p ())
3509 error ("strong using only meaningful at namespace scope");
3510 else if (name_space != error_mark_node)
3512 if (!is_ancestor (current_namespace, name_space))
3513 error ("current namespace %qD does not enclose strongly used namespace %qD",
3514 current_namespace, name_space);
3515 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3516 = tree_cons (current_namespace, 0,
3517 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3521 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3525 /* Like pushdecl, only it places X in the global scope if appropriate.
3526 Calls cp_finish_decl to register the variable, initializing it with
3527 *INIT, if INIT is non-NULL. */
3530 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3532 timevar_push (TV_NAME_LOOKUP);
3533 push_to_top_level ();
3534 x = pushdecl_namespace_level (x, is_friend);
3536 finish_decl (x, *init, NULL_TREE);
3537 pop_from_top_level ();
3538 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3541 /* Like pushdecl, only it places X in the global scope if appropriate. */
3544 pushdecl_top_level (tree x)
3546 return pushdecl_top_level_1 (x, NULL, false);
3549 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3552 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3554 return pushdecl_top_level_1 (x, NULL, is_friend);
3557 /* Like pushdecl, only it places X in the global scope if
3558 appropriate. Calls cp_finish_decl to register the variable,
3559 initializing it with INIT. */
3562 pushdecl_top_level_and_finish (tree x, tree init)
3564 return pushdecl_top_level_1 (x, &init, false);
3567 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3568 duplicates. The first list becomes the tail of the result.
3570 The algorithm is O(n^2). We could get this down to O(n log n) by
3571 doing a sort on the addresses of the functions, if that becomes
3575 merge_functions (tree s1, tree s2)
3577 for (; s2; s2 = OVL_NEXT (s2))
3579 tree fn2 = OVL_CURRENT (s2);
3582 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3584 tree fn1 = OVL_CURRENT (fns1);
3586 /* If the function from S2 is already in S1, there is no
3587 need to add it again. For `extern "C"' functions, we
3588 might have two FUNCTION_DECLs for the same function, in
3589 different namespaces; again, we only need one of them. */
3591 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3592 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3596 /* If we exhausted all of the functions in S1, FN2 is new. */
3598 s1 = build_overload (fn2, s1);
3603 /* This should return an error not all definitions define functions.
3604 It is not an error if we find two functions with exactly the
3605 same signature, only if these are selected in overload resolution.
3606 old is the current set of bindings, new_binding the freshly-found binding.
3607 XXX Do we want to give *all* candidates in case of ambiguity?
3608 XXX In what way should I treat extern declarations?
3609 XXX I don't want to repeat the entire duplicate_decls here */
3612 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3615 gcc_assert (old != NULL);
3617 /* Copy the type. */
3618 type = new_binding->type;
3619 if (LOOKUP_NAMESPACES_ONLY (flags)
3620 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3623 /* Copy the value. */
3624 val = new_binding->value;
3627 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3630 switch (TREE_CODE (val))
3633 /* If we expect types or namespaces, and not templates,
3634 or this is not a template class. */
3635 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3636 && !DECL_CLASS_TEMPLATE_P (val)))
3640 if (LOOKUP_NAMESPACES_ONLY (flags)
3641 || (type && (flags & LOOKUP_PREFER_TYPES)))
3644 case NAMESPACE_DECL:
3645 if (LOOKUP_TYPES_ONLY (flags))
3649 /* Ignore built-in functions that are still anticipated. */
3650 if (LOOKUP_QUALIFIERS_ONLY (flags))
3654 if (LOOKUP_QUALIFIERS_ONLY (flags))
3659 /* If val is hidden, shift down any class or enumeration name. */
3668 else if (val && val != old->value)
3670 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3671 old->value = merge_functions (old->value, val);
3674 old->value = tree_cons (NULL_TREE, old->value,
3675 build_tree_list (NULL_TREE, val));
3676 TREE_TYPE (old->value) = error_mark_node;
3682 else if (type && old->type != type)
3684 old->type = tree_cons (NULL_TREE, old->type,
3685 build_tree_list (NULL_TREE, type));
3686 TREE_TYPE (old->type) = error_mark_node;
3690 /* Return the declarations that are members of the namespace NS. */
3693 cp_namespace_decls (tree ns)
3695 return NAMESPACE_LEVEL (ns)->names;
3698 /* Combine prefer_type and namespaces_only into flags. */
3701 lookup_flags (int prefer_type, int namespaces_only)
3703 if (namespaces_only)
3704 return LOOKUP_PREFER_NAMESPACES;
3705 if (prefer_type > 1)
3706 return LOOKUP_PREFER_TYPES;
3707 if (prefer_type > 0)
3708 return LOOKUP_PREFER_BOTH;
3712 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3713 ignore it or not. Subroutine of lookup_name_real and
3714 lookup_type_scope. */
3717 qualify_lookup (tree val, int flags)
3719 if (val == NULL_TREE)
3721 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3723 if ((flags & LOOKUP_PREFER_TYPES)
3724 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3726 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3731 /* Given a lookup that returned VAL, decide if we want to ignore it or
3732 not based on DECL_ANTICIPATED. */
3735 hidden_name_p (tree val)
3738 && DECL_LANG_SPECIFIC (val)
3739 && DECL_ANTICIPATED (val))
3744 /* Remove any hidden friend functions from a possibly overloaded set
3748 remove_hidden_names (tree fns)
3753 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3755 else if (TREE_CODE (fns) == OVERLOAD)
3759 for (o = fns; o; o = OVL_NEXT (o))
3760 if (hidden_name_p (OVL_CURRENT (o)))
3766 for (o = fns; o; o = OVL_NEXT (o))
3767 if (!hidden_name_p (OVL_CURRENT (o)))
3768 n = build_overload (OVL_CURRENT (o), n);
3776 /* Unscoped lookup of a global: iterate over current namespaces,
3777 considering using-directives. */
3780 unqualified_namespace_lookup (tree name, int flags)
3782 tree initial = current_decl_namespace ();
3783 tree scope = initial;
3785 struct cp_binding_level *level;
3786 tree val = NULL_TREE;
3788 timevar_push (TV_NAME_LOOKUP);
3790 for (; !val; scope = CP_DECL_CONTEXT (scope))
3792 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3794 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3797 ambiguous_decl (&binding, b, flags);
3799 /* Add all _DECLs seen through local using-directives. */
3800 for (level = current_binding_level;
3801 level->kind != sk_namespace;
3802 level = level->level_chain)
3803 if (!lookup_using_namespace (name, &binding, level->using_directives,
3805 /* Give up because of error. */
3806 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3808 /* Add all _DECLs seen through global using-directives. */
3809 /* XXX local and global using lists should work equally. */
3813 if (!lookup_using_namespace (name, &binding,
3814 DECL_NAMESPACE_USING (siter),
3816 /* Give up because of error. */
3817 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3818 if (siter == scope) break;
3819 siter = CP_DECL_CONTEXT (siter);
3822 val = binding.value;
3823 if (scope == global_namespace)
3826 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3829 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3830 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3833 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3834 declaration found. If no suitable declaration can be found,
3835 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3836 neither a class-type nor a namespace a diagnostic is issued. */
3839 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3844 if (TREE_CODE (scope) == NAMESPACE_DECL)
3846 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3848 flags |= LOOKUP_COMPLAIN;
3850 flags |= LOOKUP_PREFER_TYPES;
3851 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3854 else if (is_class_type (scope, complain))
3855 t = lookup_member (scope, name, 2, is_type_p);
3858 return error_mark_node;
3862 /* Subroutine of unqualified_namespace_lookup:
3863 Add the bindings of NAME in used namespaces to VAL.
3864 We are currently looking for names in namespace SCOPE, so we
3865 look through USINGS for using-directives of namespaces
3866 which have SCOPE as a common ancestor with the current scope.
3867 Returns false on errors. */
3870 lookup_using_namespace (tree name, struct scope_binding *val,
3871 tree usings, tree scope, int flags)
3874 timevar_push (TV_NAME_LOOKUP);
3875 /* Iterate over all used namespaces in current, searching for using
3876 directives of scope. */
3877 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3878 if (TREE_VALUE (iter) == scope)
3880 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3882 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3883 /* Resolve ambiguities. */
3885 ambiguous_decl (val, val1, flags);
3887 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3891 Accepts the NAME to lookup and its qualifying SCOPE.
3892 Returns the name/type pair found into the cxx_binding *RESULT,
3893 or false on error. */
3896 qualified_lookup_using_namespace (tree name, tree scope,
3897 struct scope_binding *result, int flags)
3899 /* Maintain a list of namespaces visited... */
3900 tree seen = NULL_TREE;
3901 /* ... and a list of namespace yet to see. */
3902 tree todo = NULL_TREE;
3903 tree todo_maybe = NULL_TREE;
3905 timevar_push (TV_NAME_LOOKUP);
3906 /* Look through namespace aliases. */
3907 scope = ORIGINAL_NAMESPACE (scope);
3908 while (scope && result->value != error_mark_node)
3910 cxx_binding *binding =
3911 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3912 seen = tree_cons (scope, NULL_TREE, seen);
3914 ambiguous_decl (result, binding, flags);
3916 /* Consider strong using directives always, and non-strong ones
3917 if we haven't found a binding yet. ??? Shouldn't we consider
3918 non-strong ones if the initial RESULT is non-NULL, but the
3919 binding in the given namespace is? */
3920 for (usings = DECL_NAMESPACE_USING (scope); usings;
3921 usings = TREE_CHAIN (usings))
3922 /* If this was a real directive, and we have not seen it. */
3923 if (!TREE_INDIRECT_USING (usings))
3925 /* Try to avoid queuing the same namespace more than once,
3926 the exception being when a namespace was already
3927 enqueued for todo_maybe and then a strong using is
3928 found for it. We could try to remove it from
3929 todo_maybe, but it's probably not worth the effort. */
3930 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3931 && !purpose_member (TREE_PURPOSE (usings), seen)
3932 && !purpose_member (TREE_PURPOSE (usings), todo))
3933 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3934 else if ((!result->value && !result->type)
3935 && !purpose_member (TREE_PURPOSE (usings), seen)
3936 && !purpose_member (TREE_PURPOSE (usings), todo)
3937 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3938 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3943 scope = TREE_PURPOSE (todo);
3944 todo = TREE_CHAIN (todo);
3947 && (!result->value && !result->type))
3949 scope = TREE_PURPOSE (todo_maybe);
3950 todo = TREE_CHAIN (todo_maybe);
3951 todo_maybe = NULL_TREE;
3954 scope = NULL_TREE; /* If there never was a todo list. */
3956 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3959 /* Return the innermost non-namespace binding for NAME from a scope
3960 containing BINDING, or, if BINDING is NULL, the current scope. If
3961 CLASS_P is false, then class bindings are ignored. */
3964 outer_binding (tree name,
3965 cxx_binding *binding,
3970 cxx_scope *outer_scope;
3974 scope = binding->scope->level_chain;
3975 outer = binding->previous;
3979 scope = current_binding_level;
3980 outer = IDENTIFIER_BINDING (name);
3982 outer_scope = outer ? outer->scope : NULL;
3984 /* Because we create class bindings lazily, we might be missing a
3985 class binding for NAME. If there are any class binding levels
3986 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3987 declared, we must lookup NAME in those class scopes. */
3989 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3991 if (scope->kind == sk_class)
3993 cxx_binding *class_binding;
3995 class_binding = get_class_binding (name, scope);
3998 /* Thread this new class-scope binding onto the
3999 IDENTIFIER_BINDING list so that future lookups
4001 class_binding->previous = outer;
4003 binding->previous = class_binding;
4005 IDENTIFIER_BINDING (name) = class_binding;
4006 return class_binding;
4009 scope = scope->level_chain;
4015 /* Return the innermost block-scope or class-scope value binding for
4016 NAME, or NULL_TREE if there is no such binding. */
4019 innermost_non_namespace_value (tree name)
4021 cxx_binding *binding;
4022 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4023 return binding ? binding->value : NULL_TREE;
4026 /* Look up NAME in the current binding level and its superiors in the
4027 namespace of variables, functions and typedefs. Return a ..._DECL
4028 node of some kind representing its definition if there is only one
4029 such declaration, or return a TREE_LIST with all the overloaded
4030 definitions if there are many, or return 0 if it is undefined.
4031 Hidden name, either friend declaration or built-in function, are
4034 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4035 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4036 Otherwise we prefer non-TYPE_DECLs.
4038 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4039 BLOCK_P is false, bindings in block scopes are ignored. */
4042 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4043 int namespaces_only, int flags)
4046 tree val = NULL_TREE;
4048 timevar_push (TV_NAME_LOOKUP);
4049 /* Conversion operators are handled specially because ordinary
4050 unqualified name lookup will not find template conversion
4052 if (IDENTIFIER_TYPENAME_P (name))
4054 struct cp_binding_level *level;
4056 for (level = current_binding_level;
4057 level && level->kind != sk_namespace;
4058 level = level->level_chain)
4063 /* A conversion operator can only be declared in a class
4065 if (level->kind != sk_class)
4068 /* Lookup the conversion operator in the class. */
4069 class_type = level->this_entity;
4070 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4072 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4075 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4078 flags |= lookup_flags (prefer_type, namespaces_only);
4080 /* First, look in non-namespace scopes. */
4082 if (current_class_type == NULL_TREE)
4085 if (block_p || !nonclass)
4086 for (iter = outer_binding (name, NULL, !nonclass);
4088 iter = outer_binding (name, iter, !nonclass))
4092 /* Skip entities we don't want. */
4093 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4096 /* If this is the kind of thing we're looking for, we're done. */
4097 if (qualify_lookup (iter->value, flags))
4098 binding = iter->value;
4099 else if ((flags & LOOKUP_PREFER_TYPES)
4100 && qualify_lookup (iter->type, flags))
4101 binding = iter->type;
4103 binding = NULL_TREE;
4107 if (hidden_name_p (binding))
4109 /* A non namespace-scope binding can only be hidden if
4110 we are in a local class, due to friend declarations.
4111 In particular, consider:
4116 void g() { B* b; } // error: B is hidden
4121 The standard says that "B" is a local class in "f"
4122 (but not nested within "A") -- but that name lookup
4123 for "B" does not find this declaration until it is
4124 declared directly with "f".
4130 If a friend declaration appears in a local class and
4131 the name specified is an unqualified name, a prior
4132 declaration is looked up without considering scopes
4133 that are outside the innermost enclosing non-class
4134 scope. For a friend class declaration, if there is no
4135 prior declaration, the class that is specified
4136 belongs to the innermost enclosing non-class scope,
4137 but if it is subsequently referenced, its name is not
4138 found by name lookup until a matching declaration is
4139 provided in the innermost enclosing nonclass scope.
4141 gcc_assert (current_class_type &&
4142 LOCAL_CLASS_P (current_class_type));
4144 /* This binding comes from a friend declaration in the local
4145 class. The standard (11.4.8) states that the lookup can
4146 only succeed if there is a non-hidden declaration in the
4147 current scope, which is not the case here. */
4148 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4155 /* Now lookup in namespace scopes. */
4157 val = unqualified_namespace_lookup (name, flags);
4159 /* If we have a single function from a using decl, pull it out. */
4160 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4161 val = OVL_FUNCTION (val);
4163 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4167 lookup_name_nonclass (tree name)
4169 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4173 lookup_function_nonclass (tree name, tree args, bool block_p)
4176 lookup_arg_dependent (name,
4177 lookup_name_real (name, 0, 1, block_p, 0,
4183 lookup_name (tree name)
4185 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4189 lookup_name_prefer_type (tree name, int prefer_type)
4191 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4192 0, LOOKUP_COMPLAIN);
4195 /* Look up NAME for type used in elaborated name specifier in
4196 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4197 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4198 name, more scopes are checked if cleanup or template parameter
4199 scope is encountered.
4201 Unlike lookup_name_real, we make sure that NAME is actually
4202 declared in the desired scope, not from inheritance, nor using
4203 directive. For using declaration, there is DR138 still waiting
4204 to be resolved. Hidden name coming from an earlier friend
4205 declaration is also returned.
4207 A TYPE_DECL best matching the NAME is returned. Catching error
4208 and issuing diagnostics are caller's responsibility. */
4211 lookup_type_scope (tree name, tag_scope scope)
4213 cxx_binding *iter = NULL;
4214 tree val = NULL_TREE;
4216 timevar_push (TV_NAME_LOOKUP);
4218 /* Look in non-namespace scope first. */
4219 if (current_binding_level->kind != sk_namespace)
4220 iter = outer_binding (name, NULL, /*class_p=*/ true);
4221 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4223 /* Check if this is the kind of thing we're looking for.
4224 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4225 base class. For ITER->VALUE, we can simply use
4226 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4229 We check ITER->TYPE before ITER->VALUE in order to handle
4230 typedef struct C {} C;
4233 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4234 && (scope != ts_current
4235 || LOCAL_BINDING_P (iter)
4236 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4238 else if ((scope != ts_current
4239 || !INHERITED_VALUE_BINDING_P (iter))
4240 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4247 /* Look in namespace scope. */
4250 iter = cxx_scope_find_binding_for_name
4251 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4255 /* If this is the kind of thing we're looking for, we're done. */
4256 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4258 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4264 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4265 and template parameter scopes. */
4268 struct cp_binding_level *b = current_binding_level;
4271 if (iter->scope == b)
4272 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4274 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4276 else if (b->kind == sk_class
4277 && scope == ts_within_enclosing_non_class)
4284 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4287 /* Similar to `lookup_name' but look only in the innermost non-class
4291 lookup_name_innermost_nonclass_level (tree name)
4293 struct cp_binding_level *b;
4296 timevar_push (TV_NAME_LOOKUP);
4297 b = innermost_nonclass_level ();
4299 if (b->kind == sk_namespace)
4301 t = IDENTIFIER_NAMESPACE_VALUE (name);
4303 /* extern "C" function() */
4304 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4307 else if (IDENTIFIER_BINDING (name)
4308 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4310 cxx_binding *binding;
4311 binding = IDENTIFIER_BINDING (name);
4314 if (binding->scope == b
4315 && !(TREE_CODE (binding->value) == VAR_DECL
4316 && DECL_DEAD_FOR_LOCAL (binding->value)))
4317 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4319 if (b->kind == sk_cleanup)
4326 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4329 /* Like lookup_name_innermost_nonclass_level, but for types. */
4332 lookup_type_current_level (tree name)
4336 timevar_push (TV_NAME_LOOKUP);
4337 gcc_assert (current_binding_level->kind != sk_namespace);
4339 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4340 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4342 struct cp_binding_level *b = current_binding_level;
4345 if (purpose_member (name, b->type_shadowed))
4346 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4347 REAL_IDENTIFIER_TYPE_VALUE (name));
4348 if (b->kind == sk_cleanup)
4355 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4358 /* [basic.lookup.koenig] */
4359 /* A nonzero return value in the functions below indicates an error. */
4370 static bool arg_assoc (struct arg_lookup*, tree);
4371 static bool arg_assoc_args (struct arg_lookup*, tree);
4372 static bool arg_assoc_type (struct arg_lookup*, tree);
4373 static bool add_function (struct arg_lookup *, tree);
4374 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4375 static bool arg_assoc_class (struct arg_lookup *, tree);
4376 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4378 /* Add a function to the lookup structure.
4379 Returns true on error. */
4382 add_function (struct arg_lookup *k, tree fn)
4384 /* We used to check here to see if the function was already in the list,
4385 but that's O(n^2), which is just too expensive for function lookup.
4386 Now we deal with the occasional duplicate in joust. In doing this, we
4387 assume that the number of duplicates will be small compared to the
4388 total number of functions being compared, which should usually be the
4391 /* We must find only functions, or exactly one non-function. */
4394 else if (fn == k->functions)
4396 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4397 k->functions = build_overload (fn, k->functions);
4400 tree f1 = OVL_CURRENT (k->functions);
4402 if (is_overloaded_fn (f1))
4404 fn = f1; f1 = f2; f2 = fn;
4406 error ("%q+D is not a function,", f1);
4407 error (" conflict with %q+D", f2);
4408 error (" in call to %qD", k->name);
4415 /* Returns true iff CURRENT has declared itself to be an associated
4416 namespace of SCOPE via a strong using-directive (or transitive chain
4417 thereof). Both are namespaces. */
4420 is_associated_namespace (tree current, tree scope)
4422 tree seen = NULL_TREE;
4423 tree todo = NULL_TREE;
4427 if (scope == current)
4429 seen = tree_cons (scope, NULL_TREE, seen);
4430 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4431 if (!purpose_member (TREE_PURPOSE (t), seen))
4432 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4435 scope = TREE_PURPOSE (todo);
4436 todo = TREE_CHAIN (todo);
4443 /* Return whether FN is a friend of an associated class of ARG. */
4446 friend_of_associated_class_p (tree arg, tree fn)
4452 else if (type_unknown_p (arg))
4455 type = TREE_TYPE (arg);
4457 /* If TYPE is a class, the class itself and all base classes are
4458 associated classes. */
4459 if (CLASS_TYPE_P (type))
4461 if (is_friend (type, fn))
4464 if (TYPE_BINFO (type))
4466 tree binfo, base_binfo;
4469 for (binfo = TYPE_BINFO (type), i = 0;
4470 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4472 if (is_friend (BINFO_TYPE (base_binfo), fn))
4477 /* If TYPE is a class member, the class of which it is a member is
4478 an associated class. */
4479 if ((CLASS_TYPE_P (type)
4480 || TREE_CODE (type) == UNION_TYPE
4481 || TREE_CODE (type) == ENUMERAL_TYPE)
4482 && TYPE_CONTEXT (type)
4483 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4484 && is_friend (TYPE_CONTEXT (type), fn))
4490 /* Add functions of a namespace to the lookup structure.
4491 Returns true on error. */
4494 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4498 if (purpose_member (scope, k->namespaces))
4500 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4502 /* Check out our super-users. */
4503 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4504 value = TREE_CHAIN (value))
4505 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4508 /* Also look down into inline namespaces. */
4509 for (value = DECL_NAMESPACE_USING (scope); value;
4510 value = TREE_CHAIN (value))
4511 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4512 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4515 value = namespace_binding (k->name, scope);
4519 for (; value; value = OVL_NEXT (value))
4521 /* We don't want to find arbitrary hidden functions via argument
4522 dependent lookup. We only want to find friends of associated
4524 if (hidden_name_p (OVL_CURRENT (value)))
4528 for (args = k->args; args; args = TREE_CHAIN (args))
4529 if (friend_of_associated_class_p (TREE_VALUE (args),
4530 OVL_CURRENT (value)))
4536 if (add_function (k, OVL_CURRENT (value)))
4543 /* Adds everything associated with a template argument to the lookup
4544 structure. Returns true on error. */
4547 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4549 /* [basic.lookup.koenig]
4551 If T is a template-id, its associated namespaces and classes are
4552 ... the namespaces and classes associated with the types of the
4553 template arguments provided for template type parameters
4554 (excluding template template parameters); the namespaces in which
4555 any template template arguments are defined; and the classes in
4556 which any member templates used as template template arguments
4557 are defined. [Note: non-type template arguments do not
4558 contribute to the set of associated namespaces. ] */
4560 /* Consider first template template arguments. */
4561 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4562 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4564 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4566 tree ctx = CP_DECL_CONTEXT (arg);
4568 /* It's not a member template. */
4569 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4570 return arg_assoc_namespace (k, ctx);
4571 /* Otherwise, it must be member template. */
4573 return arg_assoc_class (k, ctx);
4575 /* It's an argument pack; handle it recursively. */
4576 else if (ARGUMENT_PACK_P (arg))
4578 tree args = ARGUMENT_PACK_ARGS (arg);
4579 int i, len = TREE_VEC_LENGTH (args);
4580 for (i = 0; i < len; ++i)
4581 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4586 /* It's not a template template argument, but it is a type template
4588 else if (TYPE_P (arg))
4589 return arg_assoc_type (k, arg);
4590 /* It's a non-type template argument. */
4595 /* Adds everything associated with class to the lookup structure.
4596 Returns true on error. */
4599 arg_assoc_class (struct arg_lookup *k, tree type)
4601 tree list, friends, context;
4604 /* Backend build structures, such as __builtin_va_list, aren't
4605 affected by all this. */
4606 if (!CLASS_TYPE_P (type))
4609 if (purpose_member (type, k->classes))
4611 k->classes = tree_cons (type, NULL_TREE, k->classes);
4613 context = decl_namespace_context (type);
4614 if (arg_assoc_namespace (k, context))
4617 if (TYPE_BINFO (type))
4619 /* Process baseclasses. */
4620 tree binfo, base_binfo;
4622 for (binfo = TYPE_BINFO (type), i = 0;
4623 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4624 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4628 /* Process friends. */
4629 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4630 list = TREE_CHAIN (list))
4631 if (k->name == FRIEND_NAME (list))
4632 for (friends = FRIEND_DECLS (list); friends;
4633 friends = TREE_CHAIN (friends))
4635 tree fn = TREE_VALUE (friends);
4637 /* Only interested in global functions with potentially hidden
4638 (i.e. unqualified) declarations. */
4639 if (CP_DECL_CONTEXT (fn) != context)
4641 /* Template specializations are never found by name lookup.
4642 (Templates themselves can be found, but not template
4643 specializations.) */
4644 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4646 if (add_function (k, fn))
4650 /* Process template arguments. */
4651 if (CLASSTYPE_TEMPLATE_INFO (type)
4652 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4654 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4655 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4656 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4662 /* Adds everything associated with a given type.
4663 Returns 1 on error. */
4666 arg_assoc_type (struct arg_lookup *k, tree type)
4668 /* As we do not get the type of non-type dependent expressions
4669 right, we can end up with such things without a type. */
4673 if (TYPE_PTRMEM_P (type))
4675 /* Pointer to member: associate class type and value type. */
4676 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4678 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4680 else switch (TREE_CODE (type))
4690 case FIXED_POINT_TYPE:
4693 if (TYPE_PTRMEMFUNC_P (type))
4694 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4695 return arg_assoc_class (k, type);
4697 case REFERENCE_TYPE:
4699 return arg_assoc_type (k, TREE_TYPE (type));
4702 return arg_assoc_namespace (k, decl_namespace_context (type));
4704 /* The basetype is referenced in the first arg type, so just
4707 /* Associate the parameter types. */
4708 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4710 /* Associate the return type. */
4711 return arg_assoc_type (k, TREE_TYPE (type));
4712 case TEMPLATE_TYPE_PARM:
4713 case BOUND_TEMPLATE_TEMPLATE_PARM:
4718 gcc_assert (type == unknown_type_node
4719 || type == init_list_type_node);
4721 case TYPE_PACK_EXPANSION:
4722 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4730 /* Adds everything associated with arguments. Returns true on error. */
4733 arg_assoc_args (struct arg_lookup *k, tree args)
4735 for (; args; args = TREE_CHAIN (args))
4736 if (arg_assoc (k, TREE_VALUE (args)))
4741 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4744 arg_assoc (struct arg_lookup *k, tree n)
4746 if (n == error_mark_node)
4750 return arg_assoc_type (k, n);
4752 if (! type_unknown_p (n))
4753 return arg_assoc_type (k, TREE_TYPE (n));
4755 if (TREE_CODE (n) == ADDR_EXPR)
4756 n = TREE_OPERAND (n, 0);
4757 if (TREE_CODE (n) == COMPONENT_REF)
4758 n = TREE_OPERAND (n, 1);
4759 if (TREE_CODE (n) == OFFSET_REF)
4760 n = TREE_OPERAND (n, 1);
4761 while (TREE_CODE (n) == TREE_LIST)
4763 if (TREE_CODE (n) == BASELINK)
4764 n = BASELINK_FUNCTIONS (n);
4766 if (TREE_CODE (n) == FUNCTION_DECL)
4767 return arg_assoc_type (k, TREE_TYPE (n));
4768 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4770 /* [basic.lookup.koenig]
4772 If T is a template-id, its associated namespaces and classes
4773 are the namespace in which the template is defined; for
4774 member templates, the member template's class... */
4775 tree templ = TREE_OPERAND (n, 0);
4776 tree args = TREE_OPERAND (n, 1);
4780 if (TREE_CODE (templ) == COMPONENT_REF)
4781 templ = TREE_OPERAND (templ, 1);
4783 /* First, the template. There may actually be more than one if
4784 this is an overloaded function template. But, in that case,
4785 we only need the first; all the functions will be in the same
4787 templ = OVL_CURRENT (templ);
4789 ctx = CP_DECL_CONTEXT (templ);
4791 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4793 if (arg_assoc_namespace (k, ctx) == 1)
4796 /* It must be a member template. */
4797 else if (arg_assoc_class (k, ctx) == 1)
4800 /* Now the arguments. */
4802 for (ix = TREE_VEC_LENGTH (args); ix--;)
4803 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4806 else if (TREE_CODE (n) == OVERLOAD)
4808 for (; n; n = OVL_CHAIN (n))
4809 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4816 /* Performs Koenig lookup depending on arguments, where fns
4817 are the functions found in normal lookup. */
4820 lookup_arg_dependent (tree name, tree fns, tree args)
4822 struct arg_lookup k;
4824 timevar_push (TV_NAME_LOOKUP);
4826 /* Remove any hidden friend functions from the list of functions
4827 found so far. They will be added back by arg_assoc_class as
4829 fns = remove_hidden_names (fns);
4834 k.classes = NULL_TREE;
4836 /* We previously performed an optimization here by setting
4837 NAMESPACES to the current namespace when it was safe. However, DR
4838 164 says that namespaces that were already searched in the first
4839 stage of template processing are searched again (potentially
4840 picking up later definitions) in the second stage. */
4841 k.namespaces = NULL_TREE;
4843 arg_assoc_args (&k, args);
4848 && TREE_CODE (fns) != VAR_DECL
4849 && !is_overloaded_fn (fns))
4851 error ("argument dependent lookup finds %q+D", fns);
4852 error (" in call to %qD", name);
4853 fns = error_mark_node;
4856 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4859 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4860 changed (i.e. there was already a directive), or the fresh
4861 TREE_LIST otherwise. */
4864 push_using_directive (tree used)
4866 tree ud = current_binding_level->using_directives;
4867 tree iter, ancestor;
4869 timevar_push (TV_NAME_LOOKUP);
4870 /* Check if we already have this. */
4871 if (purpose_member (used, ud) != NULL_TREE)
4872 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4874 ancestor = namespace_ancestor (current_decl_namespace (), used);
4875 ud = current_binding_level->using_directives;
4876 ud = tree_cons (used, ancestor, ud);
4877 current_binding_level->using_directives = ud;
4879 /* Recursively add all namespaces used. */
4880 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4881 push_using_directive (TREE_PURPOSE (iter));
4883 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4886 /* The type TYPE is being declared. If it is a class template, or a
4887 specialization of a class template, do any processing required and
4888 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4889 being declared a friend. B is the binding level at which this TYPE
4892 Returns the TYPE_DECL for TYPE, which may have been altered by this
4896 maybe_process_template_type_declaration (tree type, int is_friend,
4899 tree decl = TYPE_NAME (type);
4901 if (processing_template_parmlist)
4902 /* You can't declare a new template type in a template parameter
4903 list. But, you can declare a non-template type:
4905 template <class A*> struct S;
4907 is a forward-declaration of `A'. */
4909 else if (b->kind == sk_namespace
4910 && current_binding_level->kind != sk_namespace)
4911 /* If this new type is being injected into a containing scope,
4912 then it's not a template type. */
4916 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4917 || TREE_CODE (type) == ENUMERAL_TYPE);
4919 if (processing_template_decl)
4921 /* This may change after the call to
4922 push_template_decl_real, but we want the original value. */
4923 tree name = DECL_NAME (decl);
4925 decl = push_template_decl_real (decl, is_friend);
4926 /* If the current binding level is the binding level for the
4927 template parameters (see the comment in
4928 begin_template_parm_list) and the enclosing level is a class
4929 scope, and we're not looking at a friend, push the
4930 declaration of the member class into the class scope. In the
4931 friend case, push_template_decl will already have put the
4932 friend into global scope, if appropriate. */
4933 if (TREE_CODE (type) != ENUMERAL_TYPE
4934 && !is_friend && b->kind == sk_template_parms
4935 && b->level_chain->kind == sk_class)
4937 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4939 if (!COMPLETE_TYPE_P (current_class_type))
4941 maybe_add_class_template_decl_list (current_class_type,
4942 type, /*friend_p=*/0);
4943 /* Put this UTD in the table of UTDs for the class. */
4944 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4945 CLASSTYPE_NESTED_UTDS (current_class_type) =
4946 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4948 binding_table_insert
4949 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4958 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4959 that the NAME is a class template, the tag is processed but not pushed.
4961 The pushed scope depend on the SCOPE parameter:
4962 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4964 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4965 non-template-parameter scope. This case is needed for forward
4967 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4968 TS_GLOBAL case except that names within template-parameter scopes
4969 are not pushed at all.
4971 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4974 pushtag (tree name, tree type, tag_scope scope)
4976 struct cp_binding_level *b;
4979 timevar_push (TV_NAME_LOOKUP);
4980 b = current_binding_level;
4981 while (/* Cleanup scopes are not scopes from the point of view of
4983 b->kind == sk_cleanup
4984 /* Neither are the scopes used to hold template parameters
4985 for an explicit specialization. For an ordinary template
4986 declaration, these scopes are not scopes from the point of
4987 view of the language. */
4988 || (b->kind == sk_template_parms
4989 && (b->explicit_spec_p || scope == ts_global))
4990 || (b->kind == sk_class
4991 && (scope != ts_current
4992 /* We may be defining a new type in the initializer
4993 of a static member variable. We allow this when
4994 not pedantic, and it is particularly useful for
4995 type punning via an anonymous union. */
4996 || COMPLETE_TYPE_P (b->this_entity))))
4999 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5001 /* Do C++ gratuitous typedefing. */
5002 if (IDENTIFIER_TYPE_VALUE (name) != type)
5006 tree context = TYPE_CONTEXT (type);
5010 tree cs = current_scope ();
5012 if (scope == ts_current)
5014 else if (cs != NULL_TREE && TYPE_P (cs))
5015 /* When declaring a friend class of a local class, we want
5016 to inject the newly named class into the scope
5017 containing the local class, not the namespace
5019 context = decl_function_context (get_type_decl (cs));
5022 context = current_namespace;
5024 if (b->kind == sk_class
5025 || (b->kind == sk_template_parms
5026 && b->level_chain->kind == sk_class))
5029 if (current_lang_name == lang_name_java)
5030 TYPE_FOR_JAVA (type) = 1;
5032 tdef = create_implicit_typedef (name, type);
5033 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5034 if (scope == ts_within_enclosing_non_class)
5036 /* This is a friend. Make this TYPE_DECL node hidden from
5037 ordinary name lookup. Its corresponding TEMPLATE_DECL
5038 will be marked in push_template_decl_real. */
5039 retrofit_lang_decl (tdef);
5040 DECL_ANTICIPATED (tdef) = 1;
5041 DECL_FRIEND_P (tdef) = 1;
5044 decl = maybe_process_template_type_declaration
5045 (type, scope == ts_within_enclosing_non_class, b);
5046 if (decl == error_mark_node)
5047 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5049 if (b->kind == sk_class)
5051 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5052 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5053 class. But if it's a member template class, we want
5054 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5056 finish_member_declaration (decl);
5058 pushdecl_class_level (decl);
5060 else if (b->kind != sk_template_parms)
5062 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5063 if (decl == error_mark_node)
5064 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5068 set_identifier_type_value_with_scope (name, tdef, b);
5070 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5072 /* If this is a local class, keep track of it. We need this
5073 information for name-mangling, and so that it is possible to
5074 find all function definitions in a translation unit in a
5075 convenient way. (It's otherwise tricky to find a member
5076 function definition it's only pointed to from within a local
5078 if (TYPE_CONTEXT (type)
5079 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5080 VEC_safe_push (tree, gc, local_classes, type);
5082 if (b->kind == sk_class
5083 && !COMPLETE_TYPE_P (current_class_type))
5085 maybe_add_class_template_decl_list (current_class_type,
5086 type, /*friend_p=*/0);
5088 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5089 CLASSTYPE_NESTED_UTDS (current_class_type)
5090 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5092 binding_table_insert
5093 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5096 decl = TYPE_NAME (type);
5097 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5098 TYPE_STUB_DECL (type) = decl;
5100 /* Set type visibility now if this is a forward declaration. */
5101 TREE_PUBLIC (decl) = 1;
5102 determine_visibility (decl);
5104 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5107 /* Subroutines for reverting temporarily to top-level for instantiation
5108 of templates and such. We actually need to clear out the class- and
5109 local-value slots of all identifiers, so that only the global values
5110 are at all visible. Simply setting current_binding_level to the global
5111 scope isn't enough, because more binding levels may be pushed. */
5112 struct saved_scope *scope_chain;
5114 /* If ID has not already been marked, add an appropriate binding to
5118 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5120 cxx_saved_binding *saved;
5122 if (!id || !IDENTIFIER_BINDING (id))
5125 if (IDENTIFIER_MARKED (id))
5128 IDENTIFIER_MARKED (id) = 1;
5130 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5131 saved->identifier = id;
5132 saved->binding = IDENTIFIER_BINDING (id);
5133 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5134 IDENTIFIER_BINDING (id) = NULL;
5138 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5142 timevar_push (TV_NAME_LOOKUP);
5143 for (t = names; t; t = TREE_CHAIN (t))
5147 if (TREE_CODE (t) == TREE_LIST)
5148 id = TREE_PURPOSE (t);
5152 store_binding (id, old_bindings);
5154 timevar_pop (TV_NAME_LOOKUP);
5157 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5158 objects, rather than a TREE_LIST. */
5161 store_class_bindings (VEC(cp_class_binding,gc) *names,
5162 VEC(cxx_saved_binding,gc) **old_bindings)
5165 cp_class_binding *cb;
5167 timevar_push (TV_NAME_LOOKUP);
5168 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5169 store_binding (cb->identifier, old_bindings);
5170 timevar_pop (TV_NAME_LOOKUP);
5174 push_to_top_level (void)
5176 struct saved_scope *s;
5177 struct cp_binding_level *b;
5178 cxx_saved_binding *sb;
5182 timevar_push (TV_NAME_LOOKUP);
5183 s = GGC_CNEW (struct saved_scope);
5185 b = scope_chain ? current_binding_level : 0;
5187 /* If we're in the middle of some function, save our state. */
5191 push_function_context ();
5196 if (scope_chain && previous_class_level)
5197 store_class_bindings (previous_class_level->class_shadowed,
5200 /* Have to include the global scope, because class-scope decls
5201 aren't listed anywhere useful. */
5202 for (; b; b = b->level_chain)
5206 /* Template IDs are inserted into the global level. If they were
5207 inserted into namespace level, finish_file wouldn't find them
5208 when doing pending instantiations. Therefore, don't stop at
5209 namespace level, but continue until :: . */
5210 if (global_scope_p (b))
5213 store_bindings (b->names, &s->old_bindings);
5214 /* We also need to check class_shadowed to save class-level type
5215 bindings, since pushclass doesn't fill in b->names. */
5216 if (b->kind == sk_class)
5217 store_class_bindings (b->class_shadowed, &s->old_bindings);
5219 /* Unwind type-value slots back to top level. */
5220 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5221 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5224 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5225 IDENTIFIER_MARKED (sb->identifier) = 0;
5227 s->prev = scope_chain;
5229 s->need_pop_function_context = need_pop;
5230 s->function_decl = current_function_decl;
5231 s->skip_evaluation = skip_evaluation;
5234 current_function_decl = NULL_TREE;
5235 current_lang_base = VEC_alloc (tree, gc, 10);
5236 current_lang_name = lang_name_cplusplus;
5237 current_namespace = global_namespace;
5238 push_class_stack ();
5239 skip_evaluation = 0;
5240 timevar_pop (TV_NAME_LOOKUP);
5244 pop_from_top_level (void)
5246 struct saved_scope *s = scope_chain;
5247 cxx_saved_binding *saved;
5250 timevar_push (TV_NAME_LOOKUP);
5251 /* Clear out class-level bindings cache. */
5252 if (previous_class_level)
5253 invalidate_class_lookup_cache ();
5256 current_lang_base = 0;
5258 scope_chain = s->prev;
5259 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5261 tree id = saved->identifier;
5263 IDENTIFIER_BINDING (id) = saved->binding;
5264 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5267 /* If we were in the middle of compiling a function, restore our
5269 if (s->need_pop_function_context)
5270 pop_function_context ();
5271 current_function_decl = s->function_decl;
5272 skip_evaluation = s->skip_evaluation;
5273 timevar_pop (TV_NAME_LOOKUP);
5276 /* Pop off extraneous binding levels left over due to syntax errors.
5278 We don't pop past namespaces, as they might be valid. */
5281 pop_everything (void)
5283 if (ENABLE_SCOPE_CHECKING)
5284 verbatim ("XXX entering pop_everything ()\n");
5285 while (!toplevel_bindings_p ())
5287 if (current_binding_level->kind == sk_class)
5288 pop_nested_class ();
5292 if (ENABLE_SCOPE_CHECKING)
5293 verbatim ("XXX leaving pop_everything ()\n");
5296 /* Emit debugging information for using declarations and directives.
5297 If input tree is overloaded fn then emit debug info for all
5301 cp_emit_debug_info_for_using (tree t, tree context)
5303 /* Don't try to emit any debug information if we have errors. */
5304 if (sorrycount || errorcount)
5307 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5308 of a builtin function. */
5309 if (TREE_CODE (t) == FUNCTION_DECL
5310 && DECL_EXTERNAL (t)
5311 && DECL_BUILT_IN (t))
5314 /* Do not supply context to imported_module_or_decl, if
5315 it is a global namespace. */
5316 if (context == global_namespace)
5317 context = NULL_TREE;
5320 t = BASELINK_FUNCTIONS (t);
5322 /* FIXME: Handle TEMPLATE_DECLs. */
5323 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5324 if (TREE_CODE (t) != TEMPLATE_DECL)
5325 (*debug_hooks->imported_module_or_decl) (t, context);
5328 #include "gt-cp-name-lookup.h"