1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
35 /* The bindings for a particular name in a particular scope. */
37 struct scope_binding {
41 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
43 static cxx_scope *innermost_nonclass_level (void);
44 static tree select_decl (const struct scope_binding *, int);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree lookup_name_innermost_nonclass_level (tree);
47 static tree push_overloaded_decl (tree, int);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
64 /* Compute the chain index of a binding_entry given the HASH value of its
65 name and the total COUNT of chains. COUNT is assumed to be a power
68 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
70 /* A free list of "binding_entry"s awaiting for re-use. */
72 static GTY((deletable)) binding_entry free_binding_entry = NULL;
74 /* Create a binding_entry object for (NAME, TYPE). */
76 static inline binding_entry
77 binding_entry_make (tree name, tree type)
81 if (free_binding_entry)
83 entry = free_binding_entry;
84 free_binding_entry = entry->chain;
87 entry = GGC_NEW (struct binding_entry_s);
96 /* Put ENTRY back on the free list. */
99 binding_entry_free (binding_entry entry)
103 entry->chain = free_binding_entry;
104 free_binding_entry = entry;
108 /* The datatype used to implement the mapping from names to types at
110 struct binding_table_s GTY(())
112 /* Array of chains of "binding_entry"s */
113 binding_entry * GTY((length ("%h.chain_count"))) chain;
115 /* The number of chains in this table. This is the length of the
116 the member "chain" considered as an array. */
119 /* Number of "binding_entry"s in this table. */
123 /* Construct TABLE with an initial CHAIN_COUNT. */
126 binding_table_construct (binding_table table, size_t chain_count)
128 table->chain_count = chain_count;
129 table->entry_count = 0;
130 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
133 /* Make TABLE's entries ready for reuse. */
136 binding_table_free (binding_table table)
144 for (i = 0, count = table->chain_count; i < count; ++i)
146 binding_entry temp = table->chain[i];
149 binding_entry entry = temp;
151 binding_entry_free (entry);
153 table->chain[i] = NULL;
155 table->entry_count = 0;
159 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
161 static inline binding_table
162 binding_table_new (size_t chain_count)
164 binding_table table = GGC_NEW (struct binding_table_s);
166 binding_table_construct (table, chain_count);
170 /* Expand TABLE to twice its current chain_count. */
173 binding_table_expand (binding_table table)
175 const size_t old_chain_count = table->chain_count;
176 const size_t old_entry_count = table->entry_count;
177 const size_t new_chain_count = 2 * old_chain_count;
178 binding_entry *old_chains = table->chain;
181 binding_table_construct (table, new_chain_count);
182 for (i = 0; i < old_chain_count; ++i)
184 binding_entry entry = old_chains[i];
185 for (; entry != NULL; entry = old_chains[i])
187 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
188 const size_t j = ENTRY_INDEX (hash, new_chain_count);
190 old_chains[i] = entry->chain;
191 entry->chain = table->chain[j];
192 table->chain[j] = entry;
195 table->entry_count = old_entry_count;
198 /* Insert a binding for NAME to TYPE into TABLE. */
201 binding_table_insert (binding_table table, tree name, tree type)
203 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
204 const size_t i = ENTRY_INDEX (hash, table->chain_count);
205 binding_entry entry = binding_entry_make (name, type);
207 entry->chain = table->chain[i];
208 table->chain[i] = entry;
209 ++table->entry_count;
211 if (3 * table->chain_count < 5 * table->entry_count)
212 binding_table_expand (table);
215 /* Return the binding_entry, if any, that maps NAME. */
218 binding_table_find (binding_table table, tree name)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
223 while (entry != NULL && entry->name != name)
224 entry = entry->chain;
229 /* Apply PROC -- with DATA -- to all entries in TABLE. */
232 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
234 const size_t chain_count = table->chain_count;
237 for (i = 0; i < chain_count; ++i)
239 binding_entry entry = table->chain[i];
240 for (; entry != NULL; entry = entry->chain)
245 #ifndef ENABLE_SCOPE_CHECKING
246 # define ENABLE_SCOPE_CHECKING 0
248 # define ENABLE_SCOPE_CHECKING 1
251 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
253 static GTY((deletable)) cxx_binding *free_bindings;
255 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
259 cxx_binding_init (cxx_binding *binding, tree value, tree type)
261 binding->value = value;
262 binding->type = type;
263 binding->previous = NULL;
266 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
269 cxx_binding_make (tree value, tree type)
271 cxx_binding *binding;
274 binding = free_bindings;
275 free_bindings = binding->previous;
278 binding = GGC_NEW (cxx_binding);
280 cxx_binding_init (binding, value, type);
285 /* Put BINDING back on the free list. */
288 cxx_binding_free (cxx_binding *binding)
290 binding->scope = NULL;
291 binding->previous = free_bindings;
292 free_bindings = binding;
295 /* Create a new binding for NAME (with the indicated VALUE and TYPE
296 bindings) in the class scope indicated by SCOPE. */
299 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
301 cp_class_binding *cb;
302 cxx_binding *binding;
304 if (VEC_length (cp_class_binding, scope->class_shadowed))
306 cp_class_binding *old_base;
307 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
308 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
310 /* Fixup the current bindings, as they might have moved. */
314 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
318 b = &IDENTIFIER_BINDING (cb->identifier);
319 while (*b != &old_base[i].base)
320 b = &((*b)->previous);
324 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
327 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
329 cb->identifier = name;
331 binding->scope = scope;
332 cxx_binding_init (binding, value, type);
336 /* Make DECL the innermost binding for ID. The LEVEL is the binding
337 level at which this declaration is being bound. */
340 push_binding (tree id, tree decl, cxx_scope* level)
342 cxx_binding *binding;
344 if (level != class_binding_level)
346 binding = cxx_binding_make (decl, NULL_TREE);
347 binding->scope = level;
350 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
352 /* Now, fill in the binding information. */
353 binding->previous = IDENTIFIER_BINDING (id);
354 INHERITED_VALUE_BINDING_P (binding) = 0;
355 LOCAL_BINDING_P (binding) = (level != class_binding_level);
357 /* And put it on the front of the list of bindings for ID. */
358 IDENTIFIER_BINDING (id) = binding;
361 /* Remove the binding for DECL which should be the innermost binding
365 pop_binding (tree id, tree decl)
367 cxx_binding *binding;
370 /* It's easiest to write the loops that call this function without
371 checking whether or not the entities involved have names. We
372 get here for such an entity. */
375 /* Get the innermost binding for ID. */
376 binding = IDENTIFIER_BINDING (id);
378 /* The name should be bound. */
379 gcc_assert (binding != NULL);
381 /* The DECL will be either the ordinary binding or the type
382 binding for this identifier. Remove that binding. */
383 if (binding->value == decl)
384 binding->value = NULL_TREE;
387 gcc_assert (binding->type == decl);
388 binding->type = NULL_TREE;
391 if (!binding->value && !binding->type)
393 /* We're completely done with the innermost binding for this
394 identifier. Unhook it from the list of bindings. */
395 IDENTIFIER_BINDING (id) = binding->previous;
397 /* Add it to the free list. */
398 cxx_binding_free (binding);
402 /* BINDING records an existing declaration for a name in the current scope.
403 But, DECL is another declaration for that same identifier in the
404 same scope. This is the `struct stat' hack whereby a non-typedef
405 class name or enum-name can be bound at the same level as some other
409 A class name (9.1) or enumeration name (7.2) can be hidden by the
410 name of an object, function, or enumerator declared in the same scope.
411 If a class or enumeration name and an object, function, or enumerator
412 are declared in the same scope (in any order) with the same name, the
413 class or enumeration name is hidden wherever the object, function, or
414 enumerator name is visible.
416 It's the responsibility of the caller to check that
417 inserting this name is valid here. Returns nonzero if the new binding
421 supplement_binding (cxx_binding *binding, tree decl)
423 tree bval = binding->value;
426 timevar_push (TV_NAME_LOOKUP);
427 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
428 /* The new name is the type name. */
429 binding->type = decl;
430 else if (/* BVAL is null when push_class_level_binding moves an
431 inherited type-binding out of the way to make room for a
432 new value binding. */
434 /* BVAL is error_mark_node when DECL's name has been used
435 in a non-class scope prior declaration. In that case,
436 we should have already issued a diagnostic; for graceful
437 error recovery purpose, pretend this was the intended
438 declaration for that name. */
439 || bval == error_mark_node
440 /* If BVAL is a built-in that has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval)))
444 binding->value = decl;
445 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
447 /* The old binding was a type name. It was placed in
448 VALUE field because it was thought, at the point it was
449 declared, to be the only entity with such a name. Move the
450 type name into the type slot; it is now hidden by the new
452 binding->type = bval;
453 binding->value = decl;
454 binding->value_is_inherited = false;
456 else if (TREE_CODE (bval) == TYPE_DECL
457 && TREE_CODE (decl) == TYPE_DECL
458 && DECL_NAME (decl) == DECL_NAME (bval)
459 && binding->scope->kind != sk_class
460 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
461 /* If either type involves template parameters, we must
462 wait until instantiation. */
463 || uses_template_parms (TREE_TYPE (decl))
464 || uses_template_parms (TREE_TYPE (bval))))
465 /* We have two typedef-names, both naming the same type to have
466 the same name. In general, this is OK because of:
470 In a given scope, a typedef specifier can be used to redefine
471 the name of any type declared in that scope to refer to the
472 type to which it already refers.
474 However, in class scopes, this rule does not apply due to the
475 stricter language in [class.mem] prohibiting redeclarations of
478 /* There can be two block-scope declarations of the same variable,
479 so long as they are `extern' declarations. However, there cannot
480 be two declarations of the same static data member:
484 A member shall not be declared twice in the
485 member-specification. */
486 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
487 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
488 && !DECL_CLASS_SCOPE_P (decl))
490 duplicate_decls (decl, binding->value);
493 else if (TREE_CODE (decl) == NAMESPACE_DECL
494 && TREE_CODE (bval) == NAMESPACE_DECL
495 && DECL_NAMESPACE_ALIAS (decl)
496 && DECL_NAMESPACE_ALIAS (bval)
497 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
500 In a declarative region, a namespace-alias-definition can be
501 used to redefine a namespace-alias declared in that declarative
502 region to refer only to the namespace to which it already
507 error ("declaration of %q#D", decl);
508 error ("conflicts with previous declaration %q+#D", bval);
512 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
515 /* Add DECL to the list of things declared in B. */
518 add_decl_to_level (tree decl, cxx_scope *b)
520 if (TREE_CODE (decl) == NAMESPACE_DECL
521 && !DECL_NAMESPACE_ALIAS (decl))
523 TREE_CHAIN (decl) = b->namespaces;
524 b->namespaces = decl;
526 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
528 TREE_CHAIN (decl) = b->vtables;
533 /* We build up the list in reverse order, and reverse it later if
535 TREE_CHAIN (decl) = b->names;
539 /* If appropriate, add decl to separate list of statics. We
540 include extern variables because they might turn out to be
541 static later. It's OK for this list to contain a few false
543 if (b->kind == sk_namespace)
544 if ((TREE_CODE (decl) == VAR_DECL
545 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
546 || (TREE_CODE (decl) == FUNCTION_DECL
547 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
548 VEC_safe_push (tree, gc, b->static_decls, decl);
552 /* Record a decl-node X as belonging to the current lexical scope.
553 Check for errors (such as an incompatible declaration for the same
554 name already seen in the same scope).
556 Returns either X or an old decl for the same name.
557 If an old decl is returned, it may have been smashed
558 to agree with what X says. */
565 int need_new_binding;
567 timevar_push (TV_NAME_LOOKUP);
569 need_new_binding = 1;
571 if (DECL_TEMPLATE_PARM_P (x))
572 /* Template parameters have no context; they are not X::T even
573 when declared within a class or namespace. */
577 if (current_function_decl && x != current_function_decl
578 /* A local declaration for a function doesn't constitute
580 && TREE_CODE (x) != FUNCTION_DECL
581 /* A local declaration for an `extern' variable is in the
582 scope of the current namespace, not the current
584 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
585 && !DECL_CONTEXT (x))
586 DECL_CONTEXT (x) = current_function_decl;
588 /* If this is the declaration for a namespace-scope function,
589 but the declaration itself is in a local scope, mark the
591 if (TREE_CODE (x) == FUNCTION_DECL
592 && DECL_NAMESPACE_SCOPE_P (x)
593 && current_function_decl
594 && x != current_function_decl)
595 DECL_LOCAL_FUNCTION_P (x) = 1;
598 name = DECL_NAME (x);
601 int different_binding_level = 0;
603 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
604 name = TREE_OPERAND (name, 0);
606 /* In case this decl was explicitly namespace-qualified, look it
607 up in its namespace context. */
608 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
609 t = namespace_binding (name, DECL_CONTEXT (x));
611 t = lookup_name_innermost_nonclass_level (name);
613 /* [basic.link] If there is a visible declaration of an entity
614 with linkage having the same name and type, ignoring entities
615 declared outside the innermost enclosing namespace scope, the
616 block scope declaration declares that same entity and
617 receives the linkage of the previous declaration. */
618 if (! t && current_function_decl && x != current_function_decl
619 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
620 && DECL_EXTERNAL (x))
622 /* Look in block scope. */
623 t = innermost_non_namespace_value (name);
624 /* Or in the innermost namespace. */
626 t = namespace_binding (name, DECL_CONTEXT (x));
627 /* Does it have linkage? Note that if this isn't a DECL, it's an
628 OVERLOAD, which is OK. */
629 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
632 different_binding_level = 1;
635 /* If we are declaring a function, and the result of name-lookup
636 was an OVERLOAD, look for an overloaded instance that is
637 actually the same as the function we are declaring. (If
638 there is one, we have to merge our declaration with the
639 previous declaration.) */
640 if (t && TREE_CODE (t) == OVERLOAD)
644 if (TREE_CODE (x) == FUNCTION_DECL)
645 for (match = t; match; match = OVL_NEXT (match))
647 if (decls_match (OVL_CURRENT (match), x))
651 /* Just choose one. */
655 t = OVL_CURRENT (match);
660 if (t && t != error_mark_node)
662 if (different_binding_level)
664 if (decls_match (x, t))
665 /* The standard only says that the local extern
666 inherits linkage from the previous decl; in
667 particular, default args are not shared. We must
668 also tell cgraph to treat these decls as the same,
669 or we may neglect to emit an "unused" static - we
670 do this by making the DECL_UIDs equal, which should
671 be viewed as a kludge. FIXME. */
673 TREE_PUBLIC (x) = TREE_PUBLIC (t);
674 DECL_UID (x) = DECL_UID (t);
677 else if (TREE_CODE (t) == PARM_DECL)
679 gcc_assert (DECL_CONTEXT (t));
681 /* Check for duplicate params. */
682 if (duplicate_decls (x, t))
683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
685 else if ((DECL_EXTERN_C_FUNCTION_P (x)
686 || DECL_FUNCTION_TEMPLATE_P (x))
687 && is_overloaded_fn (t))
688 /* Don't do anything just yet. */;
689 else if (t == wchar_decl_node)
691 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
692 pedwarn ("redeclaration of %<wchar_t%> as %qT",
695 /* Throw away the redeclaration. */
696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
700 tree olddecl = duplicate_decls (x, t);
702 /* If the redeclaration failed, we can stop at this
704 if (olddecl == error_mark_node)
705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
709 if (TREE_CODE (t) == TYPE_DECL)
710 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
711 else if (TREE_CODE (t) == FUNCTION_DECL)
712 check_default_args (t);
714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
716 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
718 /* A redeclaration of main, but not a duplicate of the
723 This function shall not be overloaded. */
724 error ("invalid redeclaration of %q+D", t);
726 /* We don't try to push this declaration since that
728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
733 check_template_shadow (x);
735 /* If this is a function conjured up by the backend, massage it
736 so it looks friendly. */
737 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
739 retrofit_lang_decl (x);
740 SET_DECL_LANGUAGE (x, lang_c);
743 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
745 t = push_overloaded_decl (x, PUSH_LOCAL);
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
748 if (!namespace_bindings_p ())
749 /* We do not need to create a binding for this name;
750 push_overloaded_decl will have already done so if
752 need_new_binding = 0;
754 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
756 t = push_overloaded_decl (x, PUSH_GLOBAL);
758 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
759 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
762 /* If declaring a type as a typedef, copy the type (unless we're
763 at line 0), and install this TYPE_DECL as the new type's typedef
764 name. See the extensive comment in ../c-decl.c (pushdecl). */
765 if (TREE_CODE (x) == TYPE_DECL)
767 tree type = TREE_TYPE (x);
768 if (DECL_IS_BUILTIN (x))
770 if (TYPE_NAME (type) == 0)
771 TYPE_NAME (type) = x;
773 else if (type != error_mark_node && TYPE_NAME (type) != x
774 /* We don't want to copy the type when all we're
775 doing is making a TYPE_DECL for the purposes of
777 && (!TYPE_NAME (type)
778 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
780 DECL_ORIGINAL_TYPE (x) = type;
781 type = build_variant_type_copy (type);
782 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
783 TYPE_NAME (type) = x;
784 TREE_TYPE (x) = type;
787 if (type != error_mark_node
789 && TYPE_IDENTIFIER (type))
790 set_identifier_type_value (DECL_NAME (x), x);
793 /* Multiple external decls of the same identifier ought to match.
795 We get warnings about inline functions where they are defined.
796 We get warnings about other functions from push_overloaded_decl.
798 Avoid duplicate warnings where they are used. */
799 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
803 decl = IDENTIFIER_NAMESPACE_VALUE (name);
804 if (decl && TREE_CODE (decl) == OVERLOAD)
805 decl = OVL_FUNCTION (decl);
807 if (decl && decl != error_mark_node
808 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
809 /* If different sort of thing, we already gave an error. */
810 && TREE_CODE (decl) == TREE_CODE (x)
811 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
813 pedwarn ("type mismatch with previous external decl of %q#D", x);
814 pedwarn ("previous external decl of %q+#D", decl);
818 /* This name is new in its binding level.
819 Install the new declaration and return it. */
820 if (namespace_bindings_p ())
822 /* Install a global value. */
824 /* If the first global decl has external linkage,
825 warn if we later see static one. */
826 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
827 TREE_PUBLIC (name) = 1;
829 /* Bind the name for the entity. */
830 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
832 && (TREE_CODE (x) == TYPE_DECL
833 || TREE_CODE (x) == VAR_DECL
834 || TREE_CODE (x) == NAMESPACE_DECL
835 || TREE_CODE (x) == CONST_DECL
836 || TREE_CODE (x) == TEMPLATE_DECL))
837 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
839 /* If new decl is `static' and an `extern' was seen previously,
841 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
842 warn_extern_redeclared_static (x, t);
846 /* Here to install a non-global value. */
847 tree oldlocal = innermost_non_namespace_value (name);
848 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
850 if (need_new_binding)
852 push_local_binding (name, x, 0);
853 /* Because push_local_binding will hook X on to the
854 current_binding_level's name list, we don't want to
855 do that again below. */
856 need_new_binding = 0;
859 /* If this is a TYPE_DECL, push it into the type value slot. */
860 if (TREE_CODE (x) == TYPE_DECL)
861 set_identifier_type_value (name, x);
863 /* Clear out any TYPE_DECL shadowed by a namespace so that
864 we won't think this is a type. The C struct hack doesn't
865 go through namespaces. */
866 if (TREE_CODE (x) == NAMESPACE_DECL)
867 set_identifier_type_value (name, NULL_TREE);
874 && TREE_CODE (oldlocal) == VAR_DECL
875 && DECL_DEAD_FOR_LOCAL (oldlocal))
876 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
878 if (oldlocal == NULL_TREE)
879 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
882 /* If this is an extern function declaration, see if we
883 have a global definition or declaration for the function. */
884 if (oldlocal == NULL_TREE
886 && oldglobal != NULL_TREE
887 && TREE_CODE (x) == FUNCTION_DECL
888 && TREE_CODE (oldglobal) == FUNCTION_DECL)
890 /* We have one. Their types must agree. */
891 if (decls_match (x, oldglobal))
895 warning (0, "extern declaration of %q#D doesn't match", x);
896 warning (0, "global declaration %q+#D", oldglobal);
899 /* If we have a local external declaration,
900 and no file-scope declaration has yet been seen,
901 then if we later have a file-scope decl it must not be static. */
902 if (oldlocal == NULL_TREE
903 && oldglobal == NULL_TREE
906 TREE_PUBLIC (name) = 1;
908 /* Warn if shadowing an argument at the top level of the body. */
909 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
910 /* Inline decls shadow nothing. */
911 && !DECL_FROM_INLINE (x)
912 && TREE_CODE (oldlocal) == PARM_DECL
913 /* Don't check the `this' parameter. */
914 && !DECL_ARTIFICIAL (oldlocal))
918 /* Don't complain if it's from an enclosing function. */
919 if (DECL_CONTEXT (oldlocal) == current_function_decl
920 && TREE_CODE (x) != PARM_DECL)
922 /* Go to where the parms should be and see if we find
924 struct cp_binding_level *b = current_binding_level->level_chain;
926 /* Skip the ctor/dtor cleanup level. */
930 if (b->kind == sk_function_parms)
932 error ("declaration of %q#D shadows a parameter", x);
937 if (warn_shadow && !err)
939 warning (0, "declaration of %q#D shadows a parameter", x);
940 warning (0, "%Jshadowed declaration is here", oldlocal);
944 /* Maybe warn if shadowing something else. */
945 else if (warn_shadow && !DECL_EXTERNAL (x)
946 /* No shadow warnings for internally generated vars. */
947 && ! DECL_ARTIFICIAL (x)
948 /* No shadow warnings for vars made for inlining. */
949 && ! DECL_FROM_INLINE (x))
953 if (current_class_ptr)
954 member = lookup_member (current_class_type,
957 /*want_type=*/false);
961 if (member && !TREE_STATIC (member))
963 /* Location of previous decl is not useful in this case. */
964 warning (0, "declaration of %qD shadows a member of 'this'",
967 else if (oldlocal != NULL_TREE
968 && TREE_CODE (oldlocal) == VAR_DECL)
970 warning (0, "declaration of %qD shadows a previous local", x);
971 warning (0, "%Jshadowed declaration is here", oldlocal);
973 else if (oldglobal != NULL_TREE
974 && TREE_CODE (oldglobal) == VAR_DECL)
975 /* XXX shadow warnings in outer-more namespaces */
977 warning (0, "declaration of %qD shadows a global declaration",
979 warning (0, "%Jshadowed declaration is here", oldglobal);
984 if (TREE_CODE (x) == FUNCTION_DECL)
985 check_default_args (x);
987 if (TREE_CODE (x) == VAR_DECL)
988 maybe_register_incomplete_var (x);
991 if (need_new_binding)
992 add_decl_to_level (x,
993 DECL_NAMESPACE_SCOPE_P (x)
994 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
995 : current_binding_level);
997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1000 /* Enter DECL into the symbol table, if that's appropriate. Returns
1001 DECL, or a modified version thereof. */
1004 maybe_push_decl (tree decl)
1006 tree type = TREE_TYPE (decl);
1008 /* Add this decl to the current binding level, but not if it comes
1009 from another scope, e.g. a static member variable. TEM may equal
1010 DECL or it may be a previous decl of the same name. */
1011 if (decl == error_mark_node
1012 || (TREE_CODE (decl) != PARM_DECL
1013 && DECL_CONTEXT (decl) != NULL_TREE
1014 /* Definitions of namespace members outside their namespace are
1016 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1017 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1018 || TREE_CODE (type) == UNKNOWN_TYPE
1019 /* The declaration of a template specialization does not affect
1020 the functions available for overload resolution, so we do not
1022 || (TREE_CODE (decl) == FUNCTION_DECL
1023 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1026 return pushdecl (decl);
1029 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1030 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1031 doesn't really belong to this binding level, that it got here
1032 through a using-declaration. */
1035 push_local_binding (tree id, tree decl, int flags)
1037 struct cp_binding_level *b;
1039 /* Skip over any local classes. This makes sense if we call
1040 push_local_binding with a friend decl of a local class. */
1041 b = innermost_nonclass_level ();
1043 if (lookup_name_innermost_nonclass_level (id))
1045 /* Supplement the existing binding. */
1046 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1047 /* It didn't work. Something else must be bound at this
1048 level. Do not add DECL to the list of things to pop
1053 /* Create a new binding. */
1054 push_binding (id, decl, b);
1056 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1057 /* We must put the OVERLOAD into a TREE_LIST since the
1058 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1059 decls that got here through a using-declaration. */
1060 decl = build_tree_list (NULL_TREE, decl);
1062 /* And put DECL on the list of things declared by the current
1064 add_decl_to_level (decl, b);
1067 /* Check to see whether or not DECL is a variable that would have been
1068 in scope under the ARM, but is not in scope under the ANSI/ISO
1069 standard. If so, issue an error message. If name lookup would
1070 work in both cases, but return a different result, this function
1071 returns the result of ANSI/ISO lookup. Otherwise, it returns
1075 check_for_out_of_scope_variable (tree decl)
1079 /* We only care about out of scope variables. */
1080 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1083 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1084 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1085 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1086 && DECL_DEAD_FOR_LOCAL (shadowed))
1087 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1088 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1090 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1093 if (!DECL_ERROR_REPORTED (decl))
1095 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1096 warning (0, " matches this %q+D under ISO standard rules",
1098 warning (0, " matches this %q+D under old rules", decl);
1099 DECL_ERROR_REPORTED (decl) = 1;
1104 /* If we have already complained about this declaration, there's no
1105 need to do it again. */
1106 if (DECL_ERROR_REPORTED (decl))
1109 DECL_ERROR_REPORTED (decl) = 1;
1111 if (TREE_TYPE (decl) == error_mark_node)
1114 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1116 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1118 error (" cannot use obsolete binding at %q+D because "
1119 "it has a destructor", decl);
1120 return error_mark_node;
1124 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1126 pedwarn (" using obsolete binding at %q+D", decl);
1132 /* true means unconditionally make a BLOCK for the next level pushed. */
1134 static bool keep_next_level_flag;
1136 static int binding_depth = 0;
1137 static int is_class_level = 0;
1144 for (i = 0; i < depth * 2; i++)
1148 /* Return a string describing the kind of SCOPE we have. */
1150 cxx_scope_descriptor (cxx_scope *scope)
1152 /* The order of this table must match the "scope_kind"
1154 static const char* scope_kind_names[] = {
1160 "function-parameter-scope",
1163 "template-parameter-scope",
1164 "template-explicit-spec-scope"
1166 const scope_kind kind = scope->explicit_spec_p
1167 ? sk_template_spec : scope->kind;
1169 return scope_kind_names[kind];
1172 /* Output a debugging information about SCOPE when performing
1175 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1177 const char *desc = cxx_scope_descriptor (scope);
1178 if (scope->this_entity)
1179 verbatim ("%s %s(%E) %p %d\n", action, desc,
1180 scope->this_entity, (void *) scope, line);
1182 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1185 /* Return the estimated initial size of the hashtable of a NAMESPACE
1188 static inline size_t
1189 namespace_scope_ht_size (tree ns)
1191 tree name = DECL_NAME (ns);
1193 return name == std_identifier
1194 ? NAMESPACE_STD_HT_SIZE
1195 : (name == global_scope_name
1196 ? GLOBAL_SCOPE_HT_SIZE
1197 : NAMESPACE_ORDINARY_HT_SIZE);
1200 /* A chain of binding_level structures awaiting reuse. */
1202 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1204 /* Insert SCOPE as the innermost binding level. */
1207 push_binding_level (struct cp_binding_level *scope)
1209 /* Add it to the front of currently active scopes stack. */
1210 scope->level_chain = current_binding_level;
1211 current_binding_level = scope;
1212 keep_next_level_flag = false;
1214 if (ENABLE_SCOPE_CHECKING)
1216 scope->binding_depth = binding_depth;
1217 indent (binding_depth);
1218 cxx_scope_debug (scope, input_line, "push");
1224 /* Create a new KIND scope and make it the top of the active scopes stack.
1225 ENTITY is the scope of the associated C++ entity (namespace, class,
1226 function); it is NULL otherwise. */
1229 begin_scope (scope_kind kind, tree entity)
1233 /* Reuse or create a struct for this binding level. */
1234 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1236 scope = free_binding_level;
1237 free_binding_level = scope->level_chain;
1240 scope = GGC_NEW (cxx_scope);
1241 memset (scope, 0, sizeof (cxx_scope));
1243 scope->this_entity = entity;
1244 scope->more_cleanups_ok = true;
1251 case sk_template_spec:
1252 scope->explicit_spec_p = true;
1253 kind = sk_template_parms;
1255 case sk_template_parms:
1261 case sk_function_parms:
1262 scope->keep = keep_next_level_flag;
1266 NAMESPACE_LEVEL (entity) = scope;
1267 scope->static_decls =
1268 VEC_alloc (tree, gc,
1269 DECL_NAME (entity) == std_identifier
1270 || DECL_NAME (entity) == global_scope_name
1275 /* Should not happen. */
1281 push_binding_level (scope);
1286 /* We're about to leave current scope. Pop the top of the stack of
1287 currently active scopes. Return the enclosing scope, now active. */
1292 cxx_scope *scope = current_binding_level;
1294 if (scope->kind == sk_namespace && class_binding_level)
1295 current_binding_level = class_binding_level;
1297 /* We cannot leave a scope, if there are none left. */
1298 if (NAMESPACE_LEVEL (global_namespace))
1299 gcc_assert (!global_scope_p (scope));
1301 if (ENABLE_SCOPE_CHECKING)
1303 indent (--binding_depth);
1304 cxx_scope_debug (scope, input_line, "leave");
1305 if (is_class_level != (scope == class_binding_level))
1307 indent (binding_depth);
1308 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1313 /* Move one nesting level up. */
1314 current_binding_level = scope->level_chain;
1316 /* Namespace-scopes are left most probably temporarily, not
1317 completely; they can be reopen later, e.g. in namespace-extension
1318 or any name binding activity that requires us to resume a
1319 namespace. For classes, we cache some binding levels. For other
1320 scopes, we just make the structure available for reuse. */
1321 if (scope->kind != sk_namespace
1322 && scope->kind != sk_class)
1324 scope->level_chain = free_binding_level;
1325 gcc_assert (!ENABLE_SCOPE_CHECKING
1326 || scope->binding_depth == binding_depth);
1327 free_binding_level = scope;
1330 /* Find the innermost enclosing class scope, and reset
1331 CLASS_BINDING_LEVEL appropriately. */
1332 if (scope->kind == sk_class)
1334 class_binding_level = NULL;
1335 for (scope = current_binding_level; scope; scope = scope->level_chain)
1336 if (scope->kind == sk_class)
1338 class_binding_level = scope;
1343 return current_binding_level;
1347 resume_scope (struct cp_binding_level* b)
1349 /* Resuming binding levels is meant only for namespaces,
1350 and those cannot nest into classes. */
1351 gcc_assert (!class_binding_level);
1352 /* Also, resuming a non-directly nested namespace is a no-no. */
1353 gcc_assert (b->level_chain == current_binding_level);
1354 current_binding_level = b;
1355 if (ENABLE_SCOPE_CHECKING)
1357 b->binding_depth = binding_depth;
1358 indent (binding_depth);
1359 cxx_scope_debug (b, input_line, "resume");
1365 /* Return the innermost binding level that is not for a class scope. */
1368 innermost_nonclass_level (void)
1372 b = current_binding_level;
1373 while (b->kind == sk_class)
1379 /* We're defining an object of type TYPE. If it needs a cleanup, but
1380 we're not allowed to add any more objects with cleanups to the current
1381 scope, create a new binding level. */
1384 maybe_push_cleanup_level (tree type)
1386 if (type != error_mark_node
1387 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1388 && current_binding_level->more_cleanups_ok == 0)
1390 begin_scope (sk_cleanup, NULL);
1391 current_binding_level->statement_list = push_stmt_list ();
1395 /* Nonzero if we are currently in the global binding level. */
1398 global_bindings_p (void)
1400 return global_scope_p (current_binding_level);
1403 /* True if we are currently in a toplevel binding level. This
1404 means either the global binding level or a namespace in a toplevel
1405 binding level. Since there are no non-toplevel namespace levels,
1406 this really means any namespace or template parameter level. We
1407 also include a class whose context is toplevel. */
1410 toplevel_bindings_p (void)
1412 struct cp_binding_level *b = innermost_nonclass_level ();
1414 return b->kind == sk_namespace || b->kind == sk_template_parms;
1417 /* True if this is a namespace scope, or if we are defining a class
1418 which is itself at namespace scope, or whose enclosing class is
1419 such a class, etc. */
1422 namespace_bindings_p (void)
1424 struct cp_binding_level *b = innermost_nonclass_level ();
1426 return b->kind == sk_namespace;
1429 /* True if the current level needs to have a BLOCK made. */
1434 return (current_binding_level->blocks != NULL_TREE
1435 || current_binding_level->keep
1436 || current_binding_level->kind == sk_cleanup
1437 || current_binding_level->names != NULL_TREE);
1440 /* Returns the kind of the innermost scope. */
1443 innermost_scope_kind (void)
1445 return current_binding_level->kind;
1448 /* Returns true if this scope was created to store template parameters. */
1451 template_parm_scope_p (void)
1453 return innermost_scope_kind () == sk_template_parms;
1456 /* If KEEP is true, make a BLOCK node for the next binding level,
1457 unconditionally. Otherwise, use the normal logic to decide whether
1458 or not to create a BLOCK. */
1461 keep_next_level (bool keep)
1463 keep_next_level_flag = keep;
1466 /* Return the list of declarations of the current level.
1467 Note that this list is in reverse order unless/until
1468 you nreverse it; and when you do nreverse it, you must
1469 store the result back using `storedecls' or you will lose. */
1474 return current_binding_level->names;
1477 /* For debugging. */
1478 static int no_print_functions = 0;
1479 static int no_print_builtins = 0;
1482 print_binding_level (struct cp_binding_level* lvl)
1486 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1487 if (lvl->more_cleanups_ok)
1488 fprintf (stderr, " more-cleanups-ok");
1489 if (lvl->have_cleanups)
1490 fprintf (stderr, " have-cleanups");
1491 fprintf (stderr, "\n");
1494 fprintf (stderr, " names:\t");
1495 /* We can probably fit 3 names to a line? */
1496 for (t = lvl->names; t; t = TREE_CHAIN (t))
1498 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1500 if (no_print_builtins
1501 && (TREE_CODE (t) == TYPE_DECL)
1502 && DECL_IS_BUILTIN (t))
1505 /* Function decls tend to have longer names. */
1506 if (TREE_CODE (t) == FUNCTION_DECL)
1513 fprintf (stderr, "\n\t");
1516 print_node_brief (stderr, "", t, 0);
1517 if (t == error_mark_node)
1521 fprintf (stderr, "\n");
1523 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1526 cp_class_binding *b;
1527 fprintf (stderr, " class-shadowed:");
1529 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1531 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1532 fprintf (stderr, "\n");
1534 if (lvl->type_shadowed)
1536 fprintf (stderr, " type-shadowed:");
1537 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1539 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1541 fprintf (stderr, "\n");
1546 print_other_binding_stack (struct cp_binding_level *stack)
1548 struct cp_binding_level *level;
1549 for (level = stack; !global_scope_p (level); level = level->level_chain)
1551 fprintf (stderr, "binding level %p\n", (void *) level);
1552 print_binding_level (level);
1557 print_binding_stack (void)
1559 struct cp_binding_level *b;
1560 fprintf (stderr, "current_binding_level=%p\n"
1561 "class_binding_level=%p\n"
1562 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1563 (void *) current_binding_level, (void *) class_binding_level,
1564 (void *) NAMESPACE_LEVEL (global_namespace));
1565 if (class_binding_level)
1567 for (b = class_binding_level; b; b = b->level_chain)
1568 if (b == current_binding_level)
1571 b = class_binding_level;
1573 b = current_binding_level;
1576 b = current_binding_level;
1577 print_other_binding_stack (b);
1578 fprintf (stderr, "global:\n");
1579 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1582 /* Return the type associated with id. */
1585 identifier_type_value (tree id)
1587 timevar_push (TV_NAME_LOOKUP);
1588 /* There is no type with that name, anywhere. */
1589 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1590 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1591 /* This is not the type marker, but the real thing. */
1592 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1593 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1594 /* Have to search for it. It must be on the global level, now.
1595 Ask lookup_name not to return non-types. */
1596 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1598 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1602 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1603 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1606 identifier_global_value (tree t)
1608 return IDENTIFIER_GLOBAL_VALUE (t);
1611 /* Push a definition of struct, union or enum tag named ID. into
1612 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1613 the tag ID is not already defined. */
1616 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1620 if (b->kind != sk_namespace)
1622 /* Shadow the marker, not the real thing, so that the marker
1623 gets restored later. */
1624 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1626 = tree_cons (id, old_type_value, b->type_shadowed);
1627 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1628 TREE_TYPE (b->type_shadowed) = type;
1632 cxx_binding *binding =
1633 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1636 supplement_binding (binding, decl);
1638 binding->value = decl;
1640 /* Store marker instead of real type. */
1641 type = global_type_node;
1643 SET_IDENTIFIER_TYPE_VALUE (id, type);
1646 /* As set_identifier_type_value_with_scope, but using
1647 current_binding_level. */
1650 set_identifier_type_value (tree id, tree decl)
1652 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1655 /* Return the name for the constructor (or destructor) for the
1656 specified class TYPE. When given a template, this routine doesn't
1657 lose the specialization. */
1660 constructor_name_full (tree type)
1662 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1665 /* Return the name for the constructor (or destructor) for the
1666 specified class. When given a template, return the plain
1667 unspecialized name. */
1670 constructor_name (tree type)
1673 name = constructor_name_full (type);
1674 if (IDENTIFIER_TEMPLATE (name))
1675 name = IDENTIFIER_TEMPLATE (name);
1679 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1682 constructor_name_p (tree name, tree type)
1689 if (TREE_CODE (name) != IDENTIFIER_NODE)
1692 ctor_name = constructor_name_full (type);
1693 if (name == ctor_name)
1695 if (IDENTIFIER_TEMPLATE (ctor_name)
1696 && name == IDENTIFIER_TEMPLATE (ctor_name))
1701 /* Counter used to create anonymous type names. */
1703 static GTY(()) int anon_cnt;
1705 /* Return an IDENTIFIER which can be used as a name for
1706 anonymous structs and unions. */
1709 make_anon_name (void)
1713 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1714 return get_identifier (buf);
1717 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1719 static inline cxx_binding *
1720 find_binding (cxx_scope *scope, cxx_binding *binding)
1722 timevar_push (TV_NAME_LOOKUP);
1724 for (; binding != NULL; binding = binding->previous)
1725 if (binding->scope == scope)
1726 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1731 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1733 static inline cxx_binding *
1734 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1736 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1739 /* Fold-in case where NAME is used only once. */
1740 if (scope == b->scope && b->previous == NULL)
1742 return find_binding (scope, b);
1747 /* Always returns a binding for name in scope. If no binding is
1748 found, make a new one. */
1750 static cxx_binding *
1751 binding_for_name (cxx_scope *scope, tree name)
1753 cxx_binding *result;
1755 result = cxx_scope_find_binding_for_name (scope, name);
1758 /* Not found, make a new one. */
1759 result = cxx_binding_make (NULL, NULL);
1760 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1761 result->scope = scope;
1762 result->is_local = false;
1763 result->value_is_inherited = false;
1764 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1768 /* Insert another USING_DECL into the current binding level, returning
1769 this declaration. If this is a redeclaration, do nothing, and
1770 return NULL_TREE if this not in namespace scope (in namespace
1771 scope, a using decl might extend any previous bindings). */
1774 push_using_decl (tree scope, tree name)
1778 timevar_push (TV_NAME_LOOKUP);
1779 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1780 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1781 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1782 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1785 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1786 namespace_bindings_p () ? decl : NULL_TREE);
1787 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1788 USING_DECL_SCOPE (decl) = scope;
1789 TREE_CHAIN (decl) = current_binding_level->usings;
1790 current_binding_level->usings = decl;
1791 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1794 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1795 caller to set DECL_CONTEXT properly. */
1798 pushdecl_with_scope (tree x, cxx_scope *level)
1800 struct cp_binding_level *b;
1801 tree function_decl = current_function_decl;
1803 timevar_push (TV_NAME_LOOKUP);
1804 current_function_decl = NULL_TREE;
1805 if (level->kind == sk_class)
1807 b = class_binding_level;
1808 class_binding_level = level;
1809 pushdecl_class_level (x);
1810 class_binding_level = b;
1814 b = current_binding_level;
1815 current_binding_level = level;
1817 current_binding_level = b;
1819 current_function_decl = function_decl;
1820 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1823 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1824 other definitions already in place. We get around this by making
1825 the value of the identifier point to a list of all the things that
1826 want to be referenced by that name. It is then up to the users of
1827 that name to decide what to do with that list.
1829 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1830 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1832 FLAGS is a bitwise-or of the following values:
1833 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1835 PUSH_USING: DECL is being pushed as the result of a using
1838 The value returned may be a previous declaration if we guessed wrong
1839 about what language DECL should belong to (C or C++). Otherwise,
1840 it's always DECL (and never something that's not a _DECL). */
1843 push_overloaded_decl (tree decl, int flags)
1845 tree name = DECL_NAME (decl);
1848 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1850 timevar_push (TV_NAME_LOOKUP);
1852 old = namespace_binding (name, DECL_CONTEXT (decl));
1854 old = lookup_name_innermost_nonclass_level (name);
1858 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1860 tree t = TREE_TYPE (old);
1861 if (IS_AGGR_TYPE (t) && warn_shadow
1862 && (! DECL_IN_SYSTEM_HEADER (decl)
1863 || ! DECL_IN_SYSTEM_HEADER (old)))
1864 warning (0, "%q#D hides constructor for %q#T", decl, t);
1867 else if (is_overloaded_fn (old))
1871 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1873 tree fn = OVL_CURRENT (tmp);
1875 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1876 && !(flags & PUSH_USING)
1877 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1878 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1879 && ! decls_match (fn, decl))
1880 error ("%q#D conflicts with previous using declaration %q#D",
1883 if (duplicate_decls (decl, fn) == fn)
1884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
1887 /* We don't overload implicit built-ins. duplicate_decls()
1888 may fail to merge the decls if the new decl is e.g. a
1889 template function. */
1890 if (TREE_CODE (old) == FUNCTION_DECL
1891 && DECL_ANTICIPATED (old))
1894 else if (old == error_mark_node)
1895 /* Ignore the undefined symbol marker. */
1899 error ("previous non-function declaration %q+#D", old);
1900 error ("conflicts with function declaration %q#D", decl);
1901 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1905 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1906 /* If it's a using declaration, we always need to build an OVERLOAD,
1907 because it's the only way to remember that the declaration comes
1908 from 'using', and have the lookup behave correctly. */
1909 || (flags & PUSH_USING))
1911 if (old && TREE_CODE (old) != OVERLOAD)
1912 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1914 new_binding = ovl_cons (decl, old);
1915 if (flags & PUSH_USING)
1916 OVL_USED (new_binding) = 1;
1919 /* NAME is not ambiguous. */
1923 set_namespace_binding (name, current_namespace, new_binding);
1926 /* We only create an OVERLOAD if there was a previous binding at
1927 this level, or if decl is a template. In the former case, we
1928 need to remove the old binding and replace it with the new
1929 binding. We must also run through the NAMES on the binding
1930 level where the name was bound to update the chain. */
1932 if (TREE_CODE (new_binding) == OVERLOAD && old)
1936 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1938 d = &TREE_CHAIN (*d))
1940 || (TREE_CODE (*d) == TREE_LIST
1941 && TREE_VALUE (*d) == old))
1943 if (TREE_CODE (*d) == TREE_LIST)
1944 /* Just replace the old binding with the new. */
1945 TREE_VALUE (*d) = new_binding;
1947 /* Build a TREE_LIST to wrap the OVERLOAD. */
1948 *d = tree_cons (NULL_TREE, new_binding,
1951 /* And update the cxx_binding node. */
1952 IDENTIFIER_BINDING (name)->value = new_binding;
1953 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1956 /* We should always find a previous binding in this case. */
1960 /* Install the new binding. */
1961 push_local_binding (name, new_binding, flags);
1964 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1967 /* Check a non-member using-declaration. Return the name and scope
1968 being used, and the USING_DECL, or NULL_TREE on failure. */
1971 validate_nonmember_using_decl (tree decl, tree scope, tree name)
1973 /* [namespace.udecl]
1974 A using-declaration for a class member shall be a
1975 member-declaration. */
1978 error ("%qT is not a namespace", scope);
1981 else if (scope == error_mark_node)
1984 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
1987 A using-declaration shall not name a template-id. */
1988 error ("a using-declaration cannot specify a template-id. "
1989 "Try %<using %D%>", name);
1993 if (TREE_CODE (decl) == NAMESPACE_DECL)
1995 error ("namespace %qD not allowed in using-declaration", decl);
1999 if (TREE_CODE (decl) == SCOPE_REF)
2001 /* It's a nested name with template parameter dependent scope.
2002 This can only be using-declaration for class member. */
2003 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2007 if (is_overloaded_fn (decl))
2008 decl = get_first_fn (decl);
2010 gcc_assert (DECL_P (decl));
2012 /* Make a USING_DECL. */
2013 return push_using_decl (scope, name);
2016 /* Process local and global using-declarations. */
2019 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2020 tree *newval, tree *newtype)
2022 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2024 *newval = *newtype = NULL_TREE;
2025 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2029 if (!decls.value && !decls.type)
2031 error ("%qD not declared", name);
2035 /* It is impossible to overload a built-in function; any explicit
2036 declaration eliminates the built-in declaration. So, if OLDVAL
2037 is a built-in, then we can just pretend it isn't there. */
2039 && TREE_CODE (oldval) == FUNCTION_DECL
2040 && DECL_ANTICIPATED (oldval))
2043 /* Check for using functions. */
2044 if (decls.value && is_overloaded_fn (decls.value))
2048 if (oldval && !is_overloaded_fn (oldval))
2050 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2051 error ("%qD is already declared in this scope", name);
2056 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2058 tree new_fn = OVL_CURRENT (tmp);
2060 /* [namespace.udecl]
2062 If a function declaration in namespace scope or block
2063 scope has the same name and the same parameter types as a
2064 function introduced by a using declaration the program is
2066 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2068 tree old_fn = OVL_CURRENT (tmp1);
2070 if (new_fn == old_fn)
2071 /* The function already exists in the current namespace. */
2073 else if (OVL_USED (tmp1))
2074 continue; /* this is a using decl */
2075 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2076 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2078 gcc_assert (!DECL_ANTICIPATED (old_fn));
2080 /* There was already a non-using declaration in
2081 this scope with the same parameter types. If both
2082 are the same extern "C" functions, that's ok. */
2083 if (decls_match (new_fn, old_fn))
2087 error ("%qD is already declared in this scope", name);
2093 /* If we broke out of the loop, there's no reason to add
2094 this function to the using declarations for this
2099 /* If we are adding to an existing OVERLOAD, then we no
2100 longer know the type of the set of functions. */
2101 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2102 TREE_TYPE (*newval) = unknown_type_node;
2103 /* Add this new function to the set. */
2104 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2105 /* If there is only one function, then we use its type. (A
2106 using-declaration naming a single function can be used in
2107 contexts where overload resolution cannot be
2109 if (TREE_CODE (*newval) != OVERLOAD)
2111 *newval = ovl_cons (*newval, NULL_TREE);
2112 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2114 OVL_USED (*newval) = 1;
2119 *newval = decls.value;
2120 if (oldval && !decls_match (*newval, oldval))
2121 error ("%qD is already declared in this scope", name);
2124 *newtype = decls.type;
2125 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2127 error ("using declaration %qD introduced ambiguous type %qT",
2133 /* Process a using-declaration at function scope. */
2136 do_local_using_decl (tree decl, tree scope, tree name)
2138 tree oldval, oldtype, newval, newtype;
2139 tree orig_decl = decl;
2141 decl = validate_nonmember_using_decl (decl, scope, name);
2142 if (decl == NULL_TREE)
2145 if (building_stmt_tree ()
2146 && at_function_scope_p ())
2147 add_decl_expr (decl);
2149 oldval = lookup_name_innermost_nonclass_level (name);
2150 oldtype = lookup_type_current_level (name);
2152 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2156 if (is_overloaded_fn (newval))
2160 /* We only need to push declarations for those functions
2161 that were not already bound in the current level.
2162 The old value might be NULL_TREE, it might be a single
2163 function, or an OVERLOAD. */
2164 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2165 term = OVL_FUNCTION (oldval);
2168 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2170 push_overloaded_decl (OVL_CURRENT (fn),
2171 PUSH_LOCAL | PUSH_USING);
2174 push_local_binding (name, newval, PUSH_USING);
2178 push_local_binding (name, newtype, PUSH_USING);
2179 set_identifier_type_value (name, newtype);
2182 /* Emit debug info. */
2183 if (!processing_template_decl)
2184 cp_emit_debug_info_for_using (orig_decl, current_scope());
2187 /* Returns true if ROOT (a namespace, class, or function) encloses
2188 CHILD. CHILD may be either a class type or a namespace. */
2191 is_ancestor (tree root, tree child)
2193 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2194 || TREE_CODE (root) == FUNCTION_DECL
2195 || CLASS_TYPE_P (root)));
2196 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2197 || CLASS_TYPE_P (child)));
2199 /* The global namespace encloses everything. */
2200 if (root == global_namespace)
2205 /* If we've run out of scopes, stop. */
2208 /* If we've reached the ROOT, it encloses CHILD. */
2211 /* Go out one level. */
2213 child = TYPE_NAME (child);
2214 child = DECL_CONTEXT (child);
2218 /* Enter the class or namespace scope indicated by T suitable for name
2219 lookup. T can be arbitrary scope, not necessary nested inside the
2220 current scope. Returns a non-null scope to pop iff pop_scope
2221 should be called later to exit this scope. */
2226 if (TREE_CODE (t) == NAMESPACE_DECL)
2227 push_decl_namespace (t);
2228 else if (CLASS_TYPE_P (t))
2230 if (!at_class_scope_p ()
2231 || !same_type_p (current_class_type, t))
2232 push_nested_class (t);
2234 /* T is the same as the current scope. There is therefore no
2235 need to re-enter the scope. Since we are not actually
2236 pushing a new scope, our caller should not call
2244 /* Leave scope pushed by push_scope. */
2249 if (TREE_CODE (t) == NAMESPACE_DECL)
2250 pop_decl_namespace ();
2251 else if CLASS_TYPE_P (t)
2252 pop_nested_class ();
2255 /* Subroutine of push_inner_scope. */
2258 push_inner_scope_r (tree outer, tree inner)
2263 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2266 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2268 push_inner_scope_r (outer, prev);
2269 if (TREE_CODE (inner) == NAMESPACE_DECL)
2271 struct cp_binding_level *save_template_parm = 0;
2272 /* Temporary take out template parameter scopes. They are saved
2273 in reversed order in save_template_parm. */
2274 while (current_binding_level->kind == sk_template_parms)
2276 struct cp_binding_level *b = current_binding_level;
2277 current_binding_level = b->level_chain;
2278 b->level_chain = save_template_parm;
2279 save_template_parm = b;
2282 resume_scope (NAMESPACE_LEVEL (inner));
2283 current_namespace = inner;
2285 /* Restore template parameter scopes. */
2286 while (save_template_parm)
2288 struct cp_binding_level *b = save_template_parm;
2289 save_template_parm = b->level_chain;
2290 b->level_chain = current_binding_level;
2291 current_binding_level = b;
2298 /* Enter the scope INNER from current scope. INNER must be a scope
2299 nested inside current scope. This works with both name lookup and
2300 pushing name into scope. In case a template parameter scope is present,
2301 namespace is pushed under the template parameter scope according to
2302 name lookup rule in 14.6.1/6.
2304 Return the former current scope suitable for pop_inner_scope. */
2307 push_inner_scope (tree inner)
2309 tree outer = current_scope ();
2311 outer = current_namespace;
2313 push_inner_scope_r (outer, inner);
2317 /* Exit the current scope INNER back to scope OUTER. */
2320 pop_inner_scope (tree outer, tree inner)
2323 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2326 while (outer != inner)
2328 if (TREE_CODE (inner) == NAMESPACE_DECL)
2330 struct cp_binding_level *save_template_parm = 0;
2331 /* Temporary take out template parameter scopes. They are saved
2332 in reversed order in save_template_parm. */
2333 while (current_binding_level->kind == sk_template_parms)
2335 struct cp_binding_level *b = current_binding_level;
2336 current_binding_level = b->level_chain;
2337 b->level_chain = save_template_parm;
2338 save_template_parm = b;
2343 /* Restore template parameter scopes. */
2344 while (save_template_parm)
2346 struct cp_binding_level *b = save_template_parm;
2347 save_template_parm = b->level_chain;
2348 b->level_chain = current_binding_level;
2349 current_binding_level = b;
2355 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2359 /* Do a pushlevel for class declarations. */
2362 pushlevel_class (void)
2364 if (ENABLE_SCOPE_CHECKING)
2367 class_binding_level = begin_scope (sk_class, current_class_type);
2370 /* ...and a poplevel for class declarations. */
2373 poplevel_class (void)
2375 struct cp_binding_level *level = class_binding_level;
2376 cp_class_binding *cb;
2380 timevar_push (TV_NAME_LOOKUP);
2381 gcc_assert (level != 0);
2383 /* If we're leaving a toplevel class, cache its binding level. */
2384 if (current_class_depth == 1)
2385 previous_class_level = level;
2386 for (shadowed = level->type_shadowed;
2388 shadowed = TREE_CHAIN (shadowed))
2389 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2391 /* Remove the bindings for all of the class-level declarations. */
2392 if (level->class_shadowed)
2395 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2397 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2398 ggc_free (level->class_shadowed);
2399 level->class_shadowed = NULL;
2402 /* Now, pop out of the binding level which we created up in the
2403 `pushlevel_class' routine. */
2404 if (ENABLE_SCOPE_CHECKING)
2408 timevar_pop (TV_NAME_LOOKUP);
2411 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2412 appropriate. DECL is the value to which a name has just been
2413 bound. CLASS_TYPE is the class in which the lookup occurred. */
2416 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2419 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2423 if (TREE_CODE (decl) == OVERLOAD)
2424 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2427 gcc_assert (DECL_P (decl));
2428 context = context_for_name_lookup (decl);
2431 if (is_properly_derived_from (class_type, context))
2432 INHERITED_VALUE_BINDING_P (binding) = 1;
2434 INHERITED_VALUE_BINDING_P (binding) = 0;
2436 else if (binding->value == decl)
2437 /* We only encounter a TREE_LIST when there is an ambiguity in the
2438 base classes. Such an ambiguity can be overridden by a
2439 definition in this class. */
2440 INHERITED_VALUE_BINDING_P (binding) = 1;
2442 INHERITED_VALUE_BINDING_P (binding) = 0;
2445 /* Make the declaration of X appear in CLASS scope. */
2448 pushdecl_class_level (tree x)
2451 bool is_valid = true;
2453 timevar_push (TV_NAME_LOOKUP);
2454 /* Get the name of X. */
2455 if (TREE_CODE (x) == OVERLOAD)
2456 name = DECL_NAME (get_first_fn (x));
2458 name = DECL_NAME (x);
2462 is_valid = push_class_level_binding (name, x);
2463 if (TREE_CODE (x) == TYPE_DECL)
2464 set_identifier_type_value (name, x);
2466 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2468 /* If X is an anonymous aggregate, all of its members are
2469 treated as if they were members of the class containing the
2470 aggregate, for naming purposes. */
2473 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2475 location_t save_location = input_location;
2476 input_location = DECL_SOURCE_LOCATION (f);
2477 if (!pushdecl_class_level (f))
2479 input_location = save_location;
2482 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2485 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2486 scope. If the value returned is non-NULL, and the PREVIOUS field
2487 is not set, callers must set the PREVIOUS field explicitly. */
2489 static cxx_binding *
2490 get_class_binding (tree name, cxx_scope *scope)
2495 cxx_binding *binding;
2497 class_type = scope->this_entity;
2499 /* Get the type binding. */
2500 type_binding = lookup_member (class_type, name,
2501 /*protect=*/2, /*want_type=*/true);
2502 /* Get the value binding. */
2503 value_binding = lookup_member (class_type, name,
2504 /*protect=*/2, /*want_type=*/false);
2507 && (TREE_CODE (value_binding) == TYPE_DECL
2508 || DECL_CLASS_TEMPLATE_P (value_binding)
2509 || (TREE_CODE (value_binding) == TREE_LIST
2510 && TREE_TYPE (value_binding) == error_mark_node
2511 && (TREE_CODE (TREE_VALUE (value_binding))
2513 /* We found a type binding, even when looking for a non-type
2514 binding. This means that we already processed this binding
2517 else if (value_binding)
2519 if (TREE_CODE (value_binding) == TREE_LIST
2520 && TREE_TYPE (value_binding) == error_mark_node)
2521 /* NAME is ambiguous. */
2523 else if (BASELINK_P (value_binding))
2524 /* NAME is some overloaded functions. */
2525 value_binding = BASELINK_FUNCTIONS (value_binding);
2528 /* If we found either a type binding or a value binding, create a
2529 new binding object. */
2530 if (type_binding || value_binding)
2532 binding = new_class_binding (name,
2536 /* This is a class-scope binding, not a block-scope binding. */
2537 LOCAL_BINDING_P (binding) = 0;
2538 set_inherited_value_binding_p (binding, value_binding, class_type);
2546 /* Make the declaration(s) of X appear in CLASS scope under the name
2547 NAME. Returns true if the binding is valid. */
2550 push_class_level_binding (tree name, tree x)
2552 cxx_binding *binding;
2556 timevar_push (TV_NAME_LOOKUP);
2557 /* The class_binding_level will be NULL if x is a template
2558 parameter name in a member template. */
2559 if (!class_binding_level)
2560 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2562 /* Check for invalid member names. */
2563 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2564 /* We could have been passed a tree list if this is an ambiguous
2565 declaration. If so, pull the declaration out because
2566 check_template_shadow will not handle a TREE_LIST. */
2567 if (TREE_CODE (decl) == TREE_LIST
2568 && TREE_TYPE (decl) == error_mark_node)
2569 decl = TREE_VALUE (decl);
2571 check_template_shadow (decl);
2575 If T is the name of a class, then each of the following shall
2576 have a name different from T:
2578 -- every static data member of class T;
2580 -- every member of class T that is itself a type;
2582 -- every enumerator of every member of class T that is an
2585 -- every member of every anonymous union that is a member of
2588 (Non-static data members were also forbidden to have the same
2589 name as T until TC1.) */
2590 if ((TREE_CODE (x) == VAR_DECL
2591 || TREE_CODE (x) == CONST_DECL
2592 || (TREE_CODE (x) == TYPE_DECL
2593 && !DECL_SELF_REFERENCE_P (x))
2594 /* A data member of an anonymous union. */
2595 || (TREE_CODE (x) == FIELD_DECL
2596 && DECL_CONTEXT (x) != current_class_type))
2597 && DECL_NAME (x) == constructor_name (current_class_type))
2599 tree scope = context_for_name_lookup (x);
2600 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2602 error ("%qD has the same name as the class in which it is "
2605 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2609 /* Get the current binding for NAME in this class, if any. */
2610 binding = IDENTIFIER_BINDING (name);
2611 if (!binding || binding->scope != class_binding_level)
2613 binding = get_class_binding (name, class_binding_level);
2614 /* If a new binding was created, put it at the front of the
2615 IDENTIFIER_BINDING list. */
2618 binding->previous = IDENTIFIER_BINDING (name);
2619 IDENTIFIER_BINDING (name) = binding;
2623 /* If there is already a binding, then we may need to update the
2625 if (binding && binding->value)
2627 tree bval = binding->value;
2628 tree old_decl = NULL_TREE;
2630 if (INHERITED_VALUE_BINDING_P (binding))
2632 /* If the old binding was from a base class, and was for a
2633 tag name, slide it over to make room for the new binding.
2634 The old binding is still visible if explicitly qualified
2635 with a class-key. */
2636 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2637 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2639 old_decl = binding->type;
2640 binding->type = bval;
2641 binding->value = NULL_TREE;
2642 INHERITED_VALUE_BINDING_P (binding) = 0;
2647 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2649 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2650 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2651 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2653 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2654 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2656 if (old_decl && binding->scope == class_binding_level)
2659 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2660 here. This function is only used to register bindings
2661 from with the class definition itself. */
2662 INHERITED_VALUE_BINDING_P (binding) = 0;
2663 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2667 /* Note that we declared this value so that we can issue an error if
2668 this is an invalid redeclaration of a name already used for some
2670 note_name_declared_in_class (name, decl);
2672 /* If we didn't replace an existing binding, put the binding on the
2673 stack of bindings for the identifier, and update the shadowed
2675 if (binding && binding->scope == class_binding_level)
2676 /* Supplement the existing binding. */
2677 ok = supplement_binding (binding, decl);
2680 /* Create a new binding. */
2681 push_binding (name, decl, class_binding_level);
2685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2688 /* Process "using SCOPE::NAME" in a class scope. Return the
2689 USING_DECL created. */
2692 do_class_using_decl (tree scope, tree name)
2694 tree value, decl, binfo;
2698 if (!scope || !TYPE_P (scope))
2700 error ("using-declaration for non-member at class scope");
2704 /* Make sure the scope is a base. */
2705 dependent_p = dependent_type_p (scope);
2707 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2711 if (same_type_p (current_class_type, scope))
2712 b_kind = bk_same_type;
2714 b_kind = bk_proper_base;
2717 if (b_kind < bk_proper_base)
2719 error_not_base_type (scope, current_class_type);
2723 /* Make sure the name is not invalid */
2724 if (TREE_CODE (name) == BIT_NOT_EXPR)
2726 error ("%<%T::%D%> names destructor", scope, name);
2729 if (constructor_name_p (name, scope))
2731 error ("%<%T::%D%> names constructor", scope, name);
2734 if (constructor_name_p (name, current_class_type))
2736 error ("%<%T::%D%> names constructor in %qT",
2737 scope, name, current_class_type);
2742 && IDENTIFIER_OPNAME_P (name) && dependent_type_p (TREE_TYPE (name)))
2745 /* See if there are any members of the base. */
2748 decl = lookup_member (binfo, name, 0, false);
2752 error ("no members matching %<%T::%D%> in %q#T", scope, name, scope);
2756 if (BASELINK_P (decl))
2757 /* Ignore base type this came from. */
2758 decl = BASELINK_FUNCTIONS (decl);
2763 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2764 USING_DECL_DECLS (value) = decl;
2765 USING_DECL_SCOPE (value) = scope;
2766 DECL_DEPENDENT_P (value) = dependent_p;
2772 /* Return the binding value for name in scope. */
2775 namespace_binding (tree name, tree scope)
2777 cxx_binding *binding;
2780 scope = global_namespace;
2782 /* Unnecessary for the global namespace because it can't be an alias. */
2783 scope = ORIGINAL_NAMESPACE (scope);
2785 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2787 return binding ? binding->value : NULL_TREE;
2790 /* Set the binding value for name in scope. */
2793 set_namespace_binding (tree name, tree scope, tree val)
2797 timevar_push (TV_NAME_LOOKUP);
2798 if (scope == NULL_TREE)
2799 scope = global_namespace;
2800 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2801 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2804 supplement_binding (b, val);
2805 timevar_pop (TV_NAME_LOOKUP);
2808 /* Set the context of a declaration to scope. Complain if we are not
2812 set_decl_namespace (tree decl, tree scope, bool friendp)
2816 /* Get rid of namespace aliases. */
2817 scope = ORIGINAL_NAMESPACE (scope);
2819 /* It is ok for friends to be qualified in parallel space. */
2820 if (!friendp && !is_ancestor (current_namespace, scope))
2821 error ("declaration of %qD not in a namespace surrounding %qD",
2823 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2825 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2826 if (scope == current_namespace)
2828 if (at_namespace_scope_p ())
2829 error ("explicit qualification in declaration of %qD",
2834 /* See whether this has been declared in the namespace. */
2835 old = namespace_binding (DECL_NAME (decl), scope);
2837 /* No old declaration at all. */
2839 /* A template can be explicitly specialized in any namespace. */
2840 if (processing_explicit_instantiation)
2842 if (!is_overloaded_fn (decl))
2843 /* Don't compare non-function decls with decls_match here, since
2844 it can't check for the correct constness at this
2845 point. pushdecl will find those errors later. */
2847 /* Since decl is a function, old should contain a function decl. */
2848 if (!is_overloaded_fn (old))
2850 if (processing_template_decl || processing_specialization)
2851 /* We have not yet called push_template_decl to turn a
2852 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2853 match. But, we'll check later, when we construct the
2856 if (is_overloaded_fn (old))
2858 for (; old; old = OVL_NEXT (old))
2859 if (decls_match (decl, OVL_CURRENT (old)))
2862 else if (decls_match (decl, old))
2865 error ("%qD should have been declared inside %qD", decl, scope);
2868 /* Return the namespace where the current declaration is declared. */
2871 current_decl_namespace (void)
2874 /* If we have been pushed into a different namespace, use it. */
2875 if (decl_namespace_list)
2876 return TREE_PURPOSE (decl_namespace_list);
2878 if (current_class_type)
2879 result = decl_namespace_context (current_class_type);
2880 else if (current_function_decl)
2881 result = decl_namespace_context (current_function_decl);
2883 result = current_namespace;
2887 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2888 select a name that is unique to this compilation unit. */
2891 push_namespace (tree name)
2895 int implicit_use = 0;
2898 timevar_push (TV_NAME_LOOKUP);
2900 /* We should not get here if the global_namespace is not yet constructed
2901 nor if NAME designates the global namespace: The global scope is
2902 constructed elsewhere. */
2903 gcc_assert (global_namespace != NULL && name != global_scope_name);
2907 /* The name of anonymous namespace is unique for the translation
2909 if (!anonymous_namespace_name)
2910 anonymous_namespace_name = get_file_function_name ('N');
2911 name = anonymous_namespace_name;
2912 d = IDENTIFIER_NAMESPACE_VALUE (name);
2914 /* Reopening anonymous namespace. */
2920 /* Check whether this is an extended namespace definition. */
2921 d = IDENTIFIER_NAMESPACE_VALUE (name);
2922 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2925 if (DECL_NAMESPACE_ALIAS (d))
2927 error ("namespace alias %qD not allowed here, assuming %qD",
2928 d, DECL_NAMESPACE_ALIAS (d));
2929 d = DECL_NAMESPACE_ALIAS (d);
2936 /* Make a new namespace, binding the name to it. */
2937 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2938 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2942 /* Clear DECL_NAME for the benefit of debugging back ends. */
2943 SET_DECL_ASSEMBLER_NAME (d, name);
2944 DECL_NAME (d) = NULL_TREE;
2946 begin_scope (sk_namespace, d);
2949 resume_scope (NAMESPACE_LEVEL (d));
2952 do_using_directive (d);
2953 /* Enter the name space. */
2954 current_namespace = d;
2956 timevar_pop (TV_NAME_LOOKUP);
2959 /* Pop from the scope of the current namespace. */
2962 pop_namespace (void)
2964 gcc_assert (current_namespace != global_namespace);
2965 current_namespace = CP_DECL_CONTEXT (current_namespace);
2966 /* The binding level is not popped, as it might be re-opened later. */
2970 /* Push into the scope of the namespace NS, even if it is deeply
2971 nested within another namespace. */
2974 push_nested_namespace (tree ns)
2976 if (ns == global_namespace)
2977 push_to_top_level ();
2980 push_nested_namespace (CP_DECL_CONTEXT (ns));
2981 push_namespace (DECL_NAME (ns));
2985 /* Pop back from the scope of the namespace NS, which was previously
2986 entered with push_nested_namespace. */
2989 pop_nested_namespace (tree ns)
2991 timevar_push (TV_NAME_LOOKUP);
2992 while (ns != global_namespace)
2995 ns = CP_DECL_CONTEXT (ns);
2998 pop_from_top_level ();
2999 timevar_pop (TV_NAME_LOOKUP);
3002 /* Temporarily set the namespace for the current declaration. */
3005 push_decl_namespace (tree decl)
3007 if (TREE_CODE (decl) != NAMESPACE_DECL)
3008 decl = decl_namespace_context (decl);
3009 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3010 NULL_TREE, decl_namespace_list);
3013 /* [namespace.memdef]/2 */
3016 pop_decl_namespace (void)
3018 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3021 /* Return the namespace that is the common ancestor
3022 of two given namespaces. */
3025 namespace_ancestor (tree ns1, tree ns2)
3027 timevar_push (TV_NAME_LOOKUP);
3028 if (is_ancestor (ns1, ns2))
3029 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3030 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3031 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3034 /* Process a namespace-alias declaration. */
3037 do_namespace_alias (tree alias, tree namespace)
3039 if (namespace == error_mark_node)
3042 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3044 namespace = ORIGINAL_NAMESPACE (namespace);
3046 /* Build the alias. */
3047 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3048 DECL_NAMESPACE_ALIAS (alias) = namespace;
3049 DECL_EXTERNAL (alias) = 1;
3050 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3053 /* Emit debug info for namespace alias. */
3054 (*debug_hooks->global_decl) (alias);
3057 /* Like pushdecl, only it places X in the current namespace,
3061 pushdecl_namespace_level (tree x)
3063 struct cp_binding_level *b = current_binding_level;
3066 timevar_push (TV_NAME_LOOKUP);
3067 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3069 /* Now, the type_shadowed stack may screw us. Munge it so it does
3071 if (TREE_CODE (t) == TYPE_DECL)
3073 tree name = DECL_NAME (t);
3075 tree *ptr = (tree *)0;
3076 for (; !global_scope_p (b); b = b->level_chain)
3078 tree shadowed = b->type_shadowed;
3079 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3080 if (TREE_PURPOSE (shadowed) == name)
3082 ptr = &TREE_VALUE (shadowed);
3083 /* Can't break out of the loop here because sometimes
3084 a binding level will have duplicate bindings for
3085 PT names. It's gross, but I haven't time to fix it. */
3088 newval = TREE_TYPE (t);
3089 if (ptr == (tree *)0)
3091 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3092 up here if this is changed to an assertion. --KR */
3093 SET_IDENTIFIER_TYPE_VALUE (name, t);
3100 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3103 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3104 directive is not directly from the source. Also find the common
3105 ancestor and let our users know about the new namespace */
3107 add_using_namespace (tree user, tree used, bool indirect)
3110 timevar_push (TV_NAME_LOOKUP);
3111 /* Using oneself is a no-op. */
3114 timevar_pop (TV_NAME_LOOKUP);
3117 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3118 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3119 /* Check if we already have this. */
3120 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3124 /* Promote to direct usage. */
3125 TREE_INDIRECT_USING (t) = 0;
3126 timevar_pop (TV_NAME_LOOKUP);
3130 /* Add used to the user's using list. */
3131 DECL_NAMESPACE_USING (user)
3132 = tree_cons (used, namespace_ancestor (user, used),
3133 DECL_NAMESPACE_USING (user));
3135 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3137 /* Add user to the used's users list. */
3138 DECL_NAMESPACE_USERS (used)
3139 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3141 /* Recursively add all namespaces used. */
3142 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3143 /* indirect usage */
3144 add_using_namespace (user, TREE_PURPOSE (t), 1);
3146 /* Tell everyone using us about the new used namespaces. */
3147 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3148 add_using_namespace (TREE_PURPOSE (t), used, 1);
3149 timevar_pop (TV_NAME_LOOKUP);
3152 /* Process a using-declaration not appearing in class or local scope. */
3155 do_toplevel_using_decl (tree decl, tree scope, tree name)
3157 tree oldval, oldtype, newval, newtype;
3158 tree orig_decl = decl;
3159 cxx_binding *binding;
3161 decl = validate_nonmember_using_decl (decl, scope, name);
3162 if (decl == NULL_TREE)
3165 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3167 oldval = binding->value;
3168 oldtype = binding->type;
3170 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3172 /* Emit debug info. */
3173 if (!processing_template_decl)
3174 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3176 /* Copy declarations found. */
3178 binding->value = newval;
3180 binding->type = newtype;
3184 /* Process a using-directive. */
3187 do_using_directive (tree namespace)
3189 tree context = NULL_TREE;
3191 if (namespace == error_mark_node)
3194 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3196 if (building_stmt_tree ())
3197 add_stmt (build_stmt (USING_STMT, namespace));
3198 namespace = ORIGINAL_NAMESPACE (namespace);
3200 if (!toplevel_bindings_p ())
3202 push_using_directive (namespace);
3203 context = current_scope ();
3208 add_using_namespace (current_namespace, namespace, 0);
3209 if (current_namespace != global_namespace)
3210 context = current_namespace;
3213 /* Emit debugging info. */
3214 if (!processing_template_decl)
3215 (*debug_hooks->imported_module_or_decl) (namespace, context);
3218 /* Deal with a using-directive seen by the parser. Currently we only
3219 handle attributes here, since they cannot appear inside a template. */
3222 parse_using_directive (tree namespace, tree attribs)
3226 do_using_directive (namespace);
3228 for (a = attribs; a; a = TREE_CHAIN (a))
3230 tree name = TREE_PURPOSE (a);
3231 if (is_attribute_p ("strong", name))
3233 if (!toplevel_bindings_p ())
3234 error ("strong using only meaningful at namespace scope");
3235 else if (namespace != error_mark_node)
3236 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3237 = tree_cons (current_namespace, 0,
3238 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3241 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3245 /* Like pushdecl, only it places X in the global scope if appropriate.
3246 Calls cp_finish_decl to register the variable, initializing it with
3247 *INIT, if INIT is non-NULL. */
3250 pushdecl_top_level_1 (tree x, tree *init)
3252 timevar_push (TV_NAME_LOOKUP);
3253 push_to_top_level ();
3254 x = pushdecl_namespace_level (x);
3256 cp_finish_decl (x, *init, NULL_TREE, 0);
3257 pop_from_top_level ();
3258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3261 /* Like pushdecl, only it places X in the global scope if appropriate. */
3264 pushdecl_top_level (tree x)
3266 return pushdecl_top_level_1 (x, NULL);
3269 /* Like pushdecl, only it places X in the global scope if
3270 appropriate. Calls cp_finish_decl to register the variable,
3271 initializing it with INIT. */
3274 pushdecl_top_level_and_finish (tree x, tree init)
3276 return pushdecl_top_level_1 (x, &init);
3279 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3280 duplicates. The first list becomes the tail of the result.
3282 The algorithm is O(n^2). We could get this down to O(n log n) by
3283 doing a sort on the addresses of the functions, if that becomes
3287 merge_functions (tree s1, tree s2)
3289 for (; s2; s2 = OVL_NEXT (s2))
3291 tree fn2 = OVL_CURRENT (s2);
3294 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3296 tree fn1 = OVL_CURRENT (fns1);
3298 /* If the function from S2 is already in S1, there is no
3299 need to add it again. For `extern "C"' functions, we
3300 might have two FUNCTION_DECLs for the same function, in
3301 different namespaces; again, we only need one of them. */
3303 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3304 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3308 /* If we exhausted all of the functions in S1, FN2 is new. */
3310 s1 = build_overload (fn2, s1);
3315 /* This should return an error not all definitions define functions.
3316 It is not an error if we find two functions with exactly the
3317 same signature, only if these are selected in overload resolution.
3318 old is the current set of bindings, new the freshly-found binding.
3319 XXX Do we want to give *all* candidates in case of ambiguity?
3320 XXX In what way should I treat extern declarations?
3321 XXX I don't want to repeat the entire duplicate_decls here */
3324 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3328 gcc_assert (old != NULL);
3329 /* Copy the value. */
3332 switch (TREE_CODE (val))
3335 /* If we expect types or namespaces, and not templates,
3336 or this is not a template class. */
3337 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3338 && !DECL_CLASS_TEMPLATE_P (val))
3339 || hidden_name_p (val))
3343 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3346 case NAMESPACE_DECL:
3347 if (LOOKUP_TYPES_ONLY (flags))
3351 /* Ignore built-in functions that are still anticipated. */
3352 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3356 if (LOOKUP_QUALIFIERS_ONLY (flags))
3362 else if (val && val != old->value)
3364 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3365 old->value = merge_functions (old->value, val);
3368 /* Some declarations are functions, some are not. */
3369 if (flags & LOOKUP_COMPLAIN)
3371 /* If we've already given this error for this lookup,
3372 old->value is error_mark_node, so let's not
3373 repeat ourselves. */
3374 if (old->value != error_mark_node)
3376 error ("use of %qD is ambiguous", name);
3377 error (" first declared as %q+#D here", old->value);
3379 error (" also declared as %q+#D here", val);
3381 old->value = error_mark_node;
3384 /* ... and copy the type. */
3386 if (LOOKUP_NAMESPACES_ONLY (flags))
3390 else if (type && old->type != type)
3392 if (flags & LOOKUP_COMPLAIN)
3394 error ("%qD denotes an ambiguous type",name);
3395 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3396 error ("%J other type here", TYPE_MAIN_DECL (type));
3401 /* Return the declarations that are members of the namespace NS. */
3404 cp_namespace_decls (tree ns)
3406 return NAMESPACE_LEVEL (ns)->names;
3409 /* Combine prefer_type and namespaces_only into flags. */
3412 lookup_flags (int prefer_type, int namespaces_only)
3414 if (namespaces_only)
3415 return LOOKUP_PREFER_NAMESPACES;
3416 if (prefer_type > 1)
3417 return LOOKUP_PREFER_TYPES;
3418 if (prefer_type > 0)
3419 return LOOKUP_PREFER_BOTH;
3423 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3424 ignore it or not. Subroutine of lookup_name_real and
3425 lookup_type_scope. */
3428 qualify_lookup (tree val, int flags)
3430 if (val == NULL_TREE)
3432 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3434 if ((flags & LOOKUP_PREFER_TYPES)
3435 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3437 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3442 /* Given a lookup that returned VAL, decide if we want to ignore it or
3443 not based on DECL_ANTICIPATED_P. */
3446 hidden_name_p (tree val)
3449 && DECL_LANG_SPECIFIC (val)
3450 && DECL_ANTICIPATED (val))
3455 /* Look up NAME in the NAMESPACE. */
3458 lookup_namespace_name (tree namespace, tree name)
3461 tree template_id = NULL_TREE;
3462 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3464 timevar_push (TV_NAME_LOOKUP);
3465 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3467 if (TREE_CODE (name) == NAMESPACE_DECL)
3468 /* This happens for A::B<int> when B is a namespace. */
3469 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3470 else if (TREE_CODE (name) == TEMPLATE_DECL)
3472 /* This happens for A::B where B is a template, and there are no
3473 template arguments. */
3474 error ("invalid use of %qD", name);
3475 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3478 namespace = ORIGINAL_NAMESPACE (namespace);
3480 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3483 name = TREE_OPERAND (name, 0);
3484 if (TREE_CODE (name) == OVERLOAD)
3485 name = DECL_NAME (OVL_CURRENT (name));
3486 else if (DECL_P (name))
3487 name = DECL_NAME (name);
3490 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3492 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3493 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3497 val = binding.value;
3501 if (DECL_CLASS_TEMPLATE_P (val))
3502 val = lookup_template_class (val,
3503 TREE_OPERAND (template_id, 1),
3504 /*in_decl=*/NULL_TREE,
3505 /*context=*/NULL_TREE,
3506 /*entering_scope=*/0,
3507 tf_error | tf_warning);
3508 else if (DECL_FUNCTION_TEMPLATE_P (val)
3509 || TREE_CODE (val) == OVERLOAD)
3510 val = lookup_template_function (val,
3511 TREE_OPERAND (template_id, 1));
3514 error ("%<%D::%D%> is not a template", namespace, name);
3515 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3519 /* If we have a single function from a using decl, pull it out. */
3520 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3521 val = OVL_FUNCTION (val);
3523 /* Ignore built-in functions and friends that haven't been declared
3525 if (!val || !hidden_name_p (val))
3526 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3529 error ("%qD undeclared in namespace %qD", name, namespace);
3530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3533 /* Select the right _DECL from multiple choices. */
3536 select_decl (const struct scope_binding *binding, int flags)
3539 val = binding->value;
3541 timevar_push (TV_NAME_LOOKUP);
3542 if (LOOKUP_NAMESPACES_ONLY (flags))
3544 /* We are not interested in types. */
3545 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3546 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3547 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3550 /* If looking for a type, or if there is no non-type binding, select
3551 the value binding. */
3552 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3553 val = binding->type;
3554 /* Don't return non-types if we really prefer types. */
3555 else if (val && LOOKUP_TYPES_ONLY (flags)
3556 && ! DECL_DECLARES_TYPE_P (val))
3559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3562 /* Unscoped lookup of a global: iterate over current namespaces,
3563 considering using-directives. */
3566 unqualified_namespace_lookup (tree name, int flags)
3568 tree initial = current_decl_namespace ();
3569 tree scope = initial;
3571 struct cp_binding_level *level;
3572 tree val = NULL_TREE;
3573 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3575 timevar_push (TV_NAME_LOOKUP);
3577 for (; !val; scope = CP_DECL_CONTEXT (scope))
3580 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3584 if (b->value && hidden_name_p (b->value))
3585 /* Ignore anticipated built-in functions and friends. */
3588 binding.value = b->value;
3589 binding.type = b->type;
3592 /* Add all _DECLs seen through local using-directives. */
3593 for (level = current_binding_level;
3594 level->kind != sk_namespace;
3595 level = level->level_chain)
3596 if (!lookup_using_namespace (name, &binding, level->using_directives,
3598 /* Give up because of error. */
3599 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3601 /* Add all _DECLs seen through global using-directives. */
3602 /* XXX local and global using lists should work equally. */
3606 if (!lookup_using_namespace (name, &binding,
3607 DECL_NAMESPACE_USING (siter),
3609 /* Give up because of error. */
3610 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3611 if (siter == scope) break;
3612 siter = CP_DECL_CONTEXT (siter);
3615 val = select_decl (&binding, flags);
3616 if (scope == global_namespace)
3619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3622 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3623 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3626 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3627 declaration found. If no suitable declaration can be found,
3628 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3629 neither a class-type nor a namespace a diagnostic is issued. */
3632 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3636 if (TREE_CODE (scope) == NAMESPACE_DECL)
3638 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3640 flags |= LOOKUP_COMPLAIN;
3642 flags |= LOOKUP_PREFER_TYPES;
3643 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3644 return select_decl (&binding, flags);
3646 else if (is_aggr_type (scope, complain))
3649 t = lookup_member (scope, name, 2, is_type_p);
3654 return error_mark_node;
3657 /* Subroutine of unqualified_namespace_lookup:
3658 Add the bindings of NAME in used namespaces to VAL.
3659 We are currently looking for names in namespace SCOPE, so we
3660 look through USINGS for using-directives of namespaces
3661 which have SCOPE as a common ancestor with the current scope.
3662 Returns false on errors. */
3665 lookup_using_namespace (tree name, struct scope_binding *val,
3666 tree usings, tree scope, int flags)
3669 timevar_push (TV_NAME_LOOKUP);
3670 /* Iterate over all used namespaces in current, searching for using
3671 directives of scope. */
3672 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3673 if (TREE_VALUE (iter) == scope)
3675 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3677 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3678 /* Resolve ambiguities. */
3680 ambiguous_decl (name, val, val1, flags);
3682 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3686 Accepts the NAME to lookup and its qualifying SCOPE.
3687 Returns the name/type pair found into the cxx_binding *RESULT,
3688 or false on error. */
3691 qualified_lookup_using_namespace (tree name, tree scope,
3692 struct scope_binding *result, int flags)
3694 /* Maintain a list of namespaces visited... */
3695 tree seen = NULL_TREE;
3696 /* ... and a list of namespace yet to see. */
3697 tree todo = NULL_TREE;
3698 tree todo_maybe = NULL_TREE;
3700 timevar_push (TV_NAME_LOOKUP);
3701 /* Look through namespace aliases. */
3702 scope = ORIGINAL_NAMESPACE (scope);
3703 while (scope && result->value != error_mark_node)
3705 cxx_binding *binding =
3706 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3707 seen = tree_cons (scope, NULL_TREE, seen);
3709 ambiguous_decl (name, result, binding, flags);
3711 /* Consider strong using directives always, and non-strong ones
3712 if we haven't found a binding yet. ??? Shouldn't we consider
3713 non-strong ones if the initial RESULT is non-NULL, but the
3714 binding in the given namespace is? */
3715 for (usings = DECL_NAMESPACE_USING (scope); usings;
3716 usings = TREE_CHAIN (usings))
3717 /* If this was a real directive, and we have not seen it. */
3718 if (!TREE_INDIRECT_USING (usings))
3720 /* Try to avoid queuing the same namespace more than once,
3721 the exception being when a namespace was already
3722 enqueued for todo_maybe and then a strong using is
3723 found for it. We could try to remove it from
3724 todo_maybe, but it's probably not worth the effort. */
3725 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3726 && !purpose_member (TREE_PURPOSE (usings), seen)
3727 && !purpose_member (TREE_PURPOSE (usings), todo))
3728 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3729 else if ((!result->value && !result->type)
3730 && !purpose_member (TREE_PURPOSE (usings), seen)
3731 && !purpose_member (TREE_PURPOSE (usings), todo)
3732 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3733 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3738 scope = TREE_PURPOSE (todo);
3739 todo = TREE_CHAIN (todo);
3742 && (!result->value && !result->type))
3744 scope = TREE_PURPOSE (todo_maybe);
3745 todo = TREE_CHAIN (todo_maybe);
3746 todo_maybe = NULL_TREE;
3749 scope = NULL_TREE; /* If there never was a todo list. */
3751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3754 /* Return the innermost non-namespace binding for NAME from a scope
3755 containing BINDING, or, if BINDING is NULL, the current scope. If
3756 CLASS_P is false, then class bindings are ignored. */
3759 outer_binding (tree name,
3760 cxx_binding *binding,
3765 cxx_scope *outer_scope;
3769 scope = binding->scope->level_chain;
3770 outer = binding->previous;
3774 scope = current_binding_level;
3775 outer = IDENTIFIER_BINDING (name);
3777 outer_scope = outer ? outer->scope : NULL;
3779 /* Because we create class bindings lazily, we might be missing a
3780 class binding for NAME. If there are any class binding levels
3781 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3782 declared, we must lookup NAME in those class scopes. */
3784 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3786 if (scope->kind == sk_class)
3788 cxx_binding *class_binding;
3790 class_binding = get_class_binding (name, scope);
3793 /* Thread this new class-scope binding onto the
3794 IDENTIFIER_BINDING list so that future lookups
3796 class_binding->previous = outer;
3798 binding->previous = class_binding;
3800 IDENTIFIER_BINDING (name) = class_binding;
3801 return class_binding;
3804 scope = scope->level_chain;
3810 /* Return the innermost block-scope or class-scope value binding for
3811 NAME, or NULL_TREE if there is no such binding. */
3814 innermost_non_namespace_value (tree name)
3816 cxx_binding *binding;
3817 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3818 return binding ? binding->value : NULL_TREE;
3821 /* Look up NAME in the current binding level and its superiors in the
3822 namespace of variables, functions and typedefs. Return a ..._DECL
3823 node of some kind representing its definition if there is only one
3824 such declaration, or return a TREE_LIST with all the overloaded
3825 definitions if there are many, or return 0 if it is undefined.
3826 Hidden name, either friend declaration or built-in function, are
3829 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3830 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3831 Otherwise we prefer non-TYPE_DECLs.
3833 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3834 BLOCK_P is false, bindings in block scopes are ignored. */
3837 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3838 int namespaces_only, int flags)
3841 tree val = NULL_TREE;
3843 timevar_push (TV_NAME_LOOKUP);
3844 /* Conversion operators are handled specially because ordinary
3845 unqualified name lookup will not find template conversion
3847 if (IDENTIFIER_TYPENAME_P (name))
3849 struct cp_binding_level *level;
3851 for (level = current_binding_level;
3852 level && level->kind != sk_namespace;
3853 level = level->level_chain)
3858 /* A conversion operator can only be declared in a class
3860 if (level->kind != sk_class)
3863 /* Lookup the conversion operator in the class. */
3864 class_type = level->this_entity;
3865 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3867 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3873 flags |= lookup_flags (prefer_type, namespaces_only);
3875 /* First, look in non-namespace scopes. */
3877 if (current_class_type == NULL_TREE)
3880 if (block_p || !nonclass)
3881 for (iter = outer_binding (name, NULL, !nonclass);
3883 iter = outer_binding (name, iter, !nonclass))
3887 /* Skip entities we don't want. */
3888 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3891 /* If this is the kind of thing we're looking for, we're done. */
3892 if (qualify_lookup (iter->value, flags)
3893 && !hidden_name_p (iter->value))
3894 binding = iter->value;
3895 else if ((flags & LOOKUP_PREFER_TYPES)
3896 && qualify_lookup (iter->type, flags)
3897 && !hidden_name_p (iter->type))
3898 binding = iter->type;
3900 binding = NULL_TREE;
3909 /* Now lookup in namespace scopes. */
3911 val = unqualified_namespace_lookup (name, flags);
3915 /* If we have a single function from a using decl, pull it out. */
3916 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3917 val = OVL_FUNCTION (val);
3920 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3924 lookup_name_nonclass (tree name)
3926 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
3930 lookup_function_nonclass (tree name, tree args, bool block_p)
3933 lookup_arg_dependent (name,
3934 lookup_name_real (name, 0, 1, block_p, 0,
3940 lookup_name (tree name, int prefer_type)
3942 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
3943 0, LOOKUP_COMPLAIN);
3946 /* Look up NAME for type used in elaborated name specifier in
3947 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
3948 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
3949 name, more scopes are checked if cleanup or template parameter
3950 scope is encountered.
3952 Unlike lookup_name_real, we make sure that NAME is actually
3953 declared in the desired scope, not from inheritance, nor using
3954 directive. For using declaration, there is DR138 still waiting
3955 to be resolved. Hidden name coming from an earlier friend
3956 declaration is also returned.
3958 A TYPE_DECL best matching the NAME is returned. Catching error
3959 and issuing diagnostics are caller's responsibility. */
3962 lookup_type_scope (tree name, tag_scope scope)
3964 cxx_binding *iter = NULL;
3965 tree val = NULL_TREE;
3967 timevar_push (TV_NAME_LOOKUP);
3969 /* Look in non-namespace scope first. */
3970 if (current_binding_level->kind != sk_namespace)
3971 iter = outer_binding (name, NULL, /*class_p=*/ true);
3972 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
3974 /* Check if this is the kind of thing we're looking for.
3975 If SCOPE is TS_CURRENT, also make sure it doesn't come from
3976 base class. For ITER->VALUE, we can simply use
3977 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
3980 We check ITER->TYPE before ITER->VALUE in order to handle
3981 typedef struct C {} C;
3984 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
3985 && (scope != ts_current
3986 || LOCAL_BINDING_P (iter)
3987 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
3989 else if ((scope != ts_current
3990 || !INHERITED_VALUE_BINDING_P (iter))
3991 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
3998 /* Look in namespace scope. */
4001 iter = cxx_scope_find_binding_for_name
4002 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4006 /* If this is the kind of thing we're looking for, we're done. */
4007 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4009 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4015 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4016 and template parameter scopes. */
4019 struct cp_binding_level *b = current_binding_level;
4022 if (iter->scope == b)
4023 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4025 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4027 else if (b->kind == sk_class
4028 && scope == ts_within_enclosing_non_class)
4035 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4038 /* Similar to `lookup_name' but look only in the innermost non-class
4042 lookup_name_innermost_nonclass_level (tree name)
4044 struct cp_binding_level *b;
4047 timevar_push (TV_NAME_LOOKUP);
4048 b = innermost_nonclass_level ();
4050 if (b->kind == sk_namespace)
4052 t = IDENTIFIER_NAMESPACE_VALUE (name);
4054 /* extern "C" function() */
4055 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4058 else if (IDENTIFIER_BINDING (name)
4059 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4061 cxx_binding *binding;
4062 binding = IDENTIFIER_BINDING (name);
4065 if (binding->scope == b
4066 && !(TREE_CODE (binding->value) == VAR_DECL
4067 && DECL_DEAD_FOR_LOCAL (binding->value)))
4068 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4070 if (b->kind == sk_cleanup)
4077 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4080 /* Like lookup_name_innermost_nonclass_level, but for types. */
4083 lookup_type_current_level (tree name)
4087 timevar_push (TV_NAME_LOOKUP);
4088 gcc_assert (current_binding_level->kind != sk_namespace);
4090 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4091 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4093 struct cp_binding_level *b = current_binding_level;
4096 if (purpose_member (name, b->type_shadowed))
4097 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4098 REAL_IDENTIFIER_TYPE_VALUE (name));
4099 if (b->kind == sk_cleanup)
4106 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4109 /* [basic.lookup.koenig] */
4110 /* A nonzero return value in the functions below indicates an error. */
4120 static bool arg_assoc (struct arg_lookup*, tree);
4121 static bool arg_assoc_args (struct arg_lookup*, tree);
4122 static bool arg_assoc_type (struct arg_lookup*, tree);
4123 static bool add_function (struct arg_lookup *, tree);
4124 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4125 static bool arg_assoc_class (struct arg_lookup *, tree);
4126 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4128 /* Add a function to the lookup structure.
4129 Returns true on error. */
4132 add_function (struct arg_lookup *k, tree fn)
4134 /* We used to check here to see if the function was already in the list,
4135 but that's O(n^2), which is just too expensive for function lookup.
4136 Now we deal with the occasional duplicate in joust. In doing this, we
4137 assume that the number of duplicates will be small compared to the
4138 total number of functions being compared, which should usually be the
4141 /* We must find only functions, or exactly one non-function. */
4144 else if (fn == k->functions)
4146 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4147 k->functions = build_overload (fn, k->functions);
4150 tree f1 = OVL_CURRENT (k->functions);
4152 if (is_overloaded_fn (f1))
4154 fn = f1; f1 = f2; f2 = fn;
4156 error ("%q+D is not a function,", f1);
4157 error (" conflict with %q+D", f2);
4158 error (" in call to %qD", k->name);
4165 /* Returns true iff CURRENT has declared itself to be an associated
4166 namespace of SCOPE via a strong using-directive (or transitive chain
4167 thereof). Both are namespaces. */
4170 is_associated_namespace (tree current, tree scope)
4172 tree seen = NULL_TREE;
4173 tree todo = NULL_TREE;
4177 if (scope == current)
4179 seen = tree_cons (scope, NULL_TREE, seen);
4180 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4181 if (!purpose_member (TREE_PURPOSE (t), seen))
4182 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4185 scope = TREE_PURPOSE (todo);
4186 todo = TREE_CHAIN (todo);
4193 /* Add functions of a namespace to the lookup structure.
4194 Returns true on error. */
4197 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4201 if (purpose_member (scope, k->namespaces))
4203 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4205 /* Check out our super-users. */
4206 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4207 value = TREE_CHAIN (value))
4208 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4211 value = namespace_binding (k->name, scope);
4215 for (; value; value = OVL_NEXT (value))
4216 if (add_function (k, OVL_CURRENT (value)))
4222 /* Adds everything associated with a template argument to the lookup
4223 structure. Returns true on error. */
4226 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4228 /* [basic.lookup.koenig]
4230 If T is a template-id, its associated namespaces and classes are
4231 ... the namespaces and classes associated with the types of the
4232 template arguments provided for template type parameters
4233 (excluding template template parameters); the namespaces in which
4234 any template template arguments are defined; and the classes in
4235 which any member templates used as template template arguments
4236 are defined. [Note: non-type template arguments do not
4237 contribute to the set of associated namespaces. ] */
4239 /* Consider first template template arguments. */
4240 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4241 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4243 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4245 tree ctx = CP_DECL_CONTEXT (arg);
4247 /* It's not a member template. */
4248 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4249 return arg_assoc_namespace (k, ctx);
4250 /* Otherwise, it must be member template. */
4252 return arg_assoc_class (k, ctx);
4254 /* It's not a template template argument, but it is a type template
4256 else if (TYPE_P (arg))
4257 return arg_assoc_type (k, arg);
4258 /* It's a non-type template argument. */
4263 /* Adds everything associated with class to the lookup structure.
4264 Returns true on error. */
4267 arg_assoc_class (struct arg_lookup *k, tree type)
4269 tree list, friends, context;
4272 /* Backend build structures, such as __builtin_va_list, aren't
4273 affected by all this. */
4274 if (!CLASS_TYPE_P (type))
4277 if (purpose_member (type, k->classes))
4279 k->classes = tree_cons (type, NULL_TREE, k->classes);
4281 context = decl_namespace_context (type);
4282 if (arg_assoc_namespace (k, context))
4285 if (TYPE_BINFO (type))
4287 /* Process baseclasses. */
4288 tree binfo, base_binfo;
4290 for (binfo = TYPE_BINFO (type), i = 0;
4291 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4292 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4296 /* Process friends. */
4297 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4298 list = TREE_CHAIN (list))
4299 if (k->name == FRIEND_NAME (list))
4300 for (friends = FRIEND_DECLS (list); friends;
4301 friends = TREE_CHAIN (friends))
4303 tree fn = TREE_VALUE (friends);
4305 /* Only interested in global functions with potentially hidden
4306 (i.e. unqualified) declarations. */
4307 if (CP_DECL_CONTEXT (fn) != context)
4309 /* Template specializations are never found by name lookup.
4310 (Templates themselves can be found, but not template
4311 specializations.) */
4312 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4314 if (add_function (k, fn))
4318 /* Process template arguments. */
4319 if (CLASSTYPE_TEMPLATE_INFO (type)
4320 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4322 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4323 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4324 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4330 /* Adds everything associated with a given type.
4331 Returns 1 on error. */
4334 arg_assoc_type (struct arg_lookup *k, tree type)
4336 /* As we do not get the type of non-type dependent expressions
4337 right, we can end up with such things without a type. */
4341 if (TYPE_PTRMEM_P (type))
4343 /* Pointer to member: associate class type and value type. */
4344 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4346 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4348 else switch (TREE_CODE (type))
4361 if (TYPE_PTRMEMFUNC_P (type))
4362 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4363 return arg_assoc_class (k, type);
4365 case REFERENCE_TYPE:
4367 return arg_assoc_type (k, TREE_TYPE (type));
4370 return arg_assoc_namespace (k, decl_namespace_context (type));
4372 /* The basetype is referenced in the first arg type, so just
4375 /* Associate the parameter types. */
4376 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4378 /* Associate the return type. */
4379 return arg_assoc_type (k, TREE_TYPE (type));
4380 case TEMPLATE_TYPE_PARM:
4381 case BOUND_TEMPLATE_TEMPLATE_PARM:
4386 gcc_assert (type == unknown_type_node);
4394 /* Adds everything associated with arguments. Returns true on error. */
4397 arg_assoc_args (struct arg_lookup *k, tree args)
4399 for (; args; args = TREE_CHAIN (args))
4400 if (arg_assoc (k, TREE_VALUE (args)))
4405 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4408 arg_assoc (struct arg_lookup *k, tree n)
4410 if (n == error_mark_node)
4414 return arg_assoc_type (k, n);
4416 if (! type_unknown_p (n))
4417 return arg_assoc_type (k, TREE_TYPE (n));
4419 if (TREE_CODE (n) == ADDR_EXPR)
4420 n = TREE_OPERAND (n, 0);
4421 if (TREE_CODE (n) == COMPONENT_REF)
4422 n = TREE_OPERAND (n, 1);
4423 if (TREE_CODE (n) == OFFSET_REF)
4424 n = TREE_OPERAND (n, 1);
4425 while (TREE_CODE (n) == TREE_LIST)
4427 if (TREE_CODE (n) == BASELINK)
4428 n = BASELINK_FUNCTIONS (n);
4430 if (TREE_CODE (n) == FUNCTION_DECL)
4431 return arg_assoc_type (k, TREE_TYPE (n));
4432 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4434 /* [basic.lookup.koenig]
4436 If T is a template-id, its associated namespaces and classes
4437 are the namespace in which the template is defined; for
4438 member templates, the member template's class... */
4439 tree template = TREE_OPERAND (n, 0);
4440 tree args = TREE_OPERAND (n, 1);
4444 if (TREE_CODE (template) == COMPONENT_REF)
4445 template = TREE_OPERAND (template, 1);
4447 /* First, the template. There may actually be more than one if
4448 this is an overloaded function template. But, in that case,
4449 we only need the first; all the functions will be in the same
4451 template = OVL_CURRENT (template);
4453 ctx = CP_DECL_CONTEXT (template);
4455 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4457 if (arg_assoc_namespace (k, ctx) == 1)
4460 /* It must be a member template. */
4461 else if (arg_assoc_class (k, ctx) == 1)
4464 /* Now the arguments. */
4465 for (ix = TREE_VEC_LENGTH (args); ix--;)
4466 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4469 else if (TREE_CODE (n) == OVERLOAD)
4471 for (; n; n = OVL_CHAIN (n))
4472 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4479 /* Performs Koenig lookup depending on arguments, where fns
4480 are the functions found in normal lookup. */
4483 lookup_arg_dependent (tree name, tree fns, tree args)
4485 struct arg_lookup k;
4487 timevar_push (TV_NAME_LOOKUP);
4490 k.classes = NULL_TREE;
4492 /* We previously performed an optimization here by setting
4493 NAMESPACES to the current namespace when it was safe. However, DR
4494 164 says that namespaces that were already searched in the first
4495 stage of template processing are searched again (potentially
4496 picking up later definitions) in the second stage. */
4497 k.namespaces = NULL_TREE;
4499 arg_assoc_args (&k, args);
4500 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4503 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4504 changed (i.e. there was already a directive), or the fresh
4505 TREE_LIST otherwise. */
4508 push_using_directive (tree used)
4510 tree ud = current_binding_level->using_directives;
4511 tree iter, ancestor;
4513 timevar_push (TV_NAME_LOOKUP);
4514 /* Check if we already have this. */
4515 if (purpose_member (used, ud) != NULL_TREE)
4516 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4518 ancestor = namespace_ancestor (current_decl_namespace (), used);
4519 ud = current_binding_level->using_directives;
4520 ud = tree_cons (used, ancestor, ud);
4521 current_binding_level->using_directives = ud;
4523 /* Recursively add all namespaces used. */
4524 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4525 push_using_directive (TREE_PURPOSE (iter));
4527 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4530 /* The type TYPE is being declared. If it is a class template, or a
4531 specialization of a class template, do any processing required and
4532 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4533 being declared a friend. B is the binding level at which this TYPE
4536 Returns the TYPE_DECL for TYPE, which may have been altered by this
4540 maybe_process_template_type_declaration (tree type, int is_friend,
4543 tree decl = TYPE_NAME (type);
4545 if (processing_template_parmlist)
4546 /* You can't declare a new template type in a template parameter
4547 list. But, you can declare a non-template type:
4549 template <class A*> struct S;
4551 is a forward-declaration of `A'. */
4555 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4557 if (processing_template_decl)
4559 /* This may change after the call to
4560 push_template_decl_real, but we want the original value. */
4561 tree name = DECL_NAME (decl);
4563 decl = push_template_decl_real (decl, is_friend);
4564 /* If the current binding level is the binding level for the
4565 template parameters (see the comment in
4566 begin_template_parm_list) and the enclosing level is a class
4567 scope, and we're not looking at a friend, push the
4568 declaration of the member class into the class scope. In the
4569 friend case, push_template_decl will already have put the
4570 friend into global scope, if appropriate. */
4571 if (TREE_CODE (type) != ENUMERAL_TYPE
4572 && !is_friend && b->kind == sk_template_parms
4573 && b->level_chain->kind == sk_class)
4575 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4577 if (!COMPLETE_TYPE_P (current_class_type))
4579 maybe_add_class_template_decl_list (current_class_type,
4580 type, /*friend_p=*/0);
4581 /* Put this UTD in the table of UTDs for the class. */
4582 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4583 CLASSTYPE_NESTED_UTDS (current_class_type) =
4584 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4586 binding_table_insert
4587 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4596 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4597 that the NAME is a class template, the tag is processed but not pushed.
4599 The pushed scope depend on the SCOPE parameter:
4600 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4602 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4603 non-template-parameter scope. This case is needed for forward
4605 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4606 TS_GLOBAL case except that names within template-parameter scopes
4607 are not pushed at all.
4609 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4612 pushtag (tree name, tree type, tag_scope scope)
4614 struct cp_binding_level *b;
4617 timevar_push (TV_NAME_LOOKUP);
4618 b = current_binding_level;
4619 while (/* Cleanup scopes are not scopes from the point of view of
4621 b->kind == sk_cleanup
4622 /* Neither are the scopes used to hold template parameters
4623 for an explicit specialization. For an ordinary template
4624 declaration, these scopes are not scopes from the point of
4625 view of the language. */
4626 || (b->kind == sk_template_parms
4627 && (b->explicit_spec_p || scope == ts_global))
4628 || (b->kind == sk_class
4629 && (scope != ts_current
4630 /* We may be defining a new type in the initializer
4631 of a static member variable. We allow this when
4632 not pedantic, and it is particularly useful for
4633 type punning via an anonymous union. */
4634 || COMPLETE_TYPE_P (b->this_entity))))
4637 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4639 /* Do C++ gratuitous typedefing. */
4640 if (IDENTIFIER_TYPE_VALUE (name) != type)
4644 tree context = TYPE_CONTEXT (type);
4648 tree cs = current_scope ();
4650 if (scope == ts_current)
4652 else if (cs != NULL_TREE && TYPE_P (cs))
4653 /* When declaring a friend class of a local class, we want
4654 to inject the newly named class into the scope
4655 containing the local class, not the namespace
4657 context = decl_function_context (get_type_decl (cs));
4660 context = current_namespace;
4662 if (b->kind == sk_class
4663 || (b->kind == sk_template_parms
4664 && b->level_chain->kind == sk_class))
4667 if (current_lang_name == lang_name_java)
4668 TYPE_FOR_JAVA (type) = 1;
4670 tdef = create_implicit_typedef (name, type);
4671 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4672 if (scope == ts_within_enclosing_non_class)
4674 /* This is a friend. Make this TYPE_DECL node hidden from
4675 ordinary name lookup. Its corresponding TEMPLATE_DECL
4676 will be marked in push_template_decl_real. */
4677 retrofit_lang_decl (tdef);
4678 DECL_ANTICIPATED (tdef) = 1;
4679 DECL_FRIEND_P (tdef) = 1;
4682 decl = maybe_process_template_type_declaration
4683 (type, scope == ts_within_enclosing_non_class, b);
4684 if (decl == error_mark_node)
4685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4688 set_identifier_type_value_with_scope (name, tdef, b);
4690 if (b->kind == sk_class)
4692 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4693 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4694 class. But if it's a member template class, we want
4695 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4697 finish_member_declaration (decl);
4699 pushdecl_class_level (decl);
4701 else if (b->kind != sk_template_parms)
4702 decl = pushdecl_with_scope (decl, b);
4704 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4706 /* If this is a local class, keep track of it. We need this
4707 information for name-mangling, and so that it is possible to
4708 find all function definitions in a translation unit in a
4709 convenient way. (It's otherwise tricky to find a member
4710 function definition it's only pointed to from within a local
4712 if (TYPE_CONTEXT (type)
4713 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4714 VEC_safe_push (tree, gc, local_classes, type);
4716 if (b->kind == sk_class
4717 && !COMPLETE_TYPE_P (current_class_type))
4719 maybe_add_class_template_decl_list (current_class_type,
4720 type, /*friend_p=*/0);
4722 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4723 CLASSTYPE_NESTED_UTDS (current_class_type)
4724 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4726 binding_table_insert
4727 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4730 decl = TYPE_NAME (type);
4731 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4732 TYPE_STUB_DECL (type) = decl;
4734 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4737 /* Subroutines for reverting temporarily to top-level for instantiation
4738 of templates and such. We actually need to clear out the class- and
4739 local-value slots of all identifiers, so that only the global values
4740 are at all visible. Simply setting current_binding_level to the global
4741 scope isn't enough, because more binding levels may be pushed. */
4742 struct saved_scope *scope_chain;
4744 /* If ID has not already been marked, add an appropriate binding to
4748 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4750 cxx_saved_binding *saved;
4752 if (!id || !IDENTIFIER_BINDING (id))
4755 if (IDENTIFIER_MARKED (id))
4758 IDENTIFIER_MARKED (id) = 1;
4760 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4761 saved->identifier = id;
4762 saved->binding = IDENTIFIER_BINDING (id);
4763 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4764 IDENTIFIER_BINDING (id) = NULL;
4768 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4772 timevar_push (TV_NAME_LOOKUP);
4773 for (t = names; t; t = TREE_CHAIN (t))
4777 if (TREE_CODE (t) == TREE_LIST)
4778 id = TREE_PURPOSE (t);
4782 store_binding (id, old_bindings);
4784 timevar_pop (TV_NAME_LOOKUP);
4787 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4788 objects, rather than a TREE_LIST. */
4791 store_class_bindings (VEC(cp_class_binding,gc) *names,
4792 VEC(cxx_saved_binding,gc) **old_bindings)
4795 cp_class_binding *cb;
4797 timevar_push (TV_NAME_LOOKUP);
4798 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4799 store_binding (cb->identifier, old_bindings);
4800 timevar_pop (TV_NAME_LOOKUP);
4804 push_to_top_level (void)
4806 struct saved_scope *s;
4807 struct cp_binding_level *b;
4808 cxx_saved_binding *sb;
4812 timevar_push (TV_NAME_LOOKUP);
4813 s = GGC_CNEW (struct saved_scope);
4815 b = scope_chain ? current_binding_level : 0;
4817 /* If we're in the middle of some function, save our state. */
4821 push_function_context_to (NULL_TREE);
4826 if (scope_chain && previous_class_level)
4827 store_class_bindings (previous_class_level->class_shadowed,
4830 /* Have to include the global scope, because class-scope decls
4831 aren't listed anywhere useful. */
4832 for (; b; b = b->level_chain)
4836 /* Template IDs are inserted into the global level. If they were
4837 inserted into namespace level, finish_file wouldn't find them
4838 when doing pending instantiations. Therefore, don't stop at
4839 namespace level, but continue until :: . */
4840 if (global_scope_p (b))
4843 store_bindings (b->names, &s->old_bindings);
4844 /* We also need to check class_shadowed to save class-level type
4845 bindings, since pushclass doesn't fill in b->names. */
4846 if (b->kind == sk_class)
4847 store_class_bindings (b->class_shadowed, &s->old_bindings);
4849 /* Unwind type-value slots back to top level. */
4850 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4851 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4854 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
4855 IDENTIFIER_MARKED (sb->identifier) = 0;
4857 s->prev = scope_chain;
4859 s->need_pop_function_context = need_pop;
4860 s->function_decl = current_function_decl;
4861 s->skip_evaluation = skip_evaluation;
4864 current_function_decl = NULL_TREE;
4865 current_lang_base = VEC_alloc (tree, gc, 10);
4866 current_lang_name = lang_name_cplusplus;
4867 current_namespace = global_namespace;
4868 skip_evaluation = 0;
4869 timevar_pop (TV_NAME_LOOKUP);
4873 pop_from_top_level (void)
4875 struct saved_scope *s = scope_chain;
4876 cxx_saved_binding *saved;
4879 timevar_push (TV_NAME_LOOKUP);
4880 /* Clear out class-level bindings cache. */
4881 if (previous_class_level)
4882 invalidate_class_lookup_cache ();
4884 current_lang_base = 0;
4886 scope_chain = s->prev;
4887 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
4889 tree id = saved->identifier;
4891 IDENTIFIER_BINDING (id) = saved->binding;
4892 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
4895 /* If we were in the middle of compiling a function, restore our
4897 if (s->need_pop_function_context)
4898 pop_function_context_from (NULL_TREE);
4899 current_function_decl = s->function_decl;
4900 skip_evaluation = s->skip_evaluation;
4901 timevar_pop (TV_NAME_LOOKUP);
4904 /* Pop off extraneous binding levels left over due to syntax errors.
4906 We don't pop past namespaces, as they might be valid. */
4909 pop_everything (void)
4911 if (ENABLE_SCOPE_CHECKING)
4912 verbatim ("XXX entering pop_everything ()\n");
4913 while (!toplevel_bindings_p ())
4915 if (current_binding_level->kind == sk_class)
4916 pop_nested_class ();
4920 if (ENABLE_SCOPE_CHECKING)
4921 verbatim ("XXX leaving pop_everything ()\n");
4924 /* Emit debugging information for using declarations and directives.
4925 If input tree is overloaded fn then emit debug info for all
4929 cp_emit_debug_info_for_using (tree t, tree context)
4931 /* Don't try to emit any debug information if we have errors. */
4932 if (sorrycount || errorcount)
4935 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
4936 of a builtin function. */
4937 if (TREE_CODE (t) == FUNCTION_DECL
4938 && DECL_EXTERNAL (t)
4939 && DECL_BUILT_IN (t))
4942 /* Do not supply context to imported_module_or_decl, if
4943 it is a global namespace. */
4944 if (context == global_namespace)
4945 context = NULL_TREE;
4948 t = BASELINK_FUNCTIONS (t);
4950 /* FIXME: Handle TEMPLATE_DECLs. */
4951 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
4952 if (TREE_CODE (t) != TEMPLATE_DECL)
4953 (*debug_hooks->imported_module_or_decl) (t, context);
4956 #include "gt-cp-name-lookup.h"