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, bool);
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 anticipated but has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval)
444 && !DECL_HIDDEN_FRIEND_P (bval)))
445 binding->value = decl;
446 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
448 /* The old binding was a type name. It was placed in
449 VALUE field because it was thought, at the point it was
450 declared, to be the only entity with such a name. Move the
451 type name into the type slot; it is now hidden by the new
453 binding->type = bval;
454 binding->value = decl;
455 binding->value_is_inherited = false;
457 else if (TREE_CODE (bval) == TYPE_DECL
458 && TREE_CODE (decl) == TYPE_DECL
459 && DECL_NAME (decl) == DECL_NAME (bval)
460 && binding->scope->kind != sk_class
461 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
462 /* If either type involves template parameters, we must
463 wait until instantiation. */
464 || uses_template_parms (TREE_TYPE (decl))
465 || uses_template_parms (TREE_TYPE (bval))))
466 /* We have two typedef-names, both naming the same type to have
467 the same name. In general, this is OK because of:
471 In a given scope, a typedef specifier can be used to redefine
472 the name of any type declared in that scope to refer to the
473 type to which it already refers.
475 However, in class scopes, this rule does not apply due to the
476 stricter language in [class.mem] prohibiting redeclarations of
479 /* There can be two block-scope declarations of the same variable,
480 so long as they are `extern' declarations. However, there cannot
481 be two declarations of the same static data member:
485 A member shall not be declared twice in the
486 member-specification. */
487 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
488 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
489 && !DECL_CLASS_SCOPE_P (decl))
491 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
494 else if (TREE_CODE (decl) == NAMESPACE_DECL
495 && TREE_CODE (bval) == NAMESPACE_DECL
496 && DECL_NAMESPACE_ALIAS (decl)
497 && DECL_NAMESPACE_ALIAS (bval)
498 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
501 In a declarative region, a namespace-alias-definition can be
502 used to redefine a namespace-alias declared in that declarative
503 region to refer only to the namespace to which it already
508 error ("declaration of %q#D", decl);
509 error ("conflicts with previous declaration %q+#D", bval);
513 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
516 /* Add DECL to the list of things declared in B. */
519 add_decl_to_level (tree decl, cxx_scope *b)
521 if (TREE_CODE (decl) == NAMESPACE_DECL
522 && !DECL_NAMESPACE_ALIAS (decl))
524 TREE_CHAIN (decl) = b->namespaces;
525 b->namespaces = decl;
527 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
529 TREE_CHAIN (decl) = b->vtables;
534 /* We build up the list in reverse order, and reverse it later if
536 TREE_CHAIN (decl) = b->names;
540 /* If appropriate, add decl to separate list of statics. We
541 include extern variables because they might turn out to be
542 static later. It's OK for this list to contain a few false
544 if (b->kind == sk_namespace)
545 if ((TREE_CODE (decl) == VAR_DECL
546 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
547 || (TREE_CODE (decl) == FUNCTION_DECL
548 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
549 VEC_safe_push (tree, gc, b->static_decls, decl);
553 /* Record a decl-node X as belonging to the current lexical scope.
554 Check for errors (such as an incompatible declaration for the same
555 name already seen in the same scope). IS_FRIEND is true if X is
556 declared as a friend.
558 Returns either X or an old decl for the same name.
559 If an old decl is returned, it may have been smashed
560 to agree with what X says. */
563 pushdecl_maybe_friend (tree x, bool is_friend)
567 int need_new_binding;
569 timevar_push (TV_NAME_LOOKUP);
571 need_new_binding = 1;
573 if (DECL_TEMPLATE_PARM_P (x))
574 /* Template parameters have no context; they are not X::T even
575 when declared within a class or namespace. */
579 if (current_function_decl && x != current_function_decl
580 /* A local declaration for a function doesn't constitute
582 && TREE_CODE (x) != FUNCTION_DECL
583 /* A local declaration for an `extern' variable is in the
584 scope of the current namespace, not the current
586 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
587 && !DECL_CONTEXT (x))
588 DECL_CONTEXT (x) = current_function_decl;
590 /* If this is the declaration for a namespace-scope function,
591 but the declaration itself is in a local scope, mark the
593 if (TREE_CODE (x) == FUNCTION_DECL
594 && DECL_NAMESPACE_SCOPE_P (x)
595 && current_function_decl
596 && x != current_function_decl)
597 DECL_LOCAL_FUNCTION_P (x) = 1;
600 name = DECL_NAME (x);
603 int different_binding_level = 0;
605 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
606 check_default_args (x);
608 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
609 name = TREE_OPERAND (name, 0);
611 /* In case this decl was explicitly namespace-qualified, look it
612 up in its namespace context. */
613 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
614 t = namespace_binding (name, DECL_CONTEXT (x));
616 t = lookup_name_innermost_nonclass_level (name);
618 /* [basic.link] If there is a visible declaration of an entity
619 with linkage having the same name and type, ignoring entities
620 declared outside the innermost enclosing namespace scope, the
621 block scope declaration declares that same entity and
622 receives the linkage of the previous declaration. */
623 if (! t && current_function_decl && x != current_function_decl
624 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
625 && DECL_EXTERNAL (x))
627 /* Look in block scope. */
628 t = innermost_non_namespace_value (name);
629 /* Or in the innermost namespace. */
631 t = namespace_binding (name, DECL_CONTEXT (x));
632 /* Does it have linkage? Note that if this isn't a DECL, it's an
633 OVERLOAD, which is OK. */
634 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
637 different_binding_level = 1;
640 /* If we are declaring a function, and the result of name-lookup
641 was an OVERLOAD, look for an overloaded instance that is
642 actually the same as the function we are declaring. (If
643 there is one, we have to merge our declaration with the
644 previous declaration.) */
645 if (t && TREE_CODE (t) == OVERLOAD)
649 if (TREE_CODE (x) == FUNCTION_DECL)
650 for (match = t; match; match = OVL_NEXT (match))
652 if (decls_match (OVL_CURRENT (match), x))
656 /* Just choose one. */
660 t = OVL_CURRENT (match);
665 if (t && t != error_mark_node)
667 if (different_binding_level)
669 if (decls_match (x, t))
670 /* The standard only says that the local extern
671 inherits linkage from the previous decl; in
672 particular, default args are not shared. We must
673 also tell cgraph to treat these decls as the same,
674 or we may neglect to emit an "unused" static - we
675 do this by making the DECL_UIDs equal, which should
676 be viewed as a kludge. FIXME. */
678 TREE_PUBLIC (x) = TREE_PUBLIC (t);
679 DECL_UID (x) = DECL_UID (t);
682 else if (TREE_CODE (t) == PARM_DECL)
684 gcc_assert (DECL_CONTEXT (t));
686 /* Check for duplicate params. */
687 if (duplicate_decls (x, t, is_friend))
688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
690 else if ((DECL_EXTERN_C_FUNCTION_P (x)
691 || DECL_FUNCTION_TEMPLATE_P (x))
692 && is_overloaded_fn (t))
693 /* Don't do anything just yet. */;
694 else if (t == wchar_decl_node)
696 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
697 pedwarn ("redeclaration of %<wchar_t%> as %qT",
700 /* Throw away the redeclaration. */
701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
705 tree olddecl = duplicate_decls (x, t, is_friend);
707 /* If the redeclaration failed, we can stop at this
709 if (olddecl == error_mark_node)
710 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
714 if (TREE_CODE (t) == TYPE_DECL)
715 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
719 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
721 /* A redeclaration of main, but not a duplicate of the
726 This function shall not be overloaded. */
727 error ("invalid redeclaration of %q+D", t);
729 /* We don't try to push this declaration since that
731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
736 check_template_shadow (x);
738 /* If this is a function conjured up by the backend, massage it
739 so it looks friendly. */
740 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
742 retrofit_lang_decl (x);
743 SET_DECL_LANGUAGE (x, lang_c);
746 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
748 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
751 if (!namespace_bindings_p ())
752 /* We do not need to create a binding for this name;
753 push_overloaded_decl will have already done so if
755 need_new_binding = 0;
757 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
759 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
761 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
762 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
765 /* If declaring a type as a typedef, copy the type (unless we're
766 at line 0), and install this TYPE_DECL as the new type's typedef
767 name. See the extensive comment in ../c-decl.c (pushdecl). */
768 if (TREE_CODE (x) == TYPE_DECL)
770 tree type = TREE_TYPE (x);
771 if (DECL_IS_BUILTIN (x))
773 if (TYPE_NAME (type) == 0)
774 TYPE_NAME (type) = x;
776 else if (type != error_mark_node && TYPE_NAME (type) != x
777 /* We don't want to copy the type when all we're
778 doing is making a TYPE_DECL for the purposes of
780 && (!TYPE_NAME (type)
781 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
783 DECL_ORIGINAL_TYPE (x) = type;
784 type = build_variant_type_copy (type);
785 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
786 TYPE_NAME (type) = x;
787 TREE_TYPE (x) = type;
790 if (type != error_mark_node
792 && TYPE_IDENTIFIER (type))
793 set_identifier_type_value (DECL_NAME (x), x);
796 /* Multiple external decls of the same identifier ought to match.
798 We get warnings about inline functions where they are defined.
799 We get warnings about other functions from push_overloaded_decl.
801 Avoid duplicate warnings where they are used. */
802 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
806 decl = IDENTIFIER_NAMESPACE_VALUE (name);
807 if (decl && TREE_CODE (decl) == OVERLOAD)
808 decl = OVL_FUNCTION (decl);
810 if (decl && decl != error_mark_node
811 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
812 /* If different sort of thing, we already gave an error. */
813 && TREE_CODE (decl) == TREE_CODE (x)
814 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
816 pedwarn ("type mismatch with previous external decl of %q#D", x);
817 pedwarn ("previous external decl of %q+#D", decl);
821 if (TREE_CODE (x) == FUNCTION_DECL
823 && !flag_friend_injection)
825 /* This is a new declaration of a friend function, so hide
826 it from ordinary function lookup. */
827 DECL_ANTICIPATED (x) = 1;
828 DECL_HIDDEN_FRIEND_P (x) = 1;
831 /* This name is new in its binding level.
832 Install the new declaration and return it. */
833 if (namespace_bindings_p ())
835 /* Install a global value. */
837 /* If the first global decl has external linkage,
838 warn if we later see static one. */
839 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
840 TREE_PUBLIC (name) = 1;
842 /* Bind the name for the entity. */
843 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
845 && (TREE_CODE (x) == TYPE_DECL
846 || TREE_CODE (x) == VAR_DECL
847 || TREE_CODE (x) == NAMESPACE_DECL
848 || TREE_CODE (x) == CONST_DECL
849 || TREE_CODE (x) == TEMPLATE_DECL))
850 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
852 /* If new decl is `static' and an `extern' was seen previously,
854 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
855 warn_extern_redeclared_static (x, t);
859 /* Here to install a non-global value. */
860 tree oldlocal = innermost_non_namespace_value (name);
861 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
863 if (need_new_binding)
865 push_local_binding (name, x, 0);
866 /* Because push_local_binding will hook X on to the
867 current_binding_level's name list, we don't want to
868 do that again below. */
869 need_new_binding = 0;
872 /* If this is a TYPE_DECL, push it into the type value slot. */
873 if (TREE_CODE (x) == TYPE_DECL)
874 set_identifier_type_value (name, x);
876 /* Clear out any TYPE_DECL shadowed by a namespace so that
877 we won't think this is a type. The C struct hack doesn't
878 go through namespaces. */
879 if (TREE_CODE (x) == NAMESPACE_DECL)
880 set_identifier_type_value (name, NULL_TREE);
887 && TREE_CODE (oldlocal) == VAR_DECL
888 && DECL_DEAD_FOR_LOCAL (oldlocal))
889 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
891 if (oldlocal == NULL_TREE)
892 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
895 /* If this is an extern function declaration, see if we
896 have a global definition or declaration for the function. */
897 if (oldlocal == NULL_TREE
899 && oldglobal != NULL_TREE
900 && TREE_CODE (x) == FUNCTION_DECL
901 && TREE_CODE (oldglobal) == FUNCTION_DECL)
903 /* We have one. Their types must agree. */
904 if (decls_match (x, oldglobal))
908 warning (0, "extern declaration of %q#D doesn't match", x);
909 warning (0, "global declaration %q+#D", oldglobal);
912 /* If we have a local external declaration,
913 and no file-scope declaration has yet been seen,
914 then if we later have a file-scope decl it must not be static. */
915 if (oldlocal == NULL_TREE
916 && oldglobal == NULL_TREE
919 TREE_PUBLIC (name) = 1;
921 /* Warn if shadowing an argument at the top level of the body. */
922 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
923 /* Inline decls shadow nothing. */
924 && !DECL_FROM_INLINE (x)
925 && TREE_CODE (oldlocal) == PARM_DECL
926 /* Don't check the `this' parameter. */
927 && !DECL_ARTIFICIAL (oldlocal))
931 /* Don't complain if it's from an enclosing function. */
932 if (DECL_CONTEXT (oldlocal) == current_function_decl
933 && TREE_CODE (x) != PARM_DECL)
935 /* Go to where the parms should be and see if we find
937 struct cp_binding_level *b = current_binding_level->level_chain;
939 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
940 /* Skip the ctor/dtor cleanup level. */
944 if (b->kind == sk_function_parms)
946 error ("declaration of %q#D shadows a parameter", x);
951 if (warn_shadow && !err)
953 warning (0, "declaration of %q#D shadows a parameter", x);
954 warning (0, "%Jshadowed declaration is here", oldlocal);
958 /* Maybe warn if shadowing something else. */
959 else if (warn_shadow && !DECL_EXTERNAL (x)
960 /* No shadow warnings for internally generated vars. */
961 && ! DECL_ARTIFICIAL (x)
962 /* No shadow warnings for vars made for inlining. */
963 && ! DECL_FROM_INLINE (x))
967 if (current_class_ptr)
968 member = lookup_member (current_class_type,
971 /*want_type=*/false);
975 if (member && !TREE_STATIC (member))
977 /* Location of previous decl is not useful in this case. */
978 warning (0, "declaration of %qD shadows a member of 'this'",
981 else if (oldlocal != NULL_TREE
982 && TREE_CODE (oldlocal) == VAR_DECL)
984 warning (0, "declaration of %qD shadows a previous local", x);
985 warning (0, "%Jshadowed declaration is here", oldlocal);
987 else if (oldglobal != NULL_TREE
988 && TREE_CODE (oldglobal) == VAR_DECL)
989 /* XXX shadow warnings in outer-more namespaces */
991 warning (0, "declaration of %qD shadows a global declaration",
993 warning (0, "%Jshadowed declaration is here", oldglobal);
998 if (TREE_CODE (x) == VAR_DECL)
999 maybe_register_incomplete_var (x);
1002 if (need_new_binding)
1003 add_decl_to_level (x,
1004 DECL_NAMESPACE_SCOPE_P (x)
1005 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1006 : current_binding_level);
1008 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1011 /* Record a decl-node X as belonging to the current lexical scope. */
1016 return pushdecl_maybe_friend (x, false);
1019 /* Enter DECL into the symbol table, if that's appropriate. Returns
1020 DECL, or a modified version thereof. */
1023 maybe_push_decl (tree decl)
1025 tree type = TREE_TYPE (decl);
1027 /* Add this decl to the current binding level, but not if it comes
1028 from another scope, e.g. a static member variable. TEM may equal
1029 DECL or it may be a previous decl of the same name. */
1030 if (decl == error_mark_node
1031 || (TREE_CODE (decl) != PARM_DECL
1032 && DECL_CONTEXT (decl) != NULL_TREE
1033 /* Definitions of namespace members outside their namespace are
1035 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1036 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1037 || TREE_CODE (type) == UNKNOWN_TYPE
1038 /* The declaration of a template specialization does not affect
1039 the functions available for overload resolution, so we do not
1041 || (TREE_CODE (decl) == FUNCTION_DECL
1042 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1045 return pushdecl (decl);
1048 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1049 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1050 doesn't really belong to this binding level, that it got here
1051 through a using-declaration. */
1054 push_local_binding (tree id, tree decl, int flags)
1056 struct cp_binding_level *b;
1058 /* Skip over any local classes. This makes sense if we call
1059 push_local_binding with a friend decl of a local class. */
1060 b = innermost_nonclass_level ();
1062 if (lookup_name_innermost_nonclass_level (id))
1064 /* Supplement the existing binding. */
1065 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1066 /* It didn't work. Something else must be bound at this
1067 level. Do not add DECL to the list of things to pop
1072 /* Create a new binding. */
1073 push_binding (id, decl, b);
1075 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1076 /* We must put the OVERLOAD into a TREE_LIST since the
1077 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1078 decls that got here through a using-declaration. */
1079 decl = build_tree_list (NULL_TREE, decl);
1081 /* And put DECL on the list of things declared by the current
1083 add_decl_to_level (decl, b);
1086 /* Check to see whether or not DECL is a variable that would have been
1087 in scope under the ARM, but is not in scope under the ANSI/ISO
1088 standard. If so, issue an error message. If name lookup would
1089 work in both cases, but return a different result, this function
1090 returns the result of ANSI/ISO lookup. Otherwise, it returns
1094 check_for_out_of_scope_variable (tree decl)
1098 /* We only care about out of scope variables. */
1099 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1102 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1103 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1104 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1105 && DECL_DEAD_FOR_LOCAL (shadowed))
1106 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1107 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1109 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1112 if (!DECL_ERROR_REPORTED (decl))
1114 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1115 warning (0, " matches this %q+D under ISO standard rules",
1117 warning (0, " matches this %q+D under old rules", decl);
1118 DECL_ERROR_REPORTED (decl) = 1;
1123 /* If we have already complained about this declaration, there's no
1124 need to do it again. */
1125 if (DECL_ERROR_REPORTED (decl))
1128 DECL_ERROR_REPORTED (decl) = 1;
1130 if (TREE_TYPE (decl) == error_mark_node)
1133 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1135 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1137 error (" cannot use obsolete binding at %q+D because "
1138 "it has a destructor", decl);
1139 return error_mark_node;
1143 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1145 pedwarn (" using obsolete binding at %q+D", decl);
1151 /* true means unconditionally make a BLOCK for the next level pushed. */
1153 static bool keep_next_level_flag;
1155 static int binding_depth = 0;
1156 static int is_class_level = 0;
1163 for (i = 0; i < depth * 2; i++)
1167 /* Return a string describing the kind of SCOPE we have. */
1169 cxx_scope_descriptor (cxx_scope *scope)
1171 /* The order of this table must match the "scope_kind"
1173 static const char* scope_kind_names[] = {
1179 "function-parameter-scope",
1182 "template-parameter-scope",
1183 "template-explicit-spec-scope"
1185 const scope_kind kind = scope->explicit_spec_p
1186 ? sk_template_spec : scope->kind;
1188 return scope_kind_names[kind];
1191 /* Output a debugging information about SCOPE when performing
1194 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1196 const char *desc = cxx_scope_descriptor (scope);
1197 if (scope->this_entity)
1198 verbatim ("%s %s(%E) %p %d\n", action, desc,
1199 scope->this_entity, (void *) scope, line);
1201 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1204 /* Return the estimated initial size of the hashtable of a NAMESPACE
1207 static inline size_t
1208 namespace_scope_ht_size (tree ns)
1210 tree name = DECL_NAME (ns);
1212 return name == std_identifier
1213 ? NAMESPACE_STD_HT_SIZE
1214 : (name == global_scope_name
1215 ? GLOBAL_SCOPE_HT_SIZE
1216 : NAMESPACE_ORDINARY_HT_SIZE);
1219 /* A chain of binding_level structures awaiting reuse. */
1221 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1223 /* Insert SCOPE as the innermost binding level. */
1226 push_binding_level (struct cp_binding_level *scope)
1228 /* Add it to the front of currently active scopes stack. */
1229 scope->level_chain = current_binding_level;
1230 current_binding_level = scope;
1231 keep_next_level_flag = false;
1233 if (ENABLE_SCOPE_CHECKING)
1235 scope->binding_depth = binding_depth;
1236 indent (binding_depth);
1237 cxx_scope_debug (scope, input_line, "push");
1243 /* Create a new KIND scope and make it the top of the active scopes stack.
1244 ENTITY is the scope of the associated C++ entity (namespace, class,
1245 function); it is NULL otherwise. */
1248 begin_scope (scope_kind kind, tree entity)
1252 /* Reuse or create a struct for this binding level. */
1253 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1255 scope = free_binding_level;
1256 free_binding_level = scope->level_chain;
1259 scope = GGC_NEW (cxx_scope);
1260 memset (scope, 0, sizeof (cxx_scope));
1262 scope->this_entity = entity;
1263 scope->more_cleanups_ok = true;
1270 case sk_template_spec:
1271 scope->explicit_spec_p = true;
1272 kind = sk_template_parms;
1274 case sk_template_parms:
1280 case sk_function_parms:
1281 scope->keep = keep_next_level_flag;
1285 NAMESPACE_LEVEL (entity) = scope;
1286 scope->static_decls =
1287 VEC_alloc (tree, gc,
1288 DECL_NAME (entity) == std_identifier
1289 || DECL_NAME (entity) == global_scope_name
1294 /* Should not happen. */
1300 push_binding_level (scope);
1305 /* We're about to leave current scope. Pop the top of the stack of
1306 currently active scopes. Return the enclosing scope, now active. */
1311 cxx_scope *scope = current_binding_level;
1313 if (scope->kind == sk_namespace && class_binding_level)
1314 current_binding_level = class_binding_level;
1316 /* We cannot leave a scope, if there are none left. */
1317 if (NAMESPACE_LEVEL (global_namespace))
1318 gcc_assert (!global_scope_p (scope));
1320 if (ENABLE_SCOPE_CHECKING)
1322 indent (--binding_depth);
1323 cxx_scope_debug (scope, input_line, "leave");
1324 if (is_class_level != (scope == class_binding_level))
1326 indent (binding_depth);
1327 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1332 /* Move one nesting level up. */
1333 current_binding_level = scope->level_chain;
1335 /* Namespace-scopes are left most probably temporarily, not
1336 completely; they can be reopen later, e.g. in namespace-extension
1337 or any name binding activity that requires us to resume a
1338 namespace. For classes, we cache some binding levels. For other
1339 scopes, we just make the structure available for reuse. */
1340 if (scope->kind != sk_namespace
1341 && scope->kind != sk_class)
1343 scope->level_chain = free_binding_level;
1344 gcc_assert (!ENABLE_SCOPE_CHECKING
1345 || scope->binding_depth == binding_depth);
1346 free_binding_level = scope;
1349 /* Find the innermost enclosing class scope, and reset
1350 CLASS_BINDING_LEVEL appropriately. */
1351 if (scope->kind == sk_class)
1353 class_binding_level = NULL;
1354 for (scope = current_binding_level; scope; scope = scope->level_chain)
1355 if (scope->kind == sk_class)
1357 class_binding_level = scope;
1362 return current_binding_level;
1366 resume_scope (struct cp_binding_level* b)
1368 /* Resuming binding levels is meant only for namespaces,
1369 and those cannot nest into classes. */
1370 gcc_assert (!class_binding_level);
1371 /* Also, resuming a non-directly nested namespace is a no-no. */
1372 gcc_assert (b->level_chain == current_binding_level);
1373 current_binding_level = b;
1374 if (ENABLE_SCOPE_CHECKING)
1376 b->binding_depth = binding_depth;
1377 indent (binding_depth);
1378 cxx_scope_debug (b, input_line, "resume");
1384 /* Return the innermost binding level that is not for a class scope. */
1387 innermost_nonclass_level (void)
1391 b = current_binding_level;
1392 while (b->kind == sk_class)
1398 /* We're defining an object of type TYPE. If it needs a cleanup, but
1399 we're not allowed to add any more objects with cleanups to the current
1400 scope, create a new binding level. */
1403 maybe_push_cleanup_level (tree type)
1405 if (type != error_mark_node
1406 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1407 && current_binding_level->more_cleanups_ok == 0)
1409 begin_scope (sk_cleanup, NULL);
1410 current_binding_level->statement_list = push_stmt_list ();
1414 /* Nonzero if we are currently in the global binding level. */
1417 global_bindings_p (void)
1419 return global_scope_p (current_binding_level);
1422 /* True if we are currently in a toplevel binding level. This
1423 means either the global binding level or a namespace in a toplevel
1424 binding level. Since there are no non-toplevel namespace levels,
1425 this really means any namespace or template parameter level. We
1426 also include a class whose context is toplevel. */
1429 toplevel_bindings_p (void)
1431 struct cp_binding_level *b = innermost_nonclass_level ();
1433 return b->kind == sk_namespace || b->kind == sk_template_parms;
1436 /* True if this is a namespace scope, or if we are defining a class
1437 which is itself at namespace scope, or whose enclosing class is
1438 such a class, etc. */
1441 namespace_bindings_p (void)
1443 struct cp_binding_level *b = innermost_nonclass_level ();
1445 return b->kind == sk_namespace;
1448 /* True if the current level needs to have a BLOCK made. */
1453 return (current_binding_level->blocks != NULL_TREE
1454 || current_binding_level->keep
1455 || current_binding_level->kind == sk_cleanup
1456 || current_binding_level->names != NULL_TREE);
1459 /* Returns the kind of the innermost scope. */
1462 innermost_scope_kind (void)
1464 return current_binding_level->kind;
1467 /* Returns true if this scope was created to store template parameters. */
1470 template_parm_scope_p (void)
1472 return innermost_scope_kind () == sk_template_parms;
1475 /* If KEEP is true, make a BLOCK node for the next binding level,
1476 unconditionally. Otherwise, use the normal logic to decide whether
1477 or not to create a BLOCK. */
1480 keep_next_level (bool keep)
1482 keep_next_level_flag = keep;
1485 /* Return the list of declarations of the current level.
1486 Note that this list is in reverse order unless/until
1487 you nreverse it; and when you do nreverse it, you must
1488 store the result back using `storedecls' or you will lose. */
1493 return current_binding_level->names;
1496 /* For debugging. */
1497 static int no_print_functions = 0;
1498 static int no_print_builtins = 0;
1501 print_binding_level (struct cp_binding_level* lvl)
1505 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1506 if (lvl->more_cleanups_ok)
1507 fprintf (stderr, " more-cleanups-ok");
1508 if (lvl->have_cleanups)
1509 fprintf (stderr, " have-cleanups");
1510 fprintf (stderr, "\n");
1513 fprintf (stderr, " names:\t");
1514 /* We can probably fit 3 names to a line? */
1515 for (t = lvl->names; t; t = TREE_CHAIN (t))
1517 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1519 if (no_print_builtins
1520 && (TREE_CODE (t) == TYPE_DECL)
1521 && DECL_IS_BUILTIN (t))
1524 /* Function decls tend to have longer names. */
1525 if (TREE_CODE (t) == FUNCTION_DECL)
1532 fprintf (stderr, "\n\t");
1535 print_node_brief (stderr, "", t, 0);
1536 if (t == error_mark_node)
1540 fprintf (stderr, "\n");
1542 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1545 cp_class_binding *b;
1546 fprintf (stderr, " class-shadowed:");
1548 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1550 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1551 fprintf (stderr, "\n");
1553 if (lvl->type_shadowed)
1555 fprintf (stderr, " type-shadowed:");
1556 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1558 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1560 fprintf (stderr, "\n");
1565 print_other_binding_stack (struct cp_binding_level *stack)
1567 struct cp_binding_level *level;
1568 for (level = stack; !global_scope_p (level); level = level->level_chain)
1570 fprintf (stderr, "binding level %p\n", (void *) level);
1571 print_binding_level (level);
1576 print_binding_stack (void)
1578 struct cp_binding_level *b;
1579 fprintf (stderr, "current_binding_level=%p\n"
1580 "class_binding_level=%p\n"
1581 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1582 (void *) current_binding_level, (void *) class_binding_level,
1583 (void *) NAMESPACE_LEVEL (global_namespace));
1584 if (class_binding_level)
1586 for (b = class_binding_level; b; b = b->level_chain)
1587 if (b == current_binding_level)
1590 b = class_binding_level;
1592 b = current_binding_level;
1595 b = current_binding_level;
1596 print_other_binding_stack (b);
1597 fprintf (stderr, "global:\n");
1598 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1601 /* Return the type associated with id. */
1604 identifier_type_value (tree id)
1606 timevar_push (TV_NAME_LOOKUP);
1607 /* There is no type with that name, anywhere. */
1608 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1609 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1610 /* This is not the type marker, but the real thing. */
1611 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1612 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1613 /* Have to search for it. It must be on the global level, now.
1614 Ask lookup_name not to return non-types. */
1615 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1617 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1618 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1621 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1622 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1625 identifier_global_value (tree t)
1627 return IDENTIFIER_GLOBAL_VALUE (t);
1630 /* Push a definition of struct, union or enum tag named ID. into
1631 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1632 the tag ID is not already defined. */
1635 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1639 if (b->kind != sk_namespace)
1641 /* Shadow the marker, not the real thing, so that the marker
1642 gets restored later. */
1643 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1645 = tree_cons (id, old_type_value, b->type_shadowed);
1646 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1647 TREE_TYPE (b->type_shadowed) = type;
1651 cxx_binding *binding =
1652 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1655 supplement_binding (binding, decl);
1657 binding->value = decl;
1659 /* Store marker instead of real type. */
1660 type = global_type_node;
1662 SET_IDENTIFIER_TYPE_VALUE (id, type);
1665 /* As set_identifier_type_value_with_scope, but using
1666 current_binding_level. */
1669 set_identifier_type_value (tree id, tree decl)
1671 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1674 /* Return the name for the constructor (or destructor) for the
1675 specified class TYPE. When given a template, this routine doesn't
1676 lose the specialization. */
1679 constructor_name_full (tree type)
1681 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1684 /* Return the name for the constructor (or destructor) for the
1685 specified class. When given a template, return the plain
1686 unspecialized name. */
1689 constructor_name (tree type)
1692 name = constructor_name_full (type);
1693 if (IDENTIFIER_TEMPLATE (name))
1694 name = IDENTIFIER_TEMPLATE (name);
1698 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1701 constructor_name_p (tree name, tree type)
1708 if (TREE_CODE (name) != IDENTIFIER_NODE)
1711 ctor_name = constructor_name_full (type);
1712 if (name == ctor_name)
1714 if (IDENTIFIER_TEMPLATE (ctor_name)
1715 && name == IDENTIFIER_TEMPLATE (ctor_name))
1720 /* Counter used to create anonymous type names. */
1722 static GTY(()) int anon_cnt;
1724 /* Return an IDENTIFIER which can be used as a name for
1725 anonymous structs and unions. */
1728 make_anon_name (void)
1732 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1733 return get_identifier (buf);
1736 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1738 static inline cxx_binding *
1739 find_binding (cxx_scope *scope, cxx_binding *binding)
1741 timevar_push (TV_NAME_LOOKUP);
1743 for (; binding != NULL; binding = binding->previous)
1744 if (binding->scope == scope)
1745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1750 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1752 static inline cxx_binding *
1753 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1755 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1758 /* Fold-in case where NAME is used only once. */
1759 if (scope == b->scope && b->previous == NULL)
1761 return find_binding (scope, b);
1766 /* Always returns a binding for name in scope. If no binding is
1767 found, make a new one. */
1769 static cxx_binding *
1770 binding_for_name (cxx_scope *scope, tree name)
1772 cxx_binding *result;
1774 result = cxx_scope_find_binding_for_name (scope, name);
1777 /* Not found, make a new one. */
1778 result = cxx_binding_make (NULL, NULL);
1779 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1780 result->scope = scope;
1781 result->is_local = false;
1782 result->value_is_inherited = false;
1783 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1787 /* Insert another USING_DECL into the current binding level, returning
1788 this declaration. If this is a redeclaration, do nothing, and
1789 return NULL_TREE if this not in namespace scope (in namespace
1790 scope, a using decl might extend any previous bindings). */
1793 push_using_decl (tree scope, tree name)
1797 timevar_push (TV_NAME_LOOKUP);
1798 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1799 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1800 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1801 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1804 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1805 namespace_bindings_p () ? decl : NULL_TREE);
1806 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1807 USING_DECL_SCOPE (decl) = scope;
1808 TREE_CHAIN (decl) = current_binding_level->usings;
1809 current_binding_level->usings = decl;
1810 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1813 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1814 caller to set DECL_CONTEXT properly. */
1817 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1819 struct cp_binding_level *b;
1820 tree function_decl = current_function_decl;
1822 timevar_push (TV_NAME_LOOKUP);
1823 current_function_decl = NULL_TREE;
1824 if (level->kind == sk_class)
1826 b = class_binding_level;
1827 class_binding_level = level;
1828 pushdecl_class_level (x);
1829 class_binding_level = b;
1833 b = current_binding_level;
1834 current_binding_level = level;
1835 x = pushdecl_maybe_friend (x, is_friend);
1836 current_binding_level = b;
1838 current_function_decl = function_decl;
1839 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1842 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1843 other definitions already in place. We get around this by making
1844 the value of the identifier point to a list of all the things that
1845 want to be referenced by that name. It is then up to the users of
1846 that name to decide what to do with that list.
1848 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1849 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1851 FLAGS is a bitwise-or of the following values:
1852 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1854 PUSH_USING: DECL is being pushed as the result of a using
1857 IS_FRIEND is true if this is a friend declaration.
1859 The value returned may be a previous declaration if we guessed wrong
1860 about what language DECL should belong to (C or C++). Otherwise,
1861 it's always DECL (and never something that's not a _DECL). */
1864 push_overloaded_decl (tree decl, int flags, bool is_friend)
1866 tree name = DECL_NAME (decl);
1869 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1871 timevar_push (TV_NAME_LOOKUP);
1873 old = namespace_binding (name, DECL_CONTEXT (decl));
1875 old = lookup_name_innermost_nonclass_level (name);
1879 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1881 tree t = TREE_TYPE (old);
1882 if (IS_AGGR_TYPE (t) && warn_shadow
1883 && (! DECL_IN_SYSTEM_HEADER (decl)
1884 || ! DECL_IN_SYSTEM_HEADER (old)))
1885 warning (0, "%q#D hides constructor for %q#T", decl, t);
1888 else if (is_overloaded_fn (old))
1892 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1894 tree fn = OVL_CURRENT (tmp);
1896 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1897 && !(flags & PUSH_USING)
1898 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1899 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1900 && ! decls_match (fn, decl))
1901 error ("%q#D conflicts with previous using declaration %q#D",
1904 if (duplicate_decls (decl, fn, is_friend) == fn)
1905 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
1908 /* We don't overload implicit built-ins. duplicate_decls()
1909 may fail to merge the decls if the new decl is e.g. a
1910 template function. */
1911 if (TREE_CODE (old) == FUNCTION_DECL
1912 && DECL_ANTICIPATED (old)
1913 && !DECL_HIDDEN_FRIEND_P (old))
1916 else if (old == error_mark_node)
1917 /* Ignore the undefined symbol marker. */
1921 error ("previous non-function declaration %q+#D", old);
1922 error ("conflicts with function declaration %q#D", decl);
1923 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1927 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1928 /* If it's a using declaration, we always need to build an OVERLOAD,
1929 because it's the only way to remember that the declaration comes
1930 from 'using', and have the lookup behave correctly. */
1931 || (flags & PUSH_USING))
1933 if (old && TREE_CODE (old) != OVERLOAD)
1934 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1936 new_binding = ovl_cons (decl, old);
1937 if (flags & PUSH_USING)
1938 OVL_USED (new_binding) = 1;
1941 /* NAME is not ambiguous. */
1945 set_namespace_binding (name, current_namespace, new_binding);
1948 /* We only create an OVERLOAD if there was a previous binding at
1949 this level, or if decl is a template. In the former case, we
1950 need to remove the old binding and replace it with the new
1951 binding. We must also run through the NAMES on the binding
1952 level where the name was bound to update the chain. */
1954 if (TREE_CODE (new_binding) == OVERLOAD && old)
1958 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1960 d = &TREE_CHAIN (*d))
1962 || (TREE_CODE (*d) == TREE_LIST
1963 && TREE_VALUE (*d) == old))
1965 if (TREE_CODE (*d) == TREE_LIST)
1966 /* Just replace the old binding with the new. */
1967 TREE_VALUE (*d) = new_binding;
1969 /* Build a TREE_LIST to wrap the OVERLOAD. */
1970 *d = tree_cons (NULL_TREE, new_binding,
1973 /* And update the cxx_binding node. */
1974 IDENTIFIER_BINDING (name)->value = new_binding;
1975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1978 /* We should always find a previous binding in this case. */
1982 /* Install the new binding. */
1983 push_local_binding (name, new_binding, flags);
1986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1989 /* Check a non-member using-declaration. Return the name and scope
1990 being used, and the USING_DECL, or NULL_TREE on failure. */
1993 validate_nonmember_using_decl (tree decl, tree scope, tree name)
1995 /* [namespace.udecl]
1996 A using-declaration for a class member shall be a
1997 member-declaration. */
2000 error ("%qT is not a namespace", scope);
2003 else if (scope == error_mark_node)
2006 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2009 A using-declaration shall not name a template-id. */
2010 error ("a using-declaration cannot specify a template-id. "
2011 "Try %<using %D%>", name);
2015 if (TREE_CODE (decl) == NAMESPACE_DECL)
2017 error ("namespace %qD not allowed in using-declaration", decl);
2021 if (TREE_CODE (decl) == SCOPE_REF)
2023 /* It's a nested name with template parameter dependent scope.
2024 This can only be using-declaration for class member. */
2025 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2029 if (is_overloaded_fn (decl))
2030 decl = get_first_fn (decl);
2032 gcc_assert (DECL_P (decl));
2034 /* Make a USING_DECL. */
2035 return push_using_decl (scope, name);
2038 /* Process local and global using-declarations. */
2041 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2042 tree *newval, tree *newtype)
2044 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2046 *newval = *newtype = NULL_TREE;
2047 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2051 if (!decls.value && !decls.type)
2053 error ("%qD not declared", name);
2057 /* It is impossible to overload a built-in function; any explicit
2058 declaration eliminates the built-in declaration. So, if OLDVAL
2059 is a built-in, then we can just pretend it isn't there. */
2061 && TREE_CODE (oldval) == FUNCTION_DECL
2062 && DECL_ANTICIPATED (oldval)
2063 && !DECL_HIDDEN_FRIEND_P (oldval))
2066 /* Check for using functions. */
2067 if (decls.value && is_overloaded_fn (decls.value))
2071 if (oldval && !is_overloaded_fn (oldval))
2073 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2074 error ("%qD is already declared in this scope", name);
2079 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2081 tree new_fn = OVL_CURRENT (tmp);
2083 /* [namespace.udecl]
2085 If a function declaration in namespace scope or block
2086 scope has the same name and the same parameter types as a
2087 function introduced by a using declaration the program is
2089 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2091 tree old_fn = OVL_CURRENT (tmp1);
2093 if (new_fn == old_fn)
2094 /* The function already exists in the current namespace. */
2096 else if (OVL_USED (tmp1))
2097 continue; /* this is a using decl */
2098 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2099 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2101 gcc_assert (!DECL_ANTICIPATED (old_fn)
2102 || DECL_HIDDEN_FRIEND_P (old_fn));
2104 /* There was already a non-using declaration in
2105 this scope with the same parameter types. If both
2106 are the same extern "C" functions, that's ok. */
2107 if (decls_match (new_fn, old_fn))
2111 error ("%qD is already declared in this scope", name);
2117 /* If we broke out of the loop, there's no reason to add
2118 this function to the using declarations for this
2123 /* If we are adding to an existing OVERLOAD, then we no
2124 longer know the type of the set of functions. */
2125 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2126 TREE_TYPE (*newval) = unknown_type_node;
2127 /* Add this new function to the set. */
2128 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2129 /* If there is only one function, then we use its type. (A
2130 using-declaration naming a single function can be used in
2131 contexts where overload resolution cannot be
2133 if (TREE_CODE (*newval) != OVERLOAD)
2135 *newval = ovl_cons (*newval, NULL_TREE);
2136 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2138 OVL_USED (*newval) = 1;
2143 *newval = decls.value;
2144 if (oldval && !decls_match (*newval, oldval))
2145 error ("%qD is already declared in this scope", name);
2148 *newtype = decls.type;
2149 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2151 error ("using declaration %qD introduced ambiguous type %qT",
2157 /* Process a using-declaration at function scope. */
2160 do_local_using_decl (tree decl, tree scope, tree name)
2162 tree oldval, oldtype, newval, newtype;
2163 tree orig_decl = decl;
2165 decl = validate_nonmember_using_decl (decl, scope, name);
2166 if (decl == NULL_TREE)
2169 if (building_stmt_tree ()
2170 && at_function_scope_p ())
2171 add_decl_expr (decl);
2173 oldval = lookup_name_innermost_nonclass_level (name);
2174 oldtype = lookup_type_current_level (name);
2176 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2180 if (is_overloaded_fn (newval))
2184 /* We only need to push declarations for those functions
2185 that were not already bound in the current level.
2186 The old value might be NULL_TREE, it might be a single
2187 function, or an OVERLOAD. */
2188 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2189 term = OVL_FUNCTION (oldval);
2192 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2194 push_overloaded_decl (OVL_CURRENT (fn),
2195 PUSH_LOCAL | PUSH_USING,
2199 push_local_binding (name, newval, PUSH_USING);
2203 push_local_binding (name, newtype, PUSH_USING);
2204 set_identifier_type_value (name, newtype);
2207 /* Emit debug info. */
2208 if (!processing_template_decl)
2209 cp_emit_debug_info_for_using (orig_decl, current_scope());
2212 /* Returns true if ROOT (a namespace, class, or function) encloses
2213 CHILD. CHILD may be either a class type or a namespace. */
2216 is_ancestor (tree root, tree child)
2218 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2219 || TREE_CODE (root) == FUNCTION_DECL
2220 || CLASS_TYPE_P (root)));
2221 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2222 || CLASS_TYPE_P (child)));
2224 /* The global namespace encloses everything. */
2225 if (root == global_namespace)
2230 /* If we've run out of scopes, stop. */
2233 /* If we've reached the ROOT, it encloses CHILD. */
2236 /* Go out one level. */
2238 child = TYPE_NAME (child);
2239 child = DECL_CONTEXT (child);
2243 /* Enter the class or namespace scope indicated by T suitable for name
2244 lookup. T can be arbitrary scope, not necessary nested inside the
2245 current scope. Returns a non-null scope to pop iff pop_scope
2246 should be called later to exit this scope. */
2251 if (TREE_CODE (t) == NAMESPACE_DECL)
2252 push_decl_namespace (t);
2253 else if (CLASS_TYPE_P (t))
2255 if (!at_class_scope_p ()
2256 || !same_type_p (current_class_type, t))
2257 push_nested_class (t);
2259 /* T is the same as the current scope. There is therefore no
2260 need to re-enter the scope. Since we are not actually
2261 pushing a new scope, our caller should not call
2269 /* Leave scope pushed by push_scope. */
2274 if (TREE_CODE (t) == NAMESPACE_DECL)
2275 pop_decl_namespace ();
2276 else if CLASS_TYPE_P (t)
2277 pop_nested_class ();
2280 /* Subroutine of push_inner_scope. */
2283 push_inner_scope_r (tree outer, tree inner)
2288 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2291 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2293 push_inner_scope_r (outer, prev);
2294 if (TREE_CODE (inner) == NAMESPACE_DECL)
2296 struct cp_binding_level *save_template_parm = 0;
2297 /* Temporary take out template parameter scopes. They are saved
2298 in reversed order in save_template_parm. */
2299 while (current_binding_level->kind == sk_template_parms)
2301 struct cp_binding_level *b = current_binding_level;
2302 current_binding_level = b->level_chain;
2303 b->level_chain = save_template_parm;
2304 save_template_parm = b;
2307 resume_scope (NAMESPACE_LEVEL (inner));
2308 current_namespace = inner;
2310 /* Restore template parameter scopes. */
2311 while (save_template_parm)
2313 struct cp_binding_level *b = save_template_parm;
2314 save_template_parm = b->level_chain;
2315 b->level_chain = current_binding_level;
2316 current_binding_level = b;
2323 /* Enter the scope INNER from current scope. INNER must be a scope
2324 nested inside current scope. This works with both name lookup and
2325 pushing name into scope. In case a template parameter scope is present,
2326 namespace is pushed under the template parameter scope according to
2327 name lookup rule in 14.6.1/6.
2329 Return the former current scope suitable for pop_inner_scope. */
2332 push_inner_scope (tree inner)
2334 tree outer = current_scope ();
2336 outer = current_namespace;
2338 push_inner_scope_r (outer, inner);
2342 /* Exit the current scope INNER back to scope OUTER. */
2345 pop_inner_scope (tree outer, tree inner)
2348 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2351 while (outer != inner)
2353 if (TREE_CODE (inner) == NAMESPACE_DECL)
2355 struct cp_binding_level *save_template_parm = 0;
2356 /* Temporary take out template parameter scopes. They are saved
2357 in reversed order in save_template_parm. */
2358 while (current_binding_level->kind == sk_template_parms)
2360 struct cp_binding_level *b = current_binding_level;
2361 current_binding_level = b->level_chain;
2362 b->level_chain = save_template_parm;
2363 save_template_parm = b;
2368 /* Restore template parameter scopes. */
2369 while (save_template_parm)
2371 struct cp_binding_level *b = save_template_parm;
2372 save_template_parm = b->level_chain;
2373 b->level_chain = current_binding_level;
2374 current_binding_level = b;
2380 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2384 /* Do a pushlevel for class declarations. */
2387 pushlevel_class (void)
2389 if (ENABLE_SCOPE_CHECKING)
2392 class_binding_level = begin_scope (sk_class, current_class_type);
2395 /* ...and a poplevel for class declarations. */
2398 poplevel_class (void)
2400 struct cp_binding_level *level = class_binding_level;
2401 cp_class_binding *cb;
2405 timevar_push (TV_NAME_LOOKUP);
2406 gcc_assert (level != 0);
2408 /* If we're leaving a toplevel class, cache its binding level. */
2409 if (current_class_depth == 1)
2410 previous_class_level = level;
2411 for (shadowed = level->type_shadowed;
2413 shadowed = TREE_CHAIN (shadowed))
2414 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2416 /* Remove the bindings for all of the class-level declarations. */
2417 if (level->class_shadowed)
2420 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2422 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2423 ggc_free (level->class_shadowed);
2424 level->class_shadowed = NULL;
2427 /* Now, pop out of the binding level which we created up in the
2428 `pushlevel_class' routine. */
2429 if (ENABLE_SCOPE_CHECKING)
2433 timevar_pop (TV_NAME_LOOKUP);
2436 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2437 appropriate. DECL is the value to which a name has just been
2438 bound. CLASS_TYPE is the class in which the lookup occurred. */
2441 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2444 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2448 if (TREE_CODE (decl) == OVERLOAD)
2449 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2452 gcc_assert (DECL_P (decl));
2453 context = context_for_name_lookup (decl);
2456 if (is_properly_derived_from (class_type, context))
2457 INHERITED_VALUE_BINDING_P (binding) = 1;
2459 INHERITED_VALUE_BINDING_P (binding) = 0;
2461 else if (binding->value == decl)
2462 /* We only encounter a TREE_LIST when there is an ambiguity in the
2463 base classes. Such an ambiguity can be overridden by a
2464 definition in this class. */
2465 INHERITED_VALUE_BINDING_P (binding) = 1;
2467 INHERITED_VALUE_BINDING_P (binding) = 0;
2470 /* Make the declaration of X appear in CLASS scope. */
2473 pushdecl_class_level (tree x)
2476 bool is_valid = true;
2478 timevar_push (TV_NAME_LOOKUP);
2479 /* Get the name of X. */
2480 if (TREE_CODE (x) == OVERLOAD)
2481 name = DECL_NAME (get_first_fn (x));
2483 name = DECL_NAME (x);
2487 is_valid = push_class_level_binding (name, x);
2488 if (TREE_CODE (x) == TYPE_DECL)
2489 set_identifier_type_value (name, x);
2491 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2493 /* If X is an anonymous aggregate, all of its members are
2494 treated as if they were members of the class containing the
2495 aggregate, for naming purposes. */
2498 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2500 location_t save_location = input_location;
2501 input_location = DECL_SOURCE_LOCATION (f);
2502 if (!pushdecl_class_level (f))
2504 input_location = save_location;
2507 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2510 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2511 scope. If the value returned is non-NULL, and the PREVIOUS field
2512 is not set, callers must set the PREVIOUS field explicitly. */
2514 static cxx_binding *
2515 get_class_binding (tree name, cxx_scope *scope)
2520 cxx_binding *binding;
2522 class_type = scope->this_entity;
2524 /* Get the type binding. */
2525 type_binding = lookup_member (class_type, name,
2526 /*protect=*/2, /*want_type=*/true);
2527 /* Get the value binding. */
2528 value_binding = lookup_member (class_type, name,
2529 /*protect=*/2, /*want_type=*/false);
2532 && (TREE_CODE (value_binding) == TYPE_DECL
2533 || DECL_CLASS_TEMPLATE_P (value_binding)
2534 || (TREE_CODE (value_binding) == TREE_LIST
2535 && TREE_TYPE (value_binding) == error_mark_node
2536 && (TREE_CODE (TREE_VALUE (value_binding))
2538 /* We found a type binding, even when looking for a non-type
2539 binding. This means that we already processed this binding
2542 else if (value_binding)
2544 if (TREE_CODE (value_binding) == TREE_LIST
2545 && TREE_TYPE (value_binding) == error_mark_node)
2546 /* NAME is ambiguous. */
2548 else if (BASELINK_P (value_binding))
2549 /* NAME is some overloaded functions. */
2550 value_binding = BASELINK_FUNCTIONS (value_binding);
2553 /* If we found either a type binding or a value binding, create a
2554 new binding object. */
2555 if (type_binding || value_binding)
2557 binding = new_class_binding (name,
2561 /* This is a class-scope binding, not a block-scope binding. */
2562 LOCAL_BINDING_P (binding) = 0;
2563 set_inherited_value_binding_p (binding, value_binding, class_type);
2571 /* Make the declaration(s) of X appear in CLASS scope under the name
2572 NAME. Returns true if the binding is valid. */
2575 push_class_level_binding (tree name, tree x)
2577 cxx_binding *binding;
2581 timevar_push (TV_NAME_LOOKUP);
2582 /* The class_binding_level will be NULL if x is a template
2583 parameter name in a member template. */
2584 if (!class_binding_level)
2585 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2587 /* Check for invalid member names. */
2588 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2589 /* We could have been passed a tree list if this is an ambiguous
2590 declaration. If so, pull the declaration out because
2591 check_template_shadow will not handle a TREE_LIST. */
2592 if (TREE_CODE (decl) == TREE_LIST
2593 && TREE_TYPE (decl) == error_mark_node)
2594 decl = TREE_VALUE (decl);
2596 check_template_shadow (decl);
2600 If T is the name of a class, then each of the following shall
2601 have a name different from T:
2603 -- every static data member of class T;
2605 -- every member of class T that is itself a type;
2607 -- every enumerator of every member of class T that is an
2610 -- every member of every anonymous union that is a member of
2613 (Non-static data members were also forbidden to have the same
2614 name as T until TC1.) */
2615 if ((TREE_CODE (x) == VAR_DECL
2616 || TREE_CODE (x) == CONST_DECL
2617 || (TREE_CODE (x) == TYPE_DECL
2618 && !DECL_SELF_REFERENCE_P (x))
2619 /* A data member of an anonymous union. */
2620 || (TREE_CODE (x) == FIELD_DECL
2621 && DECL_CONTEXT (x) != current_class_type))
2622 && DECL_NAME (x) == constructor_name (current_class_type))
2624 tree scope = context_for_name_lookup (x);
2625 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2627 error ("%qD has the same name as the class in which it is "
2630 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2634 /* Get the current binding for NAME in this class, if any. */
2635 binding = IDENTIFIER_BINDING (name);
2636 if (!binding || binding->scope != class_binding_level)
2638 binding = get_class_binding (name, class_binding_level);
2639 /* If a new binding was created, put it at the front of the
2640 IDENTIFIER_BINDING list. */
2643 binding->previous = IDENTIFIER_BINDING (name);
2644 IDENTIFIER_BINDING (name) = binding;
2648 /* If there is already a binding, then we may need to update the
2650 if (binding && binding->value)
2652 tree bval = binding->value;
2653 tree old_decl = NULL_TREE;
2655 if (INHERITED_VALUE_BINDING_P (binding))
2657 /* If the old binding was from a base class, and was for a
2658 tag name, slide it over to make room for the new binding.
2659 The old binding is still visible if explicitly qualified
2660 with a class-key. */
2661 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2662 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2664 old_decl = binding->type;
2665 binding->type = bval;
2666 binding->value = NULL_TREE;
2667 INHERITED_VALUE_BINDING_P (binding) = 0;
2672 /* Any inherited type declaration is hidden by the type
2673 declaration in the derived class. */
2674 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2675 binding->type = NULL_TREE;
2678 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2680 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2682 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2684 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2687 if (old_decl && binding->scope == class_binding_level)
2690 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2691 here. This function is only used to register bindings
2692 from with the class definition itself. */
2693 INHERITED_VALUE_BINDING_P (binding) = 0;
2694 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2698 /* Note that we declared this value so that we can issue an error if
2699 this is an invalid redeclaration of a name already used for some
2701 note_name_declared_in_class (name, decl);
2703 /* If we didn't replace an existing binding, put the binding on the
2704 stack of bindings for the identifier, and update the shadowed
2706 if (binding && binding->scope == class_binding_level)
2707 /* Supplement the existing binding. */
2708 ok = supplement_binding (binding, decl);
2711 /* Create a new binding. */
2712 push_binding (name, decl, class_binding_level);
2716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2719 /* Process "using SCOPE::NAME" in a class scope. Return the
2720 USING_DECL created. */
2723 do_class_using_decl (tree scope, tree name)
2725 /* The USING_DECL returned by this function. */
2727 /* The declaration (or declarations) name by this using
2728 declaration. NULL if we are in a template and cannot figure out
2729 what has been named. */
2731 /* True if SCOPE is a dependent type. */
2732 bool scope_dependent_p;
2733 /* True if SCOPE::NAME is dependent. */
2734 bool name_dependent_p;
2735 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2736 bool bases_dependent_p;
2741 if (!scope || !TYPE_P (scope))
2743 error ("using-declaration for non-member at class scope");
2747 /* Make sure the name is not invalid */
2748 if (TREE_CODE (name) == BIT_NOT_EXPR)
2750 error ("%<%T::%D%> names destructor", scope, name);
2753 if (constructor_name_p (name, scope))
2755 error ("%<%T::%D%> names constructor", scope, name);
2758 if (constructor_name_p (name, current_class_type))
2760 error ("%<%T::%D%> names constructor in %qT",
2761 scope, name, current_class_type);
2765 scope_dependent_p = dependent_type_p (scope);
2766 name_dependent_p = (scope_dependent_p
2767 || (IDENTIFIER_OPNAME_P (name)
2768 && dependent_type_p (TREE_TYPE (name))));
2770 bases_dependent_p = false;
2771 if (processing_template_decl)
2772 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2773 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2775 if (dependent_type_p (TREE_TYPE (base_binfo)))
2777 bases_dependent_p = true;
2783 /* From [namespace.udecl]:
2785 A using-declaration used as a member-declaration shall refer to a
2786 member of a base class of the class being defined.
2788 In general, we cannot check this constraint in a template because
2789 we do not know the entire set of base classes of the current
2790 class type. However, if all of the base classes are
2791 non-dependent, then we can avoid delaying the check until
2793 if (!scope_dependent_p && !bases_dependent_p)
2797 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2798 if (b_kind < bk_proper_base)
2800 error_not_base_type (scope, current_class_type);
2804 if (!name_dependent_p)
2806 decl = lookup_member (binfo, name, 0, false);
2809 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2813 /* The binfo from which the functions came does not matter. */
2814 if (BASELINK_P (decl))
2815 decl = BASELINK_FUNCTIONS (decl);
2819 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2820 USING_DECL_DECLS (value) = decl;
2821 USING_DECL_SCOPE (value) = scope;
2822 DECL_DEPENDENT_P (value) = !decl;
2828 /* Return the binding value for name in scope. */
2831 namespace_binding (tree name, tree scope)
2833 cxx_binding *binding;
2836 scope = global_namespace;
2838 /* Unnecessary for the global namespace because it can't be an alias. */
2839 scope = ORIGINAL_NAMESPACE (scope);
2841 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2843 return binding ? binding->value : NULL_TREE;
2846 /* Set the binding value for name in scope. */
2849 set_namespace_binding (tree name, tree scope, tree val)
2853 timevar_push (TV_NAME_LOOKUP);
2854 if (scope == NULL_TREE)
2855 scope = global_namespace;
2856 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2857 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2860 supplement_binding (b, val);
2861 timevar_pop (TV_NAME_LOOKUP);
2864 /* Set the context of a declaration to scope. Complain if we are not
2868 set_decl_namespace (tree decl, tree scope, bool friendp)
2872 /* Get rid of namespace aliases. */
2873 scope = ORIGINAL_NAMESPACE (scope);
2875 /* It is ok for friends to be qualified in parallel space. */
2876 if (!friendp && !is_ancestor (current_namespace, scope))
2877 error ("declaration of %qD not in a namespace surrounding %qD",
2879 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2881 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2882 if (scope == current_namespace)
2884 if (at_namespace_scope_p ())
2885 error ("explicit qualification in declaration of %qD",
2890 /* See whether this has been declared in the namespace. */
2891 old = namespace_binding (DECL_NAME (decl), scope);
2893 /* No old declaration at all. */
2895 /* A template can be explicitly specialized in any namespace. */
2896 if (processing_explicit_instantiation)
2898 if (!is_overloaded_fn (decl))
2899 /* Don't compare non-function decls with decls_match here, since
2900 it can't check for the correct constness at this
2901 point. pushdecl will find those errors later. */
2903 /* Since decl is a function, old should contain a function decl. */
2904 if (!is_overloaded_fn (old))
2906 if (processing_template_decl || processing_specialization)
2907 /* We have not yet called push_template_decl to turn a
2908 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2909 match. But, we'll check later, when we construct the
2912 /* Instantiations or specializations of templates may be declared as
2913 friends in any namespace. */
2914 if (friendp && DECL_USE_TEMPLATE (decl))
2916 if (is_overloaded_fn (old))
2918 for (; old; old = OVL_NEXT (old))
2919 if (decls_match (decl, OVL_CURRENT (old)))
2922 else if (decls_match (decl, old))
2925 error ("%qD should have been declared inside %qD", decl, scope);
2928 /* Return the namespace where the current declaration is declared. */
2931 current_decl_namespace (void)
2934 /* If we have been pushed into a different namespace, use it. */
2935 if (decl_namespace_list)
2936 return TREE_PURPOSE (decl_namespace_list);
2938 if (current_class_type)
2939 result = decl_namespace_context (current_class_type);
2940 else if (current_function_decl)
2941 result = decl_namespace_context (current_function_decl);
2943 result = current_namespace;
2947 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2948 select a name that is unique to this compilation unit. */
2951 push_namespace (tree name)
2955 int implicit_use = 0;
2958 timevar_push (TV_NAME_LOOKUP);
2960 /* We should not get here if the global_namespace is not yet constructed
2961 nor if NAME designates the global namespace: The global scope is
2962 constructed elsewhere. */
2963 gcc_assert (global_namespace != NULL && name != global_scope_name);
2967 /* The name of anonymous namespace is unique for the translation
2969 if (!anonymous_namespace_name)
2970 anonymous_namespace_name = get_file_function_name ('N');
2971 name = anonymous_namespace_name;
2972 d = IDENTIFIER_NAMESPACE_VALUE (name);
2974 /* Reopening anonymous namespace. */
2980 /* Check whether this is an extended namespace definition. */
2981 d = IDENTIFIER_NAMESPACE_VALUE (name);
2982 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2985 if (DECL_NAMESPACE_ALIAS (d))
2987 error ("namespace alias %qD not allowed here, assuming %qD",
2988 d, DECL_NAMESPACE_ALIAS (d));
2989 d = DECL_NAMESPACE_ALIAS (d);
2996 /* Make a new namespace, binding the name to it. */
2997 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2998 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3002 /* Clear DECL_NAME for the benefit of debugging back ends. */
3003 SET_DECL_ASSEMBLER_NAME (d, name);
3004 DECL_NAME (d) = NULL_TREE;
3006 begin_scope (sk_namespace, d);
3009 resume_scope (NAMESPACE_LEVEL (d));
3012 do_using_directive (d);
3013 /* Enter the name space. */
3014 current_namespace = d;
3016 timevar_pop (TV_NAME_LOOKUP);
3019 /* Pop from the scope of the current namespace. */
3022 pop_namespace (void)
3024 gcc_assert (current_namespace != global_namespace);
3025 current_namespace = CP_DECL_CONTEXT (current_namespace);
3026 /* The binding level is not popped, as it might be re-opened later. */
3030 /* Push into the scope of the namespace NS, even if it is deeply
3031 nested within another namespace. */
3034 push_nested_namespace (tree ns)
3036 if (ns == global_namespace)
3037 push_to_top_level ();
3040 push_nested_namespace (CP_DECL_CONTEXT (ns));
3041 push_namespace (DECL_NAME (ns));
3045 /* Pop back from the scope of the namespace NS, which was previously
3046 entered with push_nested_namespace. */
3049 pop_nested_namespace (tree ns)
3051 timevar_push (TV_NAME_LOOKUP);
3052 while (ns != global_namespace)
3055 ns = CP_DECL_CONTEXT (ns);
3058 pop_from_top_level ();
3059 timevar_pop (TV_NAME_LOOKUP);
3062 /* Temporarily set the namespace for the current declaration. */
3065 push_decl_namespace (tree decl)
3067 if (TREE_CODE (decl) != NAMESPACE_DECL)
3068 decl = decl_namespace_context (decl);
3069 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3070 NULL_TREE, decl_namespace_list);
3073 /* [namespace.memdef]/2 */
3076 pop_decl_namespace (void)
3078 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3081 /* Return the namespace that is the common ancestor
3082 of two given namespaces. */
3085 namespace_ancestor (tree ns1, tree ns2)
3087 timevar_push (TV_NAME_LOOKUP);
3088 if (is_ancestor (ns1, ns2))
3089 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3090 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3091 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3094 /* Process a namespace-alias declaration. */
3097 do_namespace_alias (tree alias, tree namespace)
3099 if (namespace == error_mark_node)
3102 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3104 namespace = ORIGINAL_NAMESPACE (namespace);
3106 /* Build the alias. */
3107 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3108 DECL_NAMESPACE_ALIAS (alias) = namespace;
3109 DECL_EXTERNAL (alias) = 1;
3110 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3113 /* Emit debug info for namespace alias. */
3114 (*debug_hooks->global_decl) (alias);
3117 /* Like pushdecl, only it places X in the current namespace,
3121 pushdecl_namespace_level (tree x, bool is_friend)
3123 struct cp_binding_level *b = current_binding_level;
3126 timevar_push (TV_NAME_LOOKUP);
3127 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3129 /* Now, the type_shadowed stack may screw us. Munge it so it does
3131 if (TREE_CODE (t) == TYPE_DECL)
3133 tree name = DECL_NAME (t);
3135 tree *ptr = (tree *)0;
3136 for (; !global_scope_p (b); b = b->level_chain)
3138 tree shadowed = b->type_shadowed;
3139 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3140 if (TREE_PURPOSE (shadowed) == name)
3142 ptr = &TREE_VALUE (shadowed);
3143 /* Can't break out of the loop here because sometimes
3144 a binding level will have duplicate bindings for
3145 PT names. It's gross, but I haven't time to fix it. */
3148 newval = TREE_TYPE (t);
3149 if (ptr == (tree *)0)
3151 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3152 up here if this is changed to an assertion. --KR */
3153 SET_IDENTIFIER_TYPE_VALUE (name, t);
3160 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3163 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3164 directive is not directly from the source. Also find the common
3165 ancestor and let our users know about the new namespace */
3167 add_using_namespace (tree user, tree used, bool indirect)
3170 timevar_push (TV_NAME_LOOKUP);
3171 /* Using oneself is a no-op. */
3174 timevar_pop (TV_NAME_LOOKUP);
3177 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3178 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3179 /* Check if we already have this. */
3180 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3184 /* Promote to direct usage. */
3185 TREE_INDIRECT_USING (t) = 0;
3186 timevar_pop (TV_NAME_LOOKUP);
3190 /* Add used to the user's using list. */
3191 DECL_NAMESPACE_USING (user)
3192 = tree_cons (used, namespace_ancestor (user, used),
3193 DECL_NAMESPACE_USING (user));
3195 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3197 /* Add user to the used's users list. */
3198 DECL_NAMESPACE_USERS (used)
3199 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3201 /* Recursively add all namespaces used. */
3202 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3203 /* indirect usage */
3204 add_using_namespace (user, TREE_PURPOSE (t), 1);
3206 /* Tell everyone using us about the new used namespaces. */
3207 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3208 add_using_namespace (TREE_PURPOSE (t), used, 1);
3209 timevar_pop (TV_NAME_LOOKUP);
3212 /* Process a using-declaration not appearing in class or local scope. */
3215 do_toplevel_using_decl (tree decl, tree scope, tree name)
3217 tree oldval, oldtype, newval, newtype;
3218 tree orig_decl = decl;
3219 cxx_binding *binding;
3221 decl = validate_nonmember_using_decl (decl, scope, name);
3222 if (decl == NULL_TREE)
3225 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3227 oldval = binding->value;
3228 oldtype = binding->type;
3230 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3232 /* Emit debug info. */
3233 if (!processing_template_decl)
3234 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3236 /* Copy declarations found. */
3238 binding->value = newval;
3240 binding->type = newtype;
3244 /* Process a using-directive. */
3247 do_using_directive (tree namespace)
3249 tree context = NULL_TREE;
3251 if (namespace == error_mark_node)
3254 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3256 if (building_stmt_tree ())
3257 add_stmt (build_stmt (USING_STMT, namespace));
3258 namespace = ORIGINAL_NAMESPACE (namespace);
3260 if (!toplevel_bindings_p ())
3262 push_using_directive (namespace);
3263 context = current_scope ();
3268 add_using_namespace (current_namespace, namespace, 0);
3269 if (current_namespace != global_namespace)
3270 context = current_namespace;
3273 /* Emit debugging info. */
3274 if (!processing_template_decl)
3275 (*debug_hooks->imported_module_or_decl) (namespace, context);
3278 /* Deal with a using-directive seen by the parser. Currently we only
3279 handle attributes here, since they cannot appear inside a template. */
3282 parse_using_directive (tree namespace, tree attribs)
3286 do_using_directive (namespace);
3288 for (a = attribs; a; a = TREE_CHAIN (a))
3290 tree name = TREE_PURPOSE (a);
3291 if (is_attribute_p ("strong", name))
3293 if (!toplevel_bindings_p ())
3294 error ("strong using only meaningful at namespace scope");
3295 else if (namespace != error_mark_node)
3296 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3297 = tree_cons (current_namespace, 0,
3298 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3301 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3305 /* Like pushdecl, only it places X in the global scope if appropriate.
3306 Calls cp_finish_decl to register the variable, initializing it with
3307 *INIT, if INIT is non-NULL. */
3310 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3312 timevar_push (TV_NAME_LOOKUP);
3313 push_to_top_level ();
3314 x = pushdecl_namespace_level (x, is_friend);
3316 finish_decl (x, *init, NULL_TREE);
3317 pop_from_top_level ();
3318 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3321 /* Like pushdecl, only it places X in the global scope if appropriate. */
3324 pushdecl_top_level (tree x)
3326 return pushdecl_top_level_1 (x, NULL, false);
3329 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3332 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3334 return pushdecl_top_level_1 (x, NULL, is_friend);
3337 /* Like pushdecl, only it places X in the global scope if
3338 appropriate. Calls cp_finish_decl to register the variable,
3339 initializing it with INIT. */
3342 pushdecl_top_level_and_finish (tree x, tree init)
3344 return pushdecl_top_level_1 (x, &init, false);
3347 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3348 duplicates. The first list becomes the tail of the result.
3350 The algorithm is O(n^2). We could get this down to O(n log n) by
3351 doing a sort on the addresses of the functions, if that becomes
3355 merge_functions (tree s1, tree s2)
3357 for (; s2; s2 = OVL_NEXT (s2))
3359 tree fn2 = OVL_CURRENT (s2);
3362 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3364 tree fn1 = OVL_CURRENT (fns1);
3366 /* If the function from S2 is already in S1, there is no
3367 need to add it again. For `extern "C"' functions, we
3368 might have two FUNCTION_DECLs for the same function, in
3369 different namespaces; again, we only need one of them. */
3371 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3372 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3376 /* If we exhausted all of the functions in S1, FN2 is new. */
3378 s1 = build_overload (fn2, s1);
3383 /* This should return an error not all definitions define functions.
3384 It is not an error if we find two functions with exactly the
3385 same signature, only if these are selected in overload resolution.
3386 old is the current set of bindings, new the freshly-found binding.
3387 XXX Do we want to give *all* candidates in case of ambiguity?
3388 XXX In what way should I treat extern declarations?
3389 XXX I don't want to repeat the entire duplicate_decls here */
3392 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3396 gcc_assert (old != NULL);
3397 /* Copy the value. */
3400 switch (TREE_CODE (val))
3403 /* If we expect types or namespaces, and not templates,
3404 or this is not a template class. */
3405 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3406 && !DECL_CLASS_TEMPLATE_P (val))
3407 || hidden_name_p (val))
3411 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3414 case NAMESPACE_DECL:
3415 if (LOOKUP_TYPES_ONLY (flags))
3419 /* Ignore built-in functions that are still anticipated. */
3420 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3424 if (LOOKUP_QUALIFIERS_ONLY (flags))
3430 else if (val && val != old->value)
3432 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3433 old->value = merge_functions (old->value, val);
3436 old->value = tree_cons (NULL_TREE, old->value,
3437 build_tree_list (NULL_TREE, new->value));
3438 TREE_TYPE (old->value) = error_mark_node;
3441 /* ... and copy the type. */
3443 if (LOOKUP_NAMESPACES_ONLY (flags))
3447 else if (type && old->type != type)
3449 if (flags & LOOKUP_COMPLAIN)
3451 error ("%qD denotes an ambiguous type",name);
3452 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3453 error ("%J other type here", TYPE_MAIN_DECL (type));
3458 /* Return the declarations that are members of the namespace NS. */
3461 cp_namespace_decls (tree ns)
3463 return NAMESPACE_LEVEL (ns)->names;
3466 /* Combine prefer_type and namespaces_only into flags. */
3469 lookup_flags (int prefer_type, int namespaces_only)
3471 if (namespaces_only)
3472 return LOOKUP_PREFER_NAMESPACES;
3473 if (prefer_type > 1)
3474 return LOOKUP_PREFER_TYPES;
3475 if (prefer_type > 0)
3476 return LOOKUP_PREFER_BOTH;
3480 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3481 ignore it or not. Subroutine of lookup_name_real and
3482 lookup_type_scope. */
3485 qualify_lookup (tree val, int flags)
3487 if (val == NULL_TREE)
3489 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3491 if ((flags & LOOKUP_PREFER_TYPES)
3492 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3494 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3499 /* Given a lookup that returned VAL, decide if we want to ignore it or
3500 not based on DECL_ANTICIPATED. */
3503 hidden_name_p (tree val)
3506 && DECL_LANG_SPECIFIC (val)
3507 && DECL_ANTICIPATED (val))
3512 /* Remove any hidden friend functions from a possibly overloaded set
3516 remove_hidden_names (tree fns)
3521 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3523 else if (TREE_CODE (fns) == OVERLOAD)
3527 for (o = fns; o; o = OVL_NEXT (o))
3528 if (hidden_name_p (OVL_CURRENT (o)))
3534 for (o = fns; o; o = OVL_NEXT (o))
3535 if (!hidden_name_p (OVL_CURRENT (o)))
3536 n = build_overload (OVL_CURRENT (o), n);
3544 /* Look up NAME in the NAMESPACE. */
3547 lookup_namespace_name (tree namespace, tree name)
3550 tree template_id = NULL_TREE;
3551 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3553 timevar_push (TV_NAME_LOOKUP);
3554 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3556 if (TREE_CODE (name) == NAMESPACE_DECL)
3557 /* This happens for A::B<int> when B is a namespace. */
3558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3559 else if (TREE_CODE (name) == TEMPLATE_DECL)
3561 /* This happens for A::B where B is a template, and there are no
3562 template arguments. */
3563 error ("invalid use of %qD", name);
3564 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3567 namespace = ORIGINAL_NAMESPACE (namespace);
3569 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3572 name = TREE_OPERAND (name, 0);
3573 if (TREE_CODE (name) == OVERLOAD)
3574 name = DECL_NAME (OVL_CURRENT (name));
3575 else if (DECL_P (name))
3576 name = DECL_NAME (name);
3579 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3581 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3582 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3586 val = binding.value;
3590 if (DECL_CLASS_TEMPLATE_P (val))
3591 val = lookup_template_class (val,
3592 TREE_OPERAND (template_id, 1),
3593 /*in_decl=*/NULL_TREE,
3594 /*context=*/NULL_TREE,
3595 /*entering_scope=*/0,
3596 tf_error | tf_warning);
3597 else if (DECL_FUNCTION_TEMPLATE_P (val)
3598 || TREE_CODE (val) == OVERLOAD)
3599 val = lookup_template_function (val,
3600 TREE_OPERAND (template_id, 1));
3603 error ("%<%D::%D%> is not a template", namespace, name);
3604 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3608 /* If we have a single function from a using decl, pull it out. */
3609 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3610 val = OVL_FUNCTION (val);
3612 /* Ignore built-in functions and friends that haven't been declared
3614 if (!val || !hidden_name_p (val))
3615 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3618 error ("%qD undeclared in namespace %qD", name, namespace);
3619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3622 /* Select the right _DECL from multiple choices. */
3625 select_decl (const struct scope_binding *binding, int flags)
3628 val = binding->value;
3630 timevar_push (TV_NAME_LOOKUP);
3631 if (LOOKUP_NAMESPACES_ONLY (flags))
3633 /* We are not interested in types. */
3634 if (val && (TREE_CODE (val) == NAMESPACE_DECL
3635 || TREE_CODE (val) == TREE_LIST))
3636 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3637 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3640 /* If looking for a type, or if there is no non-type binding, select
3641 the value binding. */
3642 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3643 val = binding->type;
3644 /* Don't return non-types if we really prefer types. */
3645 else if (val && LOOKUP_TYPES_ONLY (flags)
3646 && ! DECL_DECLARES_TYPE_P (val))
3649 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3652 /* Unscoped lookup of a global: iterate over current namespaces,
3653 considering using-directives. */
3656 unqualified_namespace_lookup (tree name, int flags)
3658 tree initial = current_decl_namespace ();
3659 tree scope = initial;
3661 struct cp_binding_level *level;
3662 tree val = NULL_TREE;
3663 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3665 timevar_push (TV_NAME_LOOKUP);
3667 for (; !val; scope = CP_DECL_CONTEXT (scope))
3670 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3674 if (b->value && hidden_name_p (b->value))
3675 /* Ignore anticipated built-in functions and friends. */
3678 binding.value = b->value;
3679 binding.type = b->type;
3682 /* Add all _DECLs seen through local using-directives. */
3683 for (level = current_binding_level;
3684 level->kind != sk_namespace;
3685 level = level->level_chain)
3686 if (!lookup_using_namespace (name, &binding, level->using_directives,
3688 /* Give up because of error. */
3689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3691 /* Add all _DECLs seen through global using-directives. */
3692 /* XXX local and global using lists should work equally. */
3696 if (!lookup_using_namespace (name, &binding,
3697 DECL_NAMESPACE_USING (siter),
3699 /* Give up because of error. */
3700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3701 if (siter == scope) break;
3702 siter = CP_DECL_CONTEXT (siter);
3705 val = select_decl (&binding, flags);
3706 if (scope == global_namespace)
3709 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3712 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3713 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3716 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3717 declaration found. If no suitable declaration can be found,
3718 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3719 neither a class-type nor a namespace a diagnostic is issued. */
3722 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3726 if (TREE_CODE (scope) == NAMESPACE_DECL)
3728 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3730 flags |= LOOKUP_COMPLAIN;
3732 flags |= LOOKUP_PREFER_TYPES;
3733 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3734 return select_decl (&binding, flags);
3736 else if (is_aggr_type (scope, complain))
3739 t = lookup_member (scope, name, 2, is_type_p);
3744 return error_mark_node;
3747 /* Subroutine of unqualified_namespace_lookup:
3748 Add the bindings of NAME in used namespaces to VAL.
3749 We are currently looking for names in namespace SCOPE, so we
3750 look through USINGS for using-directives of namespaces
3751 which have SCOPE as a common ancestor with the current scope.
3752 Returns false on errors. */
3755 lookup_using_namespace (tree name, struct scope_binding *val,
3756 tree usings, tree scope, int flags)
3759 timevar_push (TV_NAME_LOOKUP);
3760 /* Iterate over all used namespaces in current, searching for using
3761 directives of scope. */
3762 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3763 if (TREE_VALUE (iter) == scope)
3765 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3767 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3768 /* Resolve ambiguities. */
3770 ambiguous_decl (name, val, val1, flags);
3772 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3776 Accepts the NAME to lookup and its qualifying SCOPE.
3777 Returns the name/type pair found into the cxx_binding *RESULT,
3778 or false on error. */
3781 qualified_lookup_using_namespace (tree name, tree scope,
3782 struct scope_binding *result, int flags)
3784 /* Maintain a list of namespaces visited... */
3785 tree seen = NULL_TREE;
3786 /* ... and a list of namespace yet to see. */
3787 tree todo = NULL_TREE;
3788 tree todo_maybe = NULL_TREE;
3790 timevar_push (TV_NAME_LOOKUP);
3791 /* Look through namespace aliases. */
3792 scope = ORIGINAL_NAMESPACE (scope);
3793 while (scope && result->value != error_mark_node)
3795 cxx_binding *binding =
3796 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3797 seen = tree_cons (scope, NULL_TREE, seen);
3799 ambiguous_decl (name, result, binding, flags);
3801 /* Consider strong using directives always, and non-strong ones
3802 if we haven't found a binding yet. ??? Shouldn't we consider
3803 non-strong ones if the initial RESULT is non-NULL, but the
3804 binding in the given namespace is? */
3805 for (usings = DECL_NAMESPACE_USING (scope); usings;
3806 usings = TREE_CHAIN (usings))
3807 /* If this was a real directive, and we have not seen it. */
3808 if (!TREE_INDIRECT_USING (usings))
3810 /* Try to avoid queuing the same namespace more than once,
3811 the exception being when a namespace was already
3812 enqueued for todo_maybe and then a strong using is
3813 found for it. We could try to remove it from
3814 todo_maybe, but it's probably not worth the effort. */
3815 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3816 && !purpose_member (TREE_PURPOSE (usings), seen)
3817 && !purpose_member (TREE_PURPOSE (usings), todo))
3818 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3819 else if ((!result->value && !result->type)
3820 && !purpose_member (TREE_PURPOSE (usings), seen)
3821 && !purpose_member (TREE_PURPOSE (usings), todo)
3822 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3823 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3828 scope = TREE_PURPOSE (todo);
3829 todo = TREE_CHAIN (todo);
3832 && (!result->value && !result->type))
3834 scope = TREE_PURPOSE (todo_maybe);
3835 todo = TREE_CHAIN (todo_maybe);
3836 todo_maybe = NULL_TREE;
3839 scope = NULL_TREE; /* If there never was a todo list. */
3841 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3844 /* Return the innermost non-namespace binding for NAME from a scope
3845 containing BINDING, or, if BINDING is NULL, the current scope. If
3846 CLASS_P is false, then class bindings are ignored. */
3849 outer_binding (tree name,
3850 cxx_binding *binding,
3855 cxx_scope *outer_scope;
3859 scope = binding->scope->level_chain;
3860 outer = binding->previous;
3864 scope = current_binding_level;
3865 outer = IDENTIFIER_BINDING (name);
3867 outer_scope = outer ? outer->scope : NULL;
3869 /* Because we create class bindings lazily, we might be missing a
3870 class binding for NAME. If there are any class binding levels
3871 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3872 declared, we must lookup NAME in those class scopes. */
3874 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3876 if (scope->kind == sk_class)
3878 cxx_binding *class_binding;
3880 class_binding = get_class_binding (name, scope);
3883 /* Thread this new class-scope binding onto the
3884 IDENTIFIER_BINDING list so that future lookups
3886 class_binding->previous = outer;
3888 binding->previous = class_binding;
3890 IDENTIFIER_BINDING (name) = class_binding;
3891 return class_binding;
3894 scope = scope->level_chain;
3900 /* Return the innermost block-scope or class-scope value binding for
3901 NAME, or NULL_TREE if there is no such binding. */
3904 innermost_non_namespace_value (tree name)
3906 cxx_binding *binding;
3907 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3908 return binding ? binding->value : NULL_TREE;
3911 /* Look up NAME in the current binding level and its superiors in the
3912 namespace of variables, functions and typedefs. Return a ..._DECL
3913 node of some kind representing its definition if there is only one
3914 such declaration, or return a TREE_LIST with all the overloaded
3915 definitions if there are many, or return 0 if it is undefined.
3916 Hidden name, either friend declaration or built-in function, are
3919 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3920 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3921 Otherwise we prefer non-TYPE_DECLs.
3923 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3924 BLOCK_P is false, bindings in block scopes are ignored. */
3927 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3928 int namespaces_only, int flags)
3931 tree val = NULL_TREE;
3933 timevar_push (TV_NAME_LOOKUP);
3934 /* Conversion operators are handled specially because ordinary
3935 unqualified name lookup will not find template conversion
3937 if (IDENTIFIER_TYPENAME_P (name))
3939 struct cp_binding_level *level;
3941 for (level = current_binding_level;
3942 level && level->kind != sk_namespace;
3943 level = level->level_chain)
3948 /* A conversion operator can only be declared in a class
3950 if (level->kind != sk_class)
3953 /* Lookup the conversion operator in the class. */
3954 class_type = level->this_entity;
3955 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3957 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3960 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3963 flags |= lookup_flags (prefer_type, namespaces_only);
3965 /* First, look in non-namespace scopes. */
3967 if (current_class_type == NULL_TREE)
3970 if (block_p || !nonclass)
3971 for (iter = outer_binding (name, NULL, !nonclass);
3973 iter = outer_binding (name, iter, !nonclass))
3977 /* Skip entities we don't want. */
3978 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3981 /* If this is the kind of thing we're looking for, we're done. */
3982 if (qualify_lookup (iter->value, flags)
3983 && !hidden_name_p (iter->value))
3984 binding = iter->value;
3985 else if ((flags & LOOKUP_PREFER_TYPES)
3986 && qualify_lookup (iter->type, flags)
3987 && !hidden_name_p (iter->type))
3988 binding = iter->type;
3990 binding = NULL_TREE;
3999 /* Now lookup in namespace scopes. */
4001 val = unqualified_namespace_lookup (name, flags);
4005 /* If we have a single function from a using decl, pull it out. */
4006 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
4007 val = OVL_FUNCTION (val);
4010 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4014 lookup_name_nonclass (tree name)
4016 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4020 lookup_function_nonclass (tree name, tree args, bool block_p)
4023 lookup_arg_dependent (name,
4024 lookup_name_real (name, 0, 1, block_p, 0,
4030 lookup_name (tree name, int prefer_type)
4032 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4033 0, LOOKUP_COMPLAIN);
4036 /* Similar to `lookup_name' for the benefit of common code. */
4039 lookup_name_one (tree name)
4041 return lookup_name (name, 0);
4044 /* Look up NAME for type used in elaborated name specifier in
4045 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4046 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4047 name, more scopes are checked if cleanup or template parameter
4048 scope is encountered.
4050 Unlike lookup_name_real, we make sure that NAME is actually
4051 declared in the desired scope, not from inheritance, nor using
4052 directive. For using declaration, there is DR138 still waiting
4053 to be resolved. Hidden name coming from an earlier friend
4054 declaration is also returned.
4056 A TYPE_DECL best matching the NAME is returned. Catching error
4057 and issuing diagnostics are caller's responsibility. */
4060 lookup_type_scope (tree name, tag_scope scope)
4062 cxx_binding *iter = NULL;
4063 tree val = NULL_TREE;
4065 timevar_push (TV_NAME_LOOKUP);
4067 /* Look in non-namespace scope first. */
4068 if (current_binding_level->kind != sk_namespace)
4069 iter = outer_binding (name, NULL, /*class_p=*/ true);
4070 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4072 /* Check if this is the kind of thing we're looking for.
4073 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4074 base class. For ITER->VALUE, we can simply use
4075 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4078 We check ITER->TYPE before ITER->VALUE in order to handle
4079 typedef struct C {} C;
4082 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4083 && (scope != ts_current
4084 || LOCAL_BINDING_P (iter)
4085 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4087 else if ((scope != ts_current
4088 || !INHERITED_VALUE_BINDING_P (iter))
4089 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4096 /* Look in namespace scope. */
4099 iter = cxx_scope_find_binding_for_name
4100 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4104 /* If this is the kind of thing we're looking for, we're done. */
4105 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4107 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4113 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4114 and template parameter scopes. */
4117 struct cp_binding_level *b = current_binding_level;
4120 if (iter->scope == b)
4121 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4123 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4125 else if (b->kind == sk_class
4126 && scope == ts_within_enclosing_non_class)
4133 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4136 /* Similar to `lookup_name' but look only in the innermost non-class
4140 lookup_name_innermost_nonclass_level (tree name)
4142 struct cp_binding_level *b;
4145 timevar_push (TV_NAME_LOOKUP);
4146 b = innermost_nonclass_level ();
4148 if (b->kind == sk_namespace)
4150 t = IDENTIFIER_NAMESPACE_VALUE (name);
4152 /* extern "C" function() */
4153 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4156 else if (IDENTIFIER_BINDING (name)
4157 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4159 cxx_binding *binding;
4160 binding = IDENTIFIER_BINDING (name);
4163 if (binding->scope == b
4164 && !(TREE_CODE (binding->value) == VAR_DECL
4165 && DECL_DEAD_FOR_LOCAL (binding->value)))
4166 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4168 if (b->kind == sk_cleanup)
4175 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4178 /* Like lookup_name_innermost_nonclass_level, but for types. */
4181 lookup_type_current_level (tree name)
4185 timevar_push (TV_NAME_LOOKUP);
4186 gcc_assert (current_binding_level->kind != sk_namespace);
4188 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4189 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4191 struct cp_binding_level *b = current_binding_level;
4194 if (purpose_member (name, b->type_shadowed))
4195 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4196 REAL_IDENTIFIER_TYPE_VALUE (name));
4197 if (b->kind == sk_cleanup)
4204 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4207 /* [basic.lookup.koenig] */
4208 /* A nonzero return value in the functions below indicates an error. */
4219 static bool arg_assoc (struct arg_lookup*, tree);
4220 static bool arg_assoc_args (struct arg_lookup*, tree);
4221 static bool arg_assoc_type (struct arg_lookup*, tree);
4222 static bool add_function (struct arg_lookup *, tree);
4223 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4224 static bool arg_assoc_class (struct arg_lookup *, tree);
4225 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4227 /* Add a function to the lookup structure.
4228 Returns true on error. */
4231 add_function (struct arg_lookup *k, tree fn)
4233 /* We used to check here to see if the function was already in the list,
4234 but that's O(n^2), which is just too expensive for function lookup.
4235 Now we deal with the occasional duplicate in joust. In doing this, we
4236 assume that the number of duplicates will be small compared to the
4237 total number of functions being compared, which should usually be the
4240 /* We must find only functions, or exactly one non-function. */
4243 else if (fn == k->functions)
4245 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4246 k->functions = build_overload (fn, k->functions);
4249 tree f1 = OVL_CURRENT (k->functions);
4251 if (is_overloaded_fn (f1))
4253 fn = f1; f1 = f2; f2 = fn;
4255 error ("%q+D is not a function,", f1);
4256 error (" conflict with %q+D", f2);
4257 error (" in call to %qD", k->name);
4264 /* Returns true iff CURRENT has declared itself to be an associated
4265 namespace of SCOPE via a strong using-directive (or transitive chain
4266 thereof). Both are namespaces. */
4269 is_associated_namespace (tree current, tree scope)
4271 tree seen = NULL_TREE;
4272 tree todo = NULL_TREE;
4276 if (scope == current)
4278 seen = tree_cons (scope, NULL_TREE, seen);
4279 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4280 if (!purpose_member (TREE_PURPOSE (t), seen))
4281 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4284 scope = TREE_PURPOSE (todo);
4285 todo = TREE_CHAIN (todo);
4292 /* Return whether FN is a friend of an associated class of ARG. */
4295 friend_of_associated_class_p (tree arg, tree fn)
4301 else if (type_unknown_p (arg))
4304 type = TREE_TYPE (arg);
4306 /* If TYPE is a class, the class itself and all base classes are
4307 associated classes. */
4308 if (CLASS_TYPE_P (type))
4310 if (is_friend (type, fn))
4313 if (TYPE_BINFO (type))
4315 tree binfo, base_binfo;
4318 for (binfo = TYPE_BINFO (type), i = 0;
4319 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4321 if (is_friend (BINFO_TYPE (base_binfo), fn))
4326 /* If TYPE is a class member, the class of which it is a member is
4327 an associated class. */
4328 if ((CLASS_TYPE_P (type)
4329 || TREE_CODE (type) == UNION_TYPE
4330 || TREE_CODE (type) == ENUMERAL_TYPE)
4331 && TYPE_CONTEXT (type)
4332 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4333 && is_friend (TYPE_CONTEXT (type), fn))
4339 /* Add functions of a namespace to the lookup structure.
4340 Returns true on error. */
4343 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4347 if (purpose_member (scope, k->namespaces))
4349 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4351 /* Check out our super-users. */
4352 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4353 value = TREE_CHAIN (value))
4354 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4357 value = namespace_binding (k->name, scope);
4361 for (; value; value = OVL_NEXT (value))
4363 /* We don't want to find arbitrary hidden functions via argument
4364 dependent lookup. We only want to find friends of associated
4366 if (hidden_name_p (OVL_CURRENT (value)))
4370 for (args = k->args; args; args = TREE_CHAIN (args))
4371 if (friend_of_associated_class_p (TREE_VALUE (args),
4372 OVL_CURRENT (value)))
4378 if (add_function (k, OVL_CURRENT (value)))
4385 /* Adds everything associated with a template argument to the lookup
4386 structure. Returns true on error. */
4389 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4391 /* [basic.lookup.koenig]
4393 If T is a template-id, its associated namespaces and classes are
4394 ... the namespaces and classes associated with the types of the
4395 template arguments provided for template type parameters
4396 (excluding template template parameters); the namespaces in which
4397 any template template arguments are defined; and the classes in
4398 which any member templates used as template template arguments
4399 are defined. [Note: non-type template arguments do not
4400 contribute to the set of associated namespaces. ] */
4402 /* Consider first template template arguments. */
4403 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4404 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4406 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4408 tree ctx = CP_DECL_CONTEXT (arg);
4410 /* It's not a member template. */
4411 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4412 return arg_assoc_namespace (k, ctx);
4413 /* Otherwise, it must be member template. */
4415 return arg_assoc_class (k, ctx);
4417 /* It's not a template template argument, but it is a type template
4419 else if (TYPE_P (arg))
4420 return arg_assoc_type (k, arg);
4421 /* It's a non-type template argument. */
4426 /* Adds everything associated with class to the lookup structure.
4427 Returns true on error. */
4430 arg_assoc_class (struct arg_lookup *k, tree type)
4432 tree list, friends, context;
4435 /* Backend build structures, such as __builtin_va_list, aren't
4436 affected by all this. */
4437 if (!CLASS_TYPE_P (type))
4440 if (purpose_member (type, k->classes))
4442 k->classes = tree_cons (type, NULL_TREE, k->classes);
4444 context = decl_namespace_context (type);
4445 if (arg_assoc_namespace (k, context))
4448 if (TYPE_BINFO (type))
4450 /* Process baseclasses. */
4451 tree binfo, base_binfo;
4453 for (binfo = TYPE_BINFO (type), i = 0;
4454 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4455 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4459 /* Process friends. */
4460 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4461 list = TREE_CHAIN (list))
4462 if (k->name == FRIEND_NAME (list))
4463 for (friends = FRIEND_DECLS (list); friends;
4464 friends = TREE_CHAIN (friends))
4466 tree fn = TREE_VALUE (friends);
4468 /* Only interested in global functions with potentially hidden
4469 (i.e. unqualified) declarations. */
4470 if (CP_DECL_CONTEXT (fn) != context)
4472 /* Template specializations are never found by name lookup.
4473 (Templates themselves can be found, but not template
4474 specializations.) */
4475 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4477 if (add_function (k, fn))
4481 /* Process template arguments. */
4482 if (CLASSTYPE_TEMPLATE_INFO (type)
4483 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4485 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4486 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4487 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4493 /* Adds everything associated with a given type.
4494 Returns 1 on error. */
4497 arg_assoc_type (struct arg_lookup *k, tree type)
4499 /* As we do not get the type of non-type dependent expressions
4500 right, we can end up with such things without a type. */
4504 if (TYPE_PTRMEM_P (type))
4506 /* Pointer to member: associate class type and value type. */
4507 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4509 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4511 else switch (TREE_CODE (type))
4524 if (TYPE_PTRMEMFUNC_P (type))
4525 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4526 return arg_assoc_class (k, type);
4528 case REFERENCE_TYPE:
4530 return arg_assoc_type (k, TREE_TYPE (type));
4533 return arg_assoc_namespace (k, decl_namespace_context (type));
4535 /* The basetype is referenced in the first arg type, so just
4538 /* Associate the parameter types. */
4539 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4541 /* Associate the return type. */
4542 return arg_assoc_type (k, TREE_TYPE (type));
4543 case TEMPLATE_TYPE_PARM:
4544 case BOUND_TEMPLATE_TEMPLATE_PARM:
4549 gcc_assert (type == unknown_type_node);
4557 /* Adds everything associated with arguments. Returns true on error. */
4560 arg_assoc_args (struct arg_lookup *k, tree args)
4562 for (; args; args = TREE_CHAIN (args))
4563 if (arg_assoc (k, TREE_VALUE (args)))
4568 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4571 arg_assoc (struct arg_lookup *k, tree n)
4573 if (n == error_mark_node)
4577 return arg_assoc_type (k, n);
4579 if (! type_unknown_p (n))
4580 return arg_assoc_type (k, TREE_TYPE (n));
4582 if (TREE_CODE (n) == ADDR_EXPR)
4583 n = TREE_OPERAND (n, 0);
4584 if (TREE_CODE (n) == COMPONENT_REF)
4585 n = TREE_OPERAND (n, 1);
4586 if (TREE_CODE (n) == OFFSET_REF)
4587 n = TREE_OPERAND (n, 1);
4588 while (TREE_CODE (n) == TREE_LIST)
4590 if (TREE_CODE (n) == BASELINK)
4591 n = BASELINK_FUNCTIONS (n);
4593 if (TREE_CODE (n) == FUNCTION_DECL)
4594 return arg_assoc_type (k, TREE_TYPE (n));
4595 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4597 /* [basic.lookup.koenig]
4599 If T is a template-id, its associated namespaces and classes
4600 are the namespace in which the template is defined; for
4601 member templates, the member template's class... */
4602 tree template = TREE_OPERAND (n, 0);
4603 tree args = TREE_OPERAND (n, 1);
4607 if (TREE_CODE (template) == COMPONENT_REF)
4608 template = TREE_OPERAND (template, 1);
4610 /* First, the template. There may actually be more than one if
4611 this is an overloaded function template. But, in that case,
4612 we only need the first; all the functions will be in the same
4614 template = OVL_CURRENT (template);
4616 ctx = CP_DECL_CONTEXT (template);
4618 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4620 if (arg_assoc_namespace (k, ctx) == 1)
4623 /* It must be a member template. */
4624 else if (arg_assoc_class (k, ctx) == 1)
4627 /* Now the arguments. */
4629 for (ix = TREE_VEC_LENGTH (args); ix--;)
4630 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4633 else if (TREE_CODE (n) == OVERLOAD)
4635 for (; n; n = OVL_CHAIN (n))
4636 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4643 /* Performs Koenig lookup depending on arguments, where fns
4644 are the functions found in normal lookup. */
4647 lookup_arg_dependent (tree name, tree fns, tree args)
4649 struct arg_lookup k;
4651 timevar_push (TV_NAME_LOOKUP);
4653 /* Remove any hidden friend functions from the list of functions
4654 found so far. They will be added back by arg_assoc_class as
4656 fns = remove_hidden_names (fns);
4661 k.classes = NULL_TREE;
4663 /* We previously performed an optimization here by setting
4664 NAMESPACES to the current namespace when it was safe. However, DR
4665 164 says that namespaces that were already searched in the first
4666 stage of template processing are searched again (potentially
4667 picking up later definitions) in the second stage. */
4668 k.namespaces = NULL_TREE;
4670 arg_assoc_args (&k, args);
4671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4674 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4675 changed (i.e. there was already a directive), or the fresh
4676 TREE_LIST otherwise. */
4679 push_using_directive (tree used)
4681 tree ud = current_binding_level->using_directives;
4682 tree iter, ancestor;
4684 timevar_push (TV_NAME_LOOKUP);
4685 /* Check if we already have this. */
4686 if (purpose_member (used, ud) != NULL_TREE)
4687 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4689 ancestor = namespace_ancestor (current_decl_namespace (), used);
4690 ud = current_binding_level->using_directives;
4691 ud = tree_cons (used, ancestor, ud);
4692 current_binding_level->using_directives = ud;
4694 /* Recursively add all namespaces used. */
4695 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4696 push_using_directive (TREE_PURPOSE (iter));
4698 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4701 /* The type TYPE is being declared. If it is a class template, or a
4702 specialization of a class template, do any processing required and
4703 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4704 being declared a friend. B is the binding level at which this TYPE
4707 Returns the TYPE_DECL for TYPE, which may have been altered by this
4711 maybe_process_template_type_declaration (tree type, int is_friend,
4714 tree decl = TYPE_NAME (type);
4716 if (processing_template_parmlist)
4717 /* You can't declare a new template type in a template parameter
4718 list. But, you can declare a non-template type:
4720 template <class A*> struct S;
4722 is a forward-declaration of `A'. */
4724 else if (b->kind == sk_namespace
4725 && current_binding_level->kind != sk_namespace)
4726 /* If this new type is being injected into a containing scope,
4727 then it's not a template type. */
4731 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4733 if (processing_template_decl)
4735 /* This may change after the call to
4736 push_template_decl_real, but we want the original value. */
4737 tree name = DECL_NAME (decl);
4739 decl = push_template_decl_real (decl, is_friend);
4740 /* If the current binding level is the binding level for the
4741 template parameters (see the comment in
4742 begin_template_parm_list) and the enclosing level is a class
4743 scope, and we're not looking at a friend, push the
4744 declaration of the member class into the class scope. In the
4745 friend case, push_template_decl will already have put the
4746 friend into global scope, if appropriate. */
4747 if (TREE_CODE (type) != ENUMERAL_TYPE
4748 && !is_friend && b->kind == sk_template_parms
4749 && b->level_chain->kind == sk_class)
4751 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4753 if (!COMPLETE_TYPE_P (current_class_type))
4755 maybe_add_class_template_decl_list (current_class_type,
4756 type, /*friend_p=*/0);
4757 /* Put this UTD in the table of UTDs for the class. */
4758 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4759 CLASSTYPE_NESTED_UTDS (current_class_type) =
4760 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4762 binding_table_insert
4763 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4772 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4773 that the NAME is a class template, the tag is processed but not pushed.
4775 The pushed scope depend on the SCOPE parameter:
4776 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4778 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4779 non-template-parameter scope. This case is needed for forward
4781 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4782 TS_GLOBAL case except that names within template-parameter scopes
4783 are not pushed at all.
4785 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4788 pushtag (tree name, tree type, tag_scope scope)
4790 struct cp_binding_level *b;
4793 timevar_push (TV_NAME_LOOKUP);
4794 b = current_binding_level;
4795 while (/* Cleanup scopes are not scopes from the point of view of
4797 b->kind == sk_cleanup
4798 /* Neither are the scopes used to hold template parameters
4799 for an explicit specialization. For an ordinary template
4800 declaration, these scopes are not scopes from the point of
4801 view of the language. */
4802 || (b->kind == sk_template_parms
4803 && (b->explicit_spec_p || scope == ts_global))
4804 || (b->kind == sk_class
4805 && (scope != ts_current
4806 /* We may be defining a new type in the initializer
4807 of a static member variable. We allow this when
4808 not pedantic, and it is particularly useful for
4809 type punning via an anonymous union. */
4810 || COMPLETE_TYPE_P (b->this_entity))))
4813 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4815 /* Do C++ gratuitous typedefing. */
4816 if (IDENTIFIER_TYPE_VALUE (name) != type)
4820 tree context = TYPE_CONTEXT (type);
4824 tree cs = current_scope ();
4826 if (scope == ts_current)
4828 else if (cs != NULL_TREE && TYPE_P (cs))
4829 /* When declaring a friend class of a local class, we want
4830 to inject the newly named class into the scope
4831 containing the local class, not the namespace
4833 context = decl_function_context (get_type_decl (cs));
4836 context = current_namespace;
4838 if (b->kind == sk_class
4839 || (b->kind == sk_template_parms
4840 && b->level_chain->kind == sk_class))
4843 if (current_lang_name == lang_name_java)
4844 TYPE_FOR_JAVA (type) = 1;
4846 tdef = create_implicit_typedef (name, type);
4847 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4848 if (scope == ts_within_enclosing_non_class)
4850 /* This is a friend. Make this TYPE_DECL node hidden from
4851 ordinary name lookup. Its corresponding TEMPLATE_DECL
4852 will be marked in push_template_decl_real. */
4853 retrofit_lang_decl (tdef);
4854 DECL_ANTICIPATED (tdef) = 1;
4855 DECL_FRIEND_P (tdef) = 1;
4858 decl = maybe_process_template_type_declaration
4859 (type, scope == ts_within_enclosing_non_class, b);
4860 if (decl == error_mark_node)
4861 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4864 set_identifier_type_value_with_scope (name, tdef, b);
4866 if (b->kind == sk_class)
4868 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4869 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4870 class. But if it's a member template class, we want
4871 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4873 finish_member_declaration (decl);
4875 pushdecl_class_level (decl);
4877 else if (b->kind != sk_template_parms)
4878 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4880 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4882 /* If this is a local class, keep track of it. We need this
4883 information for name-mangling, and so that it is possible to
4884 find all function definitions in a translation unit in a
4885 convenient way. (It's otherwise tricky to find a member
4886 function definition it's only pointed to from within a local
4888 if (TYPE_CONTEXT (type)
4889 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4890 VEC_safe_push (tree, gc, local_classes, type);
4892 if (b->kind == sk_class
4893 && !COMPLETE_TYPE_P (current_class_type))
4895 maybe_add_class_template_decl_list (current_class_type,
4896 type, /*friend_p=*/0);
4898 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4899 CLASSTYPE_NESTED_UTDS (current_class_type)
4900 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4902 binding_table_insert
4903 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4906 decl = TYPE_NAME (type);
4907 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4908 TYPE_STUB_DECL (type) = decl;
4910 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4913 /* Subroutines for reverting temporarily to top-level for instantiation
4914 of templates and such. We actually need to clear out the class- and
4915 local-value slots of all identifiers, so that only the global values
4916 are at all visible. Simply setting current_binding_level to the global
4917 scope isn't enough, because more binding levels may be pushed. */
4918 struct saved_scope *scope_chain;
4920 /* If ID has not already been marked, add an appropriate binding to
4924 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4926 cxx_saved_binding *saved;
4928 if (!id || !IDENTIFIER_BINDING (id))
4931 if (IDENTIFIER_MARKED (id))
4934 IDENTIFIER_MARKED (id) = 1;
4936 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4937 saved->identifier = id;
4938 saved->binding = IDENTIFIER_BINDING (id);
4939 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4940 IDENTIFIER_BINDING (id) = NULL;
4944 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4948 timevar_push (TV_NAME_LOOKUP);
4949 for (t = names; t; t = TREE_CHAIN (t))
4953 if (TREE_CODE (t) == TREE_LIST)
4954 id = TREE_PURPOSE (t);
4958 store_binding (id, old_bindings);
4960 timevar_pop (TV_NAME_LOOKUP);
4963 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4964 objects, rather than a TREE_LIST. */
4967 store_class_bindings (VEC(cp_class_binding,gc) *names,
4968 VEC(cxx_saved_binding,gc) **old_bindings)
4971 cp_class_binding *cb;
4973 timevar_push (TV_NAME_LOOKUP);
4974 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4975 store_binding (cb->identifier, old_bindings);
4976 timevar_pop (TV_NAME_LOOKUP);
4980 push_to_top_level (void)
4982 struct saved_scope *s;
4983 struct cp_binding_level *b;
4984 cxx_saved_binding *sb;
4988 timevar_push (TV_NAME_LOOKUP);
4989 s = GGC_CNEW (struct saved_scope);
4991 b = scope_chain ? current_binding_level : 0;
4993 /* If we're in the middle of some function, save our state. */
4997 push_function_context_to (NULL_TREE);
5002 if (scope_chain && previous_class_level)
5003 store_class_bindings (previous_class_level->class_shadowed,
5006 /* Have to include the global scope, because class-scope decls
5007 aren't listed anywhere useful. */
5008 for (; b; b = b->level_chain)
5012 /* Template IDs are inserted into the global level. If they were
5013 inserted into namespace level, finish_file wouldn't find them
5014 when doing pending instantiations. Therefore, don't stop at
5015 namespace level, but continue until :: . */
5016 if (global_scope_p (b))
5019 store_bindings (b->names, &s->old_bindings);
5020 /* We also need to check class_shadowed to save class-level type
5021 bindings, since pushclass doesn't fill in b->names. */
5022 if (b->kind == sk_class)
5023 store_class_bindings (b->class_shadowed, &s->old_bindings);
5025 /* Unwind type-value slots back to top level. */
5026 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5027 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5030 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5031 IDENTIFIER_MARKED (sb->identifier) = 0;
5033 s->prev = scope_chain;
5035 s->need_pop_function_context = need_pop;
5036 s->function_decl = current_function_decl;
5037 s->skip_evaluation = skip_evaluation;
5040 current_function_decl = NULL_TREE;
5041 current_lang_base = VEC_alloc (tree, gc, 10);
5042 current_lang_name = lang_name_cplusplus;
5043 current_namespace = global_namespace;
5044 push_class_stack ();
5045 skip_evaluation = 0;
5046 timevar_pop (TV_NAME_LOOKUP);
5050 pop_from_top_level (void)
5052 struct saved_scope *s = scope_chain;
5053 cxx_saved_binding *saved;
5056 timevar_push (TV_NAME_LOOKUP);
5057 /* Clear out class-level bindings cache. */
5058 if (previous_class_level)
5059 invalidate_class_lookup_cache ();
5062 current_lang_base = 0;
5064 scope_chain = s->prev;
5065 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5067 tree id = saved->identifier;
5069 IDENTIFIER_BINDING (id) = saved->binding;
5070 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5073 /* If we were in the middle of compiling a function, restore our
5075 if (s->need_pop_function_context)
5076 pop_function_context_from (NULL_TREE);
5077 current_function_decl = s->function_decl;
5078 skip_evaluation = s->skip_evaluation;
5079 timevar_pop (TV_NAME_LOOKUP);
5082 /* Pop off extraneous binding levels left over due to syntax errors.
5084 We don't pop past namespaces, as they might be valid. */
5087 pop_everything (void)
5089 if (ENABLE_SCOPE_CHECKING)
5090 verbatim ("XXX entering pop_everything ()\n");
5091 while (!toplevel_bindings_p ())
5093 if (current_binding_level->kind == sk_class)
5094 pop_nested_class ();
5098 if (ENABLE_SCOPE_CHECKING)
5099 verbatim ("XXX leaving pop_everything ()\n");
5102 /* Emit debugging information for using declarations and directives.
5103 If input tree is overloaded fn then emit debug info for all
5107 cp_emit_debug_info_for_using (tree t, tree context)
5109 /* Don't try to emit any debug information if we have errors. */
5110 if (sorrycount || errorcount)
5113 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5114 of a builtin function. */
5115 if (TREE_CODE (t) == FUNCTION_DECL
5116 && DECL_EXTERNAL (t)
5117 && DECL_BUILT_IN (t))
5120 /* Do not supply context to imported_module_or_decl, if
5121 it is a global namespace. */
5122 if (context == global_namespace)
5123 context = NULL_TREE;
5126 t = BASELINK_FUNCTIONS (t);
5128 /* FIXME: Handle TEMPLATE_DECLs. */
5129 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5130 if (TREE_CODE (t) != TEMPLATE_DECL)
5131 (*debug_hooks->imported_module_or_decl) (t, context);
5134 #include "gt-cp-name-lookup.h"