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 (name) == TEMPLATE_ID_EXPR)
606 name = TREE_OPERAND (name, 0);
608 /* In case this decl was explicitly namespace-qualified, look it
609 up in its namespace context. */
610 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
611 t = namespace_binding (name, DECL_CONTEXT (x));
613 t = lookup_name_innermost_nonclass_level (name);
615 /* [basic.link] If there is a visible declaration of an entity
616 with linkage having the same name and type, ignoring entities
617 declared outside the innermost enclosing namespace scope, the
618 block scope declaration declares that same entity and
619 receives the linkage of the previous declaration. */
620 if (! t && current_function_decl && x != current_function_decl
621 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
622 && DECL_EXTERNAL (x))
624 /* Look in block scope. */
625 t = innermost_non_namespace_value (name);
626 /* Or in the innermost namespace. */
628 t = namespace_binding (name, DECL_CONTEXT (x));
629 /* Does it have linkage? Note that if this isn't a DECL, it's an
630 OVERLOAD, which is OK. */
631 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
634 different_binding_level = 1;
637 /* If we are declaring a function, and the result of name-lookup
638 was an OVERLOAD, look for an overloaded instance that is
639 actually the same as the function we are declaring. (If
640 there is one, we have to merge our declaration with the
641 previous declaration.) */
642 if (t && TREE_CODE (t) == OVERLOAD)
646 if (TREE_CODE (x) == FUNCTION_DECL)
647 for (match = t; match; match = OVL_NEXT (match))
649 if (decls_match (OVL_CURRENT (match), x))
653 /* Just choose one. */
657 t = OVL_CURRENT (match);
662 if (t && t != error_mark_node)
664 if (different_binding_level)
666 if (decls_match (x, t))
667 /* The standard only says that the local extern
668 inherits linkage from the previous decl; in
669 particular, default args are not shared. We must
670 also tell cgraph to treat these decls as the same,
671 or we may neglect to emit an "unused" static - we
672 do this by making the DECL_UIDs equal, which should
673 be viewed as a kludge. FIXME. */
675 TREE_PUBLIC (x) = TREE_PUBLIC (t);
676 DECL_UID (x) = DECL_UID (t);
679 else if (TREE_CODE (t) == PARM_DECL)
681 gcc_assert (DECL_CONTEXT (t));
683 /* Check for duplicate params. */
684 if (duplicate_decls (x, t, is_friend))
685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
687 else if ((DECL_EXTERN_C_FUNCTION_P (x)
688 || DECL_FUNCTION_TEMPLATE_P (x))
689 && is_overloaded_fn (t))
690 /* Don't do anything just yet. */;
691 else if (t == wchar_decl_node)
693 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
694 pedwarn ("redeclaration of %<wchar_t%> as %qT",
697 /* Throw away the redeclaration. */
698 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
702 tree olddecl = duplicate_decls (x, t, is_friend);
704 /* If the redeclaration failed, we can stop at this
706 if (olddecl == error_mark_node)
707 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
711 if (TREE_CODE (t) == TYPE_DECL)
712 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
713 else if (TREE_CODE (t) == FUNCTION_DECL)
714 check_default_args (t);
716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
718 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
720 /* A redeclaration of main, but not a duplicate of the
725 This function shall not be overloaded. */
726 error ("invalid redeclaration of %q+D", t);
728 /* We don't try to push this declaration since that
730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
735 check_template_shadow (x);
737 /* If this is a function conjured up by the backend, massage it
738 so it looks friendly. */
739 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
741 retrofit_lang_decl (x);
742 SET_DECL_LANGUAGE (x, lang_c);
745 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
747 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
750 if (!namespace_bindings_p ())
751 /* We do not need to create a binding for this name;
752 push_overloaded_decl will have already done so if
754 need_new_binding = 0;
756 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
758 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
760 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
764 /* If declaring a type as a typedef, copy the type (unless we're
765 at line 0), and install this TYPE_DECL as the new type's typedef
766 name. See the extensive comment in ../c-decl.c (pushdecl). */
767 if (TREE_CODE (x) == TYPE_DECL)
769 tree type = TREE_TYPE (x);
770 if (DECL_IS_BUILTIN (x))
772 if (TYPE_NAME (type) == 0)
773 TYPE_NAME (type) = x;
775 else if (type != error_mark_node && TYPE_NAME (type) != x
776 /* We don't want to copy the type when all we're
777 doing is making a TYPE_DECL for the purposes of
779 && (!TYPE_NAME (type)
780 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
782 DECL_ORIGINAL_TYPE (x) = type;
783 type = build_variant_type_copy (type);
784 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
785 TYPE_NAME (type) = x;
786 TREE_TYPE (x) = type;
789 if (type != error_mark_node
791 && TYPE_IDENTIFIER (type))
792 set_identifier_type_value (DECL_NAME (x), x);
795 /* Multiple external decls of the same identifier ought to match.
797 We get warnings about inline functions where they are defined.
798 We get warnings about other functions from push_overloaded_decl.
800 Avoid duplicate warnings where they are used. */
801 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
805 decl = IDENTIFIER_NAMESPACE_VALUE (name);
806 if (decl && TREE_CODE (decl) == OVERLOAD)
807 decl = OVL_FUNCTION (decl);
809 if (decl && decl != error_mark_node
810 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
811 /* If different sort of thing, we already gave an error. */
812 && TREE_CODE (decl) == TREE_CODE (x)
813 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
815 pedwarn ("type mismatch with previous external decl of %q#D", x);
816 pedwarn ("previous external decl of %q+#D", decl);
820 if (TREE_CODE (x) == FUNCTION_DECL
822 && !flag_friend_injection)
824 /* This is a new declaration of a friend function, so hide
825 it from ordinary function lookup. */
826 DECL_ANTICIPATED (x) = 1;
827 DECL_HIDDEN_FRIEND_P (x) = 1;
830 /* This name is new in its binding level.
831 Install the new declaration and return it. */
832 if (namespace_bindings_p ())
834 /* Install a global value. */
836 /* If the first global decl has external linkage,
837 warn if we later see static one. */
838 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
839 TREE_PUBLIC (name) = 1;
841 /* Bind the name for the entity. */
842 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
844 && (TREE_CODE (x) == TYPE_DECL
845 || TREE_CODE (x) == VAR_DECL
846 || TREE_CODE (x) == NAMESPACE_DECL
847 || TREE_CODE (x) == CONST_DECL
848 || TREE_CODE (x) == TEMPLATE_DECL))
849 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
851 /* If new decl is `static' and an `extern' was seen previously,
853 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
854 warn_extern_redeclared_static (x, t);
858 /* Here to install a non-global value. */
859 tree oldlocal = innermost_non_namespace_value (name);
860 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
862 if (need_new_binding)
864 push_local_binding (name, x, 0);
865 /* Because push_local_binding will hook X on to the
866 current_binding_level's name list, we don't want to
867 do that again below. */
868 need_new_binding = 0;
871 /* If this is a TYPE_DECL, push it into the type value slot. */
872 if (TREE_CODE (x) == TYPE_DECL)
873 set_identifier_type_value (name, x);
875 /* Clear out any TYPE_DECL shadowed by a namespace so that
876 we won't think this is a type. The C struct hack doesn't
877 go through namespaces. */
878 if (TREE_CODE (x) == NAMESPACE_DECL)
879 set_identifier_type_value (name, NULL_TREE);
886 && TREE_CODE (oldlocal) == VAR_DECL
887 && DECL_DEAD_FOR_LOCAL (oldlocal))
888 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
890 if (oldlocal == NULL_TREE)
891 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
894 /* If this is an extern function declaration, see if we
895 have a global definition or declaration for the function. */
896 if (oldlocal == NULL_TREE
898 && oldglobal != NULL_TREE
899 && TREE_CODE (x) == FUNCTION_DECL
900 && TREE_CODE (oldglobal) == FUNCTION_DECL)
902 /* We have one. Their types must agree. */
903 if (decls_match (x, oldglobal))
907 warning (0, "extern declaration of %q#D doesn't match", x);
908 warning (0, "global declaration %q+#D", oldglobal);
911 /* If we have a local external declaration,
912 and no file-scope declaration has yet been seen,
913 then if we later have a file-scope decl it must not be static. */
914 if (oldlocal == NULL_TREE
915 && oldglobal == NULL_TREE
918 TREE_PUBLIC (name) = 1;
920 /* Warn if shadowing an argument at the top level of the body. */
921 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
922 /* Inline decls shadow nothing. */
923 && !DECL_FROM_INLINE (x)
924 && TREE_CODE (oldlocal) == PARM_DECL
925 /* Don't check the `this' parameter. */
926 && !DECL_ARTIFICIAL (oldlocal))
930 /* Don't complain if it's from an enclosing function. */
931 if (DECL_CONTEXT (oldlocal) == current_function_decl
932 && TREE_CODE (x) != PARM_DECL)
934 /* Go to where the parms should be and see if we find
936 struct cp_binding_level *b = current_binding_level->level_chain;
938 /* Skip the ctor/dtor cleanup level. */
942 if (b->kind == sk_function_parms)
944 error ("declaration of %q#D shadows a parameter", x);
949 if (warn_shadow && !err)
951 warning (0, "declaration of %q#D shadows a parameter", x);
952 warning (0, "%Jshadowed declaration is here", oldlocal);
956 /* Maybe warn if shadowing something else. */
957 else if (warn_shadow && !DECL_EXTERNAL (x)
958 /* No shadow warnings for internally generated vars. */
959 && ! DECL_ARTIFICIAL (x)
960 /* No shadow warnings for vars made for inlining. */
961 && ! DECL_FROM_INLINE (x))
965 if (current_class_ptr)
966 member = lookup_member (current_class_type,
969 /*want_type=*/false);
973 if (member && !TREE_STATIC (member))
975 /* Location of previous decl is not useful in this case. */
976 warning (0, "declaration of %qD shadows a member of 'this'",
979 else if (oldlocal != NULL_TREE
980 && TREE_CODE (oldlocal) == VAR_DECL)
982 warning (0, "declaration of %qD shadows a previous local", x);
983 warning (0, "%Jshadowed declaration is here", oldlocal);
985 else if (oldglobal != NULL_TREE
986 && TREE_CODE (oldglobal) == VAR_DECL)
987 /* XXX shadow warnings in outer-more namespaces */
989 warning (0, "declaration of %qD shadows a global declaration",
991 warning (0, "%Jshadowed declaration is here", oldglobal);
996 if (TREE_CODE (x) == FUNCTION_DECL)
997 check_default_args (x);
999 if (TREE_CODE (x) == VAR_DECL)
1000 maybe_register_incomplete_var (x);
1003 if (need_new_binding)
1004 add_decl_to_level (x,
1005 DECL_NAMESPACE_SCOPE_P (x)
1006 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1007 : current_binding_level);
1009 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1012 /* Record a decl-node X as belonging to the current lexical scope. */
1017 return pushdecl_maybe_friend (x, false);
1020 /* Enter DECL into the symbol table, if that's appropriate. Returns
1021 DECL, or a modified version thereof. */
1024 maybe_push_decl (tree decl)
1026 tree type = TREE_TYPE (decl);
1028 /* Add this decl to the current binding level, but not if it comes
1029 from another scope, e.g. a static member variable. TEM may equal
1030 DECL or it may be a previous decl of the same name. */
1031 if (decl == error_mark_node
1032 || (TREE_CODE (decl) != PARM_DECL
1033 && DECL_CONTEXT (decl) != NULL_TREE
1034 /* Definitions of namespace members outside their namespace are
1036 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1037 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1038 || TREE_CODE (type) == UNKNOWN_TYPE
1039 /* The declaration of a template specialization does not affect
1040 the functions available for overload resolution, so we do not
1042 || (TREE_CODE (decl) == FUNCTION_DECL
1043 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1046 return pushdecl (decl);
1049 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1050 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1051 doesn't really belong to this binding level, that it got here
1052 through a using-declaration. */
1055 push_local_binding (tree id, tree decl, int flags)
1057 struct cp_binding_level *b;
1059 /* Skip over any local classes. This makes sense if we call
1060 push_local_binding with a friend decl of a local class. */
1061 b = innermost_nonclass_level ();
1063 if (lookup_name_innermost_nonclass_level (id))
1065 /* Supplement the existing binding. */
1066 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1067 /* It didn't work. Something else must be bound at this
1068 level. Do not add DECL to the list of things to pop
1073 /* Create a new binding. */
1074 push_binding (id, decl, b);
1076 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1077 /* We must put the OVERLOAD into a TREE_LIST since the
1078 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1079 decls that got here through a using-declaration. */
1080 decl = build_tree_list (NULL_TREE, decl);
1082 /* And put DECL on the list of things declared by the current
1084 add_decl_to_level (decl, b);
1087 /* Check to see whether or not DECL is a variable that would have been
1088 in scope under the ARM, but is not in scope under the ANSI/ISO
1089 standard. If so, issue an error message. If name lookup would
1090 work in both cases, but return a different result, this function
1091 returns the result of ANSI/ISO lookup. Otherwise, it returns
1095 check_for_out_of_scope_variable (tree decl)
1099 /* We only care about out of scope variables. */
1100 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1103 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1104 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1105 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1106 && DECL_DEAD_FOR_LOCAL (shadowed))
1107 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1108 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1110 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1113 if (!DECL_ERROR_REPORTED (decl))
1115 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1116 warning (0, " matches this %q+D under ISO standard rules",
1118 warning (0, " matches this %q+D under old rules", decl);
1119 DECL_ERROR_REPORTED (decl) = 1;
1124 /* If we have already complained about this declaration, there's no
1125 need to do it again. */
1126 if (DECL_ERROR_REPORTED (decl))
1129 DECL_ERROR_REPORTED (decl) = 1;
1131 if (TREE_TYPE (decl) == error_mark_node)
1134 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1136 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1138 error (" cannot use obsolete binding at %q+D because "
1139 "it has a destructor", decl);
1140 return error_mark_node;
1144 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1146 pedwarn (" using obsolete binding at %q+D", decl);
1152 /* true means unconditionally make a BLOCK for the next level pushed. */
1154 static bool keep_next_level_flag;
1156 static int binding_depth = 0;
1157 static int is_class_level = 0;
1164 for (i = 0; i < depth * 2; i++)
1168 /* Return a string describing the kind of SCOPE we have. */
1170 cxx_scope_descriptor (cxx_scope *scope)
1172 /* The order of this table must match the "scope_kind"
1174 static const char* scope_kind_names[] = {
1180 "function-parameter-scope",
1183 "template-parameter-scope",
1184 "template-explicit-spec-scope"
1186 const scope_kind kind = scope->explicit_spec_p
1187 ? sk_template_spec : scope->kind;
1189 return scope_kind_names[kind];
1192 /* Output a debugging information about SCOPE when performing
1195 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1197 const char *desc = cxx_scope_descriptor (scope);
1198 if (scope->this_entity)
1199 verbatim ("%s %s(%E) %p %d\n", action, desc,
1200 scope->this_entity, (void *) scope, line);
1202 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1205 /* Return the estimated initial size of the hashtable of a NAMESPACE
1208 static inline size_t
1209 namespace_scope_ht_size (tree ns)
1211 tree name = DECL_NAME (ns);
1213 return name == std_identifier
1214 ? NAMESPACE_STD_HT_SIZE
1215 : (name == global_scope_name
1216 ? GLOBAL_SCOPE_HT_SIZE
1217 : NAMESPACE_ORDINARY_HT_SIZE);
1220 /* A chain of binding_level structures awaiting reuse. */
1222 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1224 /* Insert SCOPE as the innermost binding level. */
1227 push_binding_level (struct cp_binding_level *scope)
1229 /* Add it to the front of currently active scopes stack. */
1230 scope->level_chain = current_binding_level;
1231 current_binding_level = scope;
1232 keep_next_level_flag = false;
1234 if (ENABLE_SCOPE_CHECKING)
1236 scope->binding_depth = binding_depth;
1237 indent (binding_depth);
1238 cxx_scope_debug (scope, input_line, "push");
1244 /* Create a new KIND scope and make it the top of the active scopes stack.
1245 ENTITY is the scope of the associated C++ entity (namespace, class,
1246 function); it is NULL otherwise. */
1249 begin_scope (scope_kind kind, tree entity)
1253 /* Reuse or create a struct for this binding level. */
1254 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1256 scope = free_binding_level;
1257 free_binding_level = scope->level_chain;
1260 scope = GGC_NEW (cxx_scope);
1261 memset (scope, 0, sizeof (cxx_scope));
1263 scope->this_entity = entity;
1264 scope->more_cleanups_ok = true;
1271 case sk_template_spec:
1272 scope->explicit_spec_p = true;
1273 kind = sk_template_parms;
1275 case sk_template_parms:
1281 case sk_function_parms:
1282 scope->keep = keep_next_level_flag;
1286 NAMESPACE_LEVEL (entity) = scope;
1287 scope->static_decls =
1288 VEC_alloc (tree, gc,
1289 DECL_NAME (entity) == std_identifier
1290 || DECL_NAME (entity) == global_scope_name
1295 /* Should not happen. */
1301 push_binding_level (scope);
1306 /* We're about to leave current scope. Pop the top of the stack of
1307 currently active scopes. Return the enclosing scope, now active. */
1312 cxx_scope *scope = current_binding_level;
1314 if (scope->kind == sk_namespace && class_binding_level)
1315 current_binding_level = class_binding_level;
1317 /* We cannot leave a scope, if there are none left. */
1318 if (NAMESPACE_LEVEL (global_namespace))
1319 gcc_assert (!global_scope_p (scope));
1321 if (ENABLE_SCOPE_CHECKING)
1323 indent (--binding_depth);
1324 cxx_scope_debug (scope, input_line, "leave");
1325 if (is_class_level != (scope == class_binding_level))
1327 indent (binding_depth);
1328 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1333 /* Move one nesting level up. */
1334 current_binding_level = scope->level_chain;
1336 /* Namespace-scopes are left most probably temporarily, not
1337 completely; they can be reopen later, e.g. in namespace-extension
1338 or any name binding activity that requires us to resume a
1339 namespace. For classes, we cache some binding levels. For other
1340 scopes, we just make the structure available for reuse. */
1341 if (scope->kind != sk_namespace
1342 && scope->kind != sk_class)
1344 scope->level_chain = free_binding_level;
1345 gcc_assert (!ENABLE_SCOPE_CHECKING
1346 || scope->binding_depth == binding_depth);
1347 free_binding_level = scope;
1350 /* Find the innermost enclosing class scope, and reset
1351 CLASS_BINDING_LEVEL appropriately. */
1352 if (scope->kind == sk_class)
1354 class_binding_level = NULL;
1355 for (scope = current_binding_level; scope; scope = scope->level_chain)
1356 if (scope->kind == sk_class)
1358 class_binding_level = scope;
1363 return current_binding_level;
1367 resume_scope (struct cp_binding_level* b)
1369 /* Resuming binding levels is meant only for namespaces,
1370 and those cannot nest into classes. */
1371 gcc_assert (!class_binding_level);
1372 /* Also, resuming a non-directly nested namespace is a no-no. */
1373 gcc_assert (b->level_chain == current_binding_level);
1374 current_binding_level = b;
1375 if (ENABLE_SCOPE_CHECKING)
1377 b->binding_depth = binding_depth;
1378 indent (binding_depth);
1379 cxx_scope_debug (b, input_line, "resume");
1385 /* Return the innermost binding level that is not for a class scope. */
1388 innermost_nonclass_level (void)
1392 b = current_binding_level;
1393 while (b->kind == sk_class)
1399 /* We're defining an object of type TYPE. If it needs a cleanup, but
1400 we're not allowed to add any more objects with cleanups to the current
1401 scope, create a new binding level. */
1404 maybe_push_cleanup_level (tree type)
1406 if (type != error_mark_node
1407 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1408 && current_binding_level->more_cleanups_ok == 0)
1410 begin_scope (sk_cleanup, NULL);
1411 current_binding_level->statement_list = push_stmt_list ();
1415 /* Nonzero if we are currently in the global binding level. */
1418 global_bindings_p (void)
1420 return global_scope_p (current_binding_level);
1423 /* True if we are currently in a toplevel binding level. This
1424 means either the global binding level or a namespace in a toplevel
1425 binding level. Since there are no non-toplevel namespace levels,
1426 this really means any namespace or template parameter level. We
1427 also include a class whose context is toplevel. */
1430 toplevel_bindings_p (void)
1432 struct cp_binding_level *b = innermost_nonclass_level ();
1434 return b->kind == sk_namespace || b->kind == sk_template_parms;
1437 /* True if this is a namespace scope, or if we are defining a class
1438 which is itself at namespace scope, or whose enclosing class is
1439 such a class, etc. */
1442 namespace_bindings_p (void)
1444 struct cp_binding_level *b = innermost_nonclass_level ();
1446 return b->kind == sk_namespace;
1449 /* True if the current level needs to have a BLOCK made. */
1454 return (current_binding_level->blocks != NULL_TREE
1455 || current_binding_level->keep
1456 || current_binding_level->kind == sk_cleanup
1457 || current_binding_level->names != NULL_TREE);
1460 /* Returns the kind of the innermost scope. */
1463 innermost_scope_kind (void)
1465 return current_binding_level->kind;
1468 /* Returns true if this scope was created to store template parameters. */
1471 template_parm_scope_p (void)
1473 return innermost_scope_kind () == sk_template_parms;
1476 /* If KEEP is true, make a BLOCK node for the next binding level,
1477 unconditionally. Otherwise, use the normal logic to decide whether
1478 or not to create a BLOCK. */
1481 keep_next_level (bool keep)
1483 keep_next_level_flag = keep;
1486 /* Return the list of declarations of the current level.
1487 Note that this list is in reverse order unless/until
1488 you nreverse it; and when you do nreverse it, you must
1489 store the result back using `storedecls' or you will lose. */
1494 return current_binding_level->names;
1497 /* For debugging. */
1498 static int no_print_functions = 0;
1499 static int no_print_builtins = 0;
1502 print_binding_level (struct cp_binding_level* lvl)
1506 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1507 if (lvl->more_cleanups_ok)
1508 fprintf (stderr, " more-cleanups-ok");
1509 if (lvl->have_cleanups)
1510 fprintf (stderr, " have-cleanups");
1511 fprintf (stderr, "\n");
1514 fprintf (stderr, " names:\t");
1515 /* We can probably fit 3 names to a line? */
1516 for (t = lvl->names; t; t = TREE_CHAIN (t))
1518 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1520 if (no_print_builtins
1521 && (TREE_CODE (t) == TYPE_DECL)
1522 && DECL_IS_BUILTIN (t))
1525 /* Function decls tend to have longer names. */
1526 if (TREE_CODE (t) == FUNCTION_DECL)
1533 fprintf (stderr, "\n\t");
1536 print_node_brief (stderr, "", t, 0);
1537 if (t == error_mark_node)
1541 fprintf (stderr, "\n");
1543 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1546 cp_class_binding *b;
1547 fprintf (stderr, " class-shadowed:");
1549 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1551 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1552 fprintf (stderr, "\n");
1554 if (lvl->type_shadowed)
1556 fprintf (stderr, " type-shadowed:");
1557 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1559 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1561 fprintf (stderr, "\n");
1566 print_other_binding_stack (struct cp_binding_level *stack)
1568 struct cp_binding_level *level;
1569 for (level = stack; !global_scope_p (level); level = level->level_chain)
1571 fprintf (stderr, "binding level %p\n", (void *) level);
1572 print_binding_level (level);
1577 print_binding_stack (void)
1579 struct cp_binding_level *b;
1580 fprintf (stderr, "current_binding_level=%p\n"
1581 "class_binding_level=%p\n"
1582 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1583 (void *) current_binding_level, (void *) class_binding_level,
1584 (void *) NAMESPACE_LEVEL (global_namespace));
1585 if (class_binding_level)
1587 for (b = class_binding_level; b; b = b->level_chain)
1588 if (b == current_binding_level)
1591 b = class_binding_level;
1593 b = current_binding_level;
1596 b = current_binding_level;
1597 print_other_binding_stack (b);
1598 fprintf (stderr, "global:\n");
1599 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1602 /* Return the type associated with id. */
1605 identifier_type_value (tree id)
1607 timevar_push (TV_NAME_LOOKUP);
1608 /* There is no type with that name, anywhere. */
1609 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1610 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1611 /* This is not the type marker, but the real thing. */
1612 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1614 /* Have to search for it. It must be on the global level, now.
1615 Ask lookup_name not to return non-types. */
1616 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1618 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1622 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1623 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1626 identifier_global_value (tree t)
1628 return IDENTIFIER_GLOBAL_VALUE (t);
1631 /* Push a definition of struct, union or enum tag named ID. into
1632 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1633 the tag ID is not already defined. */
1636 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1640 if (b->kind != sk_namespace)
1642 /* Shadow the marker, not the real thing, so that the marker
1643 gets restored later. */
1644 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1646 = tree_cons (id, old_type_value, b->type_shadowed);
1647 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1648 TREE_TYPE (b->type_shadowed) = type;
1652 cxx_binding *binding =
1653 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1656 supplement_binding (binding, decl);
1658 binding->value = decl;
1660 /* Store marker instead of real type. */
1661 type = global_type_node;
1663 SET_IDENTIFIER_TYPE_VALUE (id, type);
1666 /* As set_identifier_type_value_with_scope, but using
1667 current_binding_level. */
1670 set_identifier_type_value (tree id, tree decl)
1672 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1675 /* Return the name for the constructor (or destructor) for the
1676 specified class TYPE. When given a template, this routine doesn't
1677 lose the specialization. */
1680 constructor_name_full (tree type)
1682 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1685 /* Return the name for the constructor (or destructor) for the
1686 specified class. When given a template, return the plain
1687 unspecialized name. */
1690 constructor_name (tree type)
1693 name = constructor_name_full (type);
1694 if (IDENTIFIER_TEMPLATE (name))
1695 name = IDENTIFIER_TEMPLATE (name);
1699 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1702 constructor_name_p (tree name, tree type)
1709 if (TREE_CODE (name) != IDENTIFIER_NODE)
1712 ctor_name = constructor_name_full (type);
1713 if (name == ctor_name)
1715 if (IDENTIFIER_TEMPLATE (ctor_name)
1716 && name == IDENTIFIER_TEMPLATE (ctor_name))
1721 /* Counter used to create anonymous type names. */
1723 static GTY(()) int anon_cnt;
1725 /* Return an IDENTIFIER which can be used as a name for
1726 anonymous structs and unions. */
1729 make_anon_name (void)
1733 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1734 return get_identifier (buf);
1737 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1739 static inline cxx_binding *
1740 find_binding (cxx_scope *scope, cxx_binding *binding)
1742 timevar_push (TV_NAME_LOOKUP);
1744 for (; binding != NULL; binding = binding->previous)
1745 if (binding->scope == scope)
1746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1751 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1753 static inline cxx_binding *
1754 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1756 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1759 /* Fold-in case where NAME is used only once. */
1760 if (scope == b->scope && b->previous == NULL)
1762 return find_binding (scope, b);
1767 /* Always returns a binding for name in scope. If no binding is
1768 found, make a new one. */
1770 static cxx_binding *
1771 binding_for_name (cxx_scope *scope, tree name)
1773 cxx_binding *result;
1775 result = cxx_scope_find_binding_for_name (scope, name);
1778 /* Not found, make a new one. */
1779 result = cxx_binding_make (NULL, NULL);
1780 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1781 result->scope = scope;
1782 result->is_local = false;
1783 result->value_is_inherited = false;
1784 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1788 /* Insert another USING_DECL into the current binding level, returning
1789 this declaration. If this is a redeclaration, do nothing, and
1790 return NULL_TREE if this not in namespace scope (in namespace
1791 scope, a using decl might extend any previous bindings). */
1794 push_using_decl (tree scope, tree name)
1798 timevar_push (TV_NAME_LOOKUP);
1799 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1800 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1801 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1802 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1805 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1806 namespace_bindings_p () ? decl : NULL_TREE);
1807 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1808 USING_DECL_SCOPE (decl) = scope;
1809 TREE_CHAIN (decl) = current_binding_level->usings;
1810 current_binding_level->usings = decl;
1811 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1814 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1815 caller to set DECL_CONTEXT properly. */
1818 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1820 struct cp_binding_level *b;
1821 tree function_decl = current_function_decl;
1823 timevar_push (TV_NAME_LOOKUP);
1824 current_function_decl = NULL_TREE;
1825 if (level->kind == sk_class)
1827 b = class_binding_level;
1828 class_binding_level = level;
1829 pushdecl_class_level (x);
1830 class_binding_level = b;
1834 b = current_binding_level;
1835 current_binding_level = level;
1836 x = pushdecl_maybe_friend (x, is_friend);
1837 current_binding_level = b;
1839 current_function_decl = function_decl;
1840 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1843 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1844 other definitions already in place. We get around this by making
1845 the value of the identifier point to a list of all the things that
1846 want to be referenced by that name. It is then up to the users of
1847 that name to decide what to do with that list.
1849 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1850 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1852 FLAGS is a bitwise-or of the following values:
1853 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1855 PUSH_USING: DECL is being pushed as the result of a using
1858 IS_FRIEND is true if this is a friend declaration.
1860 The value returned may be a previous declaration if we guessed wrong
1861 about what language DECL should belong to (C or C++). Otherwise,
1862 it's always DECL (and never something that's not a _DECL). */
1865 push_overloaded_decl (tree decl, int flags, bool is_friend)
1867 tree name = DECL_NAME (decl);
1870 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1872 timevar_push (TV_NAME_LOOKUP);
1874 old = namespace_binding (name, DECL_CONTEXT (decl));
1876 old = lookup_name_innermost_nonclass_level (name);
1880 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1882 tree t = TREE_TYPE (old);
1883 if (IS_AGGR_TYPE (t) && warn_shadow
1884 && (! DECL_IN_SYSTEM_HEADER (decl)
1885 || ! DECL_IN_SYSTEM_HEADER (old)))
1886 warning (0, "%q#D hides constructor for %q#T", decl, t);
1889 else if (is_overloaded_fn (old))
1893 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1895 tree fn = OVL_CURRENT (tmp);
1897 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1898 && !(flags & PUSH_USING)
1899 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1900 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1901 && ! decls_match (fn, decl))
1902 error ("%q#D conflicts with previous using declaration %q#D",
1905 if (duplicate_decls (decl, fn, is_friend) == fn)
1906 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
1909 /* We don't overload implicit built-ins. duplicate_decls()
1910 may fail to merge the decls if the new decl is e.g. a
1911 template function. */
1912 if (TREE_CODE (old) == FUNCTION_DECL
1913 && DECL_ANTICIPATED (old)
1914 && !DECL_HIDDEN_FRIEND_P (old))
1917 else if (old == error_mark_node)
1918 /* Ignore the undefined symbol marker. */
1922 error ("previous non-function declaration %q+#D", old);
1923 error ("conflicts with function declaration %q#D", decl);
1924 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1928 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1929 /* If it's a using declaration, we always need to build an OVERLOAD,
1930 because it's the only way to remember that the declaration comes
1931 from 'using', and have the lookup behave correctly. */
1932 || (flags & PUSH_USING))
1934 if (old && TREE_CODE (old) != OVERLOAD)
1935 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1937 new_binding = ovl_cons (decl, old);
1938 if (flags & PUSH_USING)
1939 OVL_USED (new_binding) = 1;
1942 /* NAME is not ambiguous. */
1946 set_namespace_binding (name, current_namespace, new_binding);
1949 /* We only create an OVERLOAD if there was a previous binding at
1950 this level, or if decl is a template. In the former case, we
1951 need to remove the old binding and replace it with the new
1952 binding. We must also run through the NAMES on the binding
1953 level where the name was bound to update the chain. */
1955 if (TREE_CODE (new_binding) == OVERLOAD && old)
1959 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1961 d = &TREE_CHAIN (*d))
1963 || (TREE_CODE (*d) == TREE_LIST
1964 && TREE_VALUE (*d) == old))
1966 if (TREE_CODE (*d) == TREE_LIST)
1967 /* Just replace the old binding with the new. */
1968 TREE_VALUE (*d) = new_binding;
1970 /* Build a TREE_LIST to wrap the OVERLOAD. */
1971 *d = tree_cons (NULL_TREE, new_binding,
1974 /* And update the cxx_binding node. */
1975 IDENTIFIER_BINDING (name)->value = new_binding;
1976 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1979 /* We should always find a previous binding in this case. */
1983 /* Install the new binding. */
1984 push_local_binding (name, new_binding, flags);
1987 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1990 /* Check a non-member using-declaration. Return the name and scope
1991 being used, and the USING_DECL, or NULL_TREE on failure. */
1994 validate_nonmember_using_decl (tree decl, tree scope, tree name)
1996 /* [namespace.udecl]
1997 A using-declaration for a class member shall be a
1998 member-declaration. */
2001 error ("%qT is not a namespace", scope);
2004 else if (scope == error_mark_node)
2007 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2010 A using-declaration shall not name a template-id. */
2011 error ("a using-declaration cannot specify a template-id. "
2012 "Try %<using %D%>", name);
2016 if (TREE_CODE (decl) == NAMESPACE_DECL)
2018 error ("namespace %qD not allowed in using-declaration", decl);
2022 if (TREE_CODE (decl) == SCOPE_REF)
2024 /* It's a nested name with template parameter dependent scope.
2025 This can only be using-declaration for class member. */
2026 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2030 if (is_overloaded_fn (decl))
2031 decl = get_first_fn (decl);
2033 gcc_assert (DECL_P (decl));
2035 /* Make a USING_DECL. */
2036 return push_using_decl (scope, name);
2039 /* Process local and global using-declarations. */
2042 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2043 tree *newval, tree *newtype)
2045 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2047 *newval = *newtype = NULL_TREE;
2048 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2052 if (!decls.value && !decls.type)
2054 error ("%qD not declared", name);
2058 /* It is impossible to overload a built-in function; any explicit
2059 declaration eliminates the built-in declaration. So, if OLDVAL
2060 is a built-in, then we can just pretend it isn't there. */
2062 && TREE_CODE (oldval) == FUNCTION_DECL
2063 && DECL_ANTICIPATED (oldval)
2064 && !DECL_HIDDEN_FRIEND_P (oldval))
2067 /* Check for using functions. */
2068 if (decls.value && is_overloaded_fn (decls.value))
2072 if (oldval && !is_overloaded_fn (oldval))
2074 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2075 error ("%qD is already declared in this scope", name);
2080 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2082 tree new_fn = OVL_CURRENT (tmp);
2084 /* [namespace.udecl]
2086 If a function declaration in namespace scope or block
2087 scope has the same name and the same parameter types as a
2088 function introduced by a using declaration the program is
2090 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2092 tree old_fn = OVL_CURRENT (tmp1);
2094 if (new_fn == old_fn)
2095 /* The function already exists in the current namespace. */
2097 else if (OVL_USED (tmp1))
2098 continue; /* this is a using decl */
2099 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2100 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2102 gcc_assert (!DECL_ANTICIPATED (old_fn)
2103 || DECL_HIDDEN_FRIEND_P (old_fn));
2105 /* There was already a non-using declaration in
2106 this scope with the same parameter types. If both
2107 are the same extern "C" functions, that's ok. */
2108 if (decls_match (new_fn, old_fn))
2112 error ("%qD is already declared in this scope", name);
2118 /* If we broke out of the loop, there's no reason to add
2119 this function to the using declarations for this
2124 /* If we are adding to an existing OVERLOAD, then we no
2125 longer know the type of the set of functions. */
2126 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2127 TREE_TYPE (*newval) = unknown_type_node;
2128 /* Add this new function to the set. */
2129 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2130 /* If there is only one function, then we use its type. (A
2131 using-declaration naming a single function can be used in
2132 contexts where overload resolution cannot be
2134 if (TREE_CODE (*newval) != OVERLOAD)
2136 *newval = ovl_cons (*newval, NULL_TREE);
2137 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2139 OVL_USED (*newval) = 1;
2144 *newval = decls.value;
2145 if (oldval && !decls_match (*newval, oldval))
2146 error ("%qD is already declared in this scope", name);
2149 *newtype = decls.type;
2150 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2152 error ("using declaration %qD introduced ambiguous type %qT",
2158 /* Process a using-declaration at function scope. */
2161 do_local_using_decl (tree decl, tree scope, tree name)
2163 tree oldval, oldtype, newval, newtype;
2164 tree orig_decl = decl;
2166 decl = validate_nonmember_using_decl (decl, scope, name);
2167 if (decl == NULL_TREE)
2170 if (building_stmt_tree ()
2171 && at_function_scope_p ())
2172 add_decl_expr (decl);
2174 oldval = lookup_name_innermost_nonclass_level (name);
2175 oldtype = lookup_type_current_level (name);
2177 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2181 if (is_overloaded_fn (newval))
2185 /* We only need to push declarations for those functions
2186 that were not already bound in the current level.
2187 The old value might be NULL_TREE, it might be a single
2188 function, or an OVERLOAD. */
2189 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2190 term = OVL_FUNCTION (oldval);
2193 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2195 push_overloaded_decl (OVL_CURRENT (fn),
2196 PUSH_LOCAL | PUSH_USING,
2200 push_local_binding (name, newval, PUSH_USING);
2204 push_local_binding (name, newtype, PUSH_USING);
2205 set_identifier_type_value (name, newtype);
2208 /* Emit debug info. */
2209 if (!processing_template_decl)
2210 cp_emit_debug_info_for_using (orig_decl, current_scope());
2213 /* Returns true if ROOT (a namespace, class, or function) encloses
2214 CHILD. CHILD may be either a class type or a namespace. */
2217 is_ancestor (tree root, tree child)
2219 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2220 || TREE_CODE (root) == FUNCTION_DECL
2221 || CLASS_TYPE_P (root)));
2222 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2223 || CLASS_TYPE_P (child)));
2225 /* The global namespace encloses everything. */
2226 if (root == global_namespace)
2231 /* If we've run out of scopes, stop. */
2234 /* If we've reached the ROOT, it encloses CHILD. */
2237 /* Go out one level. */
2239 child = TYPE_NAME (child);
2240 child = DECL_CONTEXT (child);
2244 /* Enter the class or namespace scope indicated by T suitable for name
2245 lookup. T can be arbitrary scope, not necessary nested inside the
2246 current scope. Returns a non-null scope to pop iff pop_scope
2247 should be called later to exit this scope. */
2252 if (TREE_CODE (t) == NAMESPACE_DECL)
2253 push_decl_namespace (t);
2254 else if (CLASS_TYPE_P (t))
2256 if (!at_class_scope_p ()
2257 || !same_type_p (current_class_type, t))
2258 push_nested_class (t);
2260 /* T is the same as the current scope. There is therefore no
2261 need to re-enter the scope. Since we are not actually
2262 pushing a new scope, our caller should not call
2270 /* Leave scope pushed by push_scope. */
2275 if (TREE_CODE (t) == NAMESPACE_DECL)
2276 pop_decl_namespace ();
2277 else if CLASS_TYPE_P (t)
2278 pop_nested_class ();
2281 /* Subroutine of push_inner_scope. */
2284 push_inner_scope_r (tree outer, tree inner)
2289 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2292 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2294 push_inner_scope_r (outer, prev);
2295 if (TREE_CODE (inner) == NAMESPACE_DECL)
2297 struct cp_binding_level *save_template_parm = 0;
2298 /* Temporary take out template parameter scopes. They are saved
2299 in reversed order in save_template_parm. */
2300 while (current_binding_level->kind == sk_template_parms)
2302 struct cp_binding_level *b = current_binding_level;
2303 current_binding_level = b->level_chain;
2304 b->level_chain = save_template_parm;
2305 save_template_parm = b;
2308 resume_scope (NAMESPACE_LEVEL (inner));
2309 current_namespace = inner;
2311 /* Restore template parameter scopes. */
2312 while (save_template_parm)
2314 struct cp_binding_level *b = save_template_parm;
2315 save_template_parm = b->level_chain;
2316 b->level_chain = current_binding_level;
2317 current_binding_level = b;
2324 /* Enter the scope INNER from current scope. INNER must be a scope
2325 nested inside current scope. This works with both name lookup and
2326 pushing name into scope. In case a template parameter scope is present,
2327 namespace is pushed under the template parameter scope according to
2328 name lookup rule in 14.6.1/6.
2330 Return the former current scope suitable for pop_inner_scope. */
2333 push_inner_scope (tree inner)
2335 tree outer = current_scope ();
2337 outer = current_namespace;
2339 push_inner_scope_r (outer, inner);
2343 /* Exit the current scope INNER back to scope OUTER. */
2346 pop_inner_scope (tree outer, tree inner)
2349 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2352 while (outer != inner)
2354 if (TREE_CODE (inner) == NAMESPACE_DECL)
2356 struct cp_binding_level *save_template_parm = 0;
2357 /* Temporary take out template parameter scopes. They are saved
2358 in reversed order in save_template_parm. */
2359 while (current_binding_level->kind == sk_template_parms)
2361 struct cp_binding_level *b = current_binding_level;
2362 current_binding_level = b->level_chain;
2363 b->level_chain = save_template_parm;
2364 save_template_parm = b;
2369 /* Restore template parameter scopes. */
2370 while (save_template_parm)
2372 struct cp_binding_level *b = save_template_parm;
2373 save_template_parm = b->level_chain;
2374 b->level_chain = current_binding_level;
2375 current_binding_level = b;
2381 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2385 /* Do a pushlevel for class declarations. */
2388 pushlevel_class (void)
2390 if (ENABLE_SCOPE_CHECKING)
2393 class_binding_level = begin_scope (sk_class, current_class_type);
2396 /* ...and a poplevel for class declarations. */
2399 poplevel_class (void)
2401 struct cp_binding_level *level = class_binding_level;
2402 cp_class_binding *cb;
2406 timevar_push (TV_NAME_LOOKUP);
2407 gcc_assert (level != 0);
2409 /* If we're leaving a toplevel class, cache its binding level. */
2410 if (current_class_depth == 1)
2411 previous_class_level = level;
2412 for (shadowed = level->type_shadowed;
2414 shadowed = TREE_CHAIN (shadowed))
2415 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2417 /* Remove the bindings for all of the class-level declarations. */
2418 if (level->class_shadowed)
2421 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2423 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2424 ggc_free (level->class_shadowed);
2425 level->class_shadowed = NULL;
2428 /* Now, pop out of the binding level which we created up in the
2429 `pushlevel_class' routine. */
2430 if (ENABLE_SCOPE_CHECKING)
2434 timevar_pop (TV_NAME_LOOKUP);
2437 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2438 appropriate. DECL is the value to which a name has just been
2439 bound. CLASS_TYPE is the class in which the lookup occurred. */
2442 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2445 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2449 if (TREE_CODE (decl) == OVERLOAD)
2450 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2453 gcc_assert (DECL_P (decl));
2454 context = context_for_name_lookup (decl);
2457 if (is_properly_derived_from (class_type, context))
2458 INHERITED_VALUE_BINDING_P (binding) = 1;
2460 INHERITED_VALUE_BINDING_P (binding) = 0;
2462 else if (binding->value == decl)
2463 /* We only encounter a TREE_LIST when there is an ambiguity in the
2464 base classes. Such an ambiguity can be overridden by a
2465 definition in this class. */
2466 INHERITED_VALUE_BINDING_P (binding) = 1;
2468 INHERITED_VALUE_BINDING_P (binding) = 0;
2471 /* Make the declaration of X appear in CLASS scope. */
2474 pushdecl_class_level (tree x)
2477 bool is_valid = true;
2479 timevar_push (TV_NAME_LOOKUP);
2480 /* Get the name of X. */
2481 if (TREE_CODE (x) == OVERLOAD)
2482 name = DECL_NAME (get_first_fn (x));
2484 name = DECL_NAME (x);
2488 is_valid = push_class_level_binding (name, x);
2489 if (TREE_CODE (x) == TYPE_DECL)
2490 set_identifier_type_value (name, x);
2492 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2494 /* If X is an anonymous aggregate, all of its members are
2495 treated as if they were members of the class containing the
2496 aggregate, for naming purposes. */
2499 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2501 location_t save_location = input_location;
2502 input_location = DECL_SOURCE_LOCATION (f);
2503 if (!pushdecl_class_level (f))
2505 input_location = save_location;
2508 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2511 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2512 scope. If the value returned is non-NULL, and the PREVIOUS field
2513 is not set, callers must set the PREVIOUS field explicitly. */
2515 static cxx_binding *
2516 get_class_binding (tree name, cxx_scope *scope)
2521 cxx_binding *binding;
2523 class_type = scope->this_entity;
2525 /* Get the type binding. */
2526 type_binding = lookup_member (class_type, name,
2527 /*protect=*/2, /*want_type=*/true);
2528 /* Get the value binding. */
2529 value_binding = lookup_member (class_type, name,
2530 /*protect=*/2, /*want_type=*/false);
2533 && (TREE_CODE (value_binding) == TYPE_DECL
2534 || DECL_CLASS_TEMPLATE_P (value_binding)
2535 || (TREE_CODE (value_binding) == TREE_LIST
2536 && TREE_TYPE (value_binding) == error_mark_node
2537 && (TREE_CODE (TREE_VALUE (value_binding))
2539 /* We found a type binding, even when looking for a non-type
2540 binding. This means that we already processed this binding
2543 else if (value_binding)
2545 if (TREE_CODE (value_binding) == TREE_LIST
2546 && TREE_TYPE (value_binding) == error_mark_node)
2547 /* NAME is ambiguous. */
2549 else if (BASELINK_P (value_binding))
2550 /* NAME is some overloaded functions. */
2551 value_binding = BASELINK_FUNCTIONS (value_binding);
2554 /* If we found either a type binding or a value binding, create a
2555 new binding object. */
2556 if (type_binding || value_binding)
2558 binding = new_class_binding (name,
2562 /* This is a class-scope binding, not a block-scope binding. */
2563 LOCAL_BINDING_P (binding) = 0;
2564 set_inherited_value_binding_p (binding, value_binding, class_type);
2572 /* Make the declaration(s) of X appear in CLASS scope under the name
2573 NAME. Returns true if the binding is valid. */
2576 push_class_level_binding (tree name, tree x)
2578 cxx_binding *binding;
2582 timevar_push (TV_NAME_LOOKUP);
2583 /* The class_binding_level will be NULL if x is a template
2584 parameter name in a member template. */
2585 if (!class_binding_level)
2586 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2588 /* Check for invalid member names. */
2589 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2590 /* We could have been passed a tree list if this is an ambiguous
2591 declaration. If so, pull the declaration out because
2592 check_template_shadow will not handle a TREE_LIST. */
2593 if (TREE_CODE (decl) == TREE_LIST
2594 && TREE_TYPE (decl) == error_mark_node)
2595 decl = TREE_VALUE (decl);
2597 check_template_shadow (decl);
2601 If T is the name of a class, then each of the following shall
2602 have a name different from T:
2604 -- every static data member of class T;
2606 -- every member of class T that is itself a type;
2608 -- every enumerator of every member of class T that is an
2611 -- every member of every anonymous union that is a member of
2614 (Non-static data members were also forbidden to have the same
2615 name as T until TC1.) */
2616 if ((TREE_CODE (x) == VAR_DECL
2617 || TREE_CODE (x) == CONST_DECL
2618 || (TREE_CODE (x) == TYPE_DECL
2619 && !DECL_SELF_REFERENCE_P (x))
2620 /* A data member of an anonymous union. */
2621 || (TREE_CODE (x) == FIELD_DECL
2622 && DECL_CONTEXT (x) != current_class_type))
2623 && DECL_NAME (x) == constructor_name (current_class_type))
2625 tree scope = context_for_name_lookup (x);
2626 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2628 error ("%qD has the same name as the class in which it is "
2631 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2635 /* Get the current binding for NAME in this class, if any. */
2636 binding = IDENTIFIER_BINDING (name);
2637 if (!binding || binding->scope != class_binding_level)
2639 binding = get_class_binding (name, class_binding_level);
2640 /* If a new binding was created, put it at the front of the
2641 IDENTIFIER_BINDING list. */
2644 binding->previous = IDENTIFIER_BINDING (name);
2645 IDENTIFIER_BINDING (name) = binding;
2649 /* If there is already a binding, then we may need to update the
2651 if (binding && binding->value)
2653 tree bval = binding->value;
2654 tree old_decl = NULL_TREE;
2656 if (INHERITED_VALUE_BINDING_P (binding))
2658 /* If the old binding was from a base class, and was for a
2659 tag name, slide it over to make room for the new binding.
2660 The old binding is still visible if explicitly qualified
2661 with a class-key. */
2662 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2663 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2665 old_decl = binding->type;
2666 binding->type = bval;
2667 binding->value = NULL_TREE;
2668 INHERITED_VALUE_BINDING_P (binding) = 0;
2673 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2675 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2676 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2677 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2679 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2680 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2682 if (old_decl && binding->scope == class_binding_level)
2685 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2686 here. This function is only used to register bindings
2687 from with the class definition itself. */
2688 INHERITED_VALUE_BINDING_P (binding) = 0;
2689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2693 /* Note that we declared this value so that we can issue an error if
2694 this is an invalid redeclaration of a name already used for some
2696 note_name_declared_in_class (name, decl);
2698 /* If we didn't replace an existing binding, put the binding on the
2699 stack of bindings for the identifier, and update the shadowed
2701 if (binding && binding->scope == class_binding_level)
2702 /* Supplement the existing binding. */
2703 ok = supplement_binding (binding, decl);
2706 /* Create a new binding. */
2707 push_binding (name, decl, class_binding_level);
2711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2714 /* Process "using SCOPE::NAME" in a class scope. Return the
2715 USING_DECL created. */
2718 do_class_using_decl (tree scope, tree name)
2720 tree value, decl, binfo;
2724 if (!scope || !TYPE_P (scope))
2726 error ("using-declaration for non-member at class scope");
2730 /* Make sure the scope is a base. */
2731 dependent_p = dependent_type_p (scope);
2733 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2737 if (same_type_p (current_class_type, scope))
2738 b_kind = bk_same_type;
2740 b_kind = bk_proper_base;
2743 if (b_kind < bk_proper_base)
2745 error_not_base_type (scope, current_class_type);
2749 /* Make sure the name is not invalid */
2750 if (TREE_CODE (name) == BIT_NOT_EXPR)
2752 error ("%<%T::%D%> names destructor", scope, name);
2755 if (constructor_name_p (name, scope))
2757 error ("%<%T::%D%> names constructor", scope, name);
2760 if (constructor_name_p (name, current_class_type))
2762 error ("%<%T::%D%> names constructor in %qT",
2763 scope, name, current_class_type);
2768 && IDENTIFIER_OPNAME_P (name) && dependent_type_p (TREE_TYPE (name)))
2771 /* See if there are any members of the base. */
2774 decl = lookup_member (binfo, name, 0, false);
2778 error ("no members matching %<%T::%D%> in %q#T", scope, name, scope);
2782 if (BASELINK_P (decl))
2783 /* Ignore base type this came from. */
2784 decl = BASELINK_FUNCTIONS (decl);
2789 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2790 USING_DECL_DECLS (value) = decl;
2791 USING_DECL_SCOPE (value) = scope;
2792 DECL_DEPENDENT_P (value) = dependent_p;
2798 /* Return the binding value for name in scope. */
2801 namespace_binding (tree name, tree scope)
2803 cxx_binding *binding;
2806 scope = global_namespace;
2808 /* Unnecessary for the global namespace because it can't be an alias. */
2809 scope = ORIGINAL_NAMESPACE (scope);
2811 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2813 return binding ? binding->value : NULL_TREE;
2816 /* Set the binding value for name in scope. */
2819 set_namespace_binding (tree name, tree scope, tree val)
2823 timevar_push (TV_NAME_LOOKUP);
2824 if (scope == NULL_TREE)
2825 scope = global_namespace;
2826 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2827 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2830 supplement_binding (b, val);
2831 timevar_pop (TV_NAME_LOOKUP);
2834 /* Set the context of a declaration to scope. Complain if we are not
2838 set_decl_namespace (tree decl, tree scope, bool friendp)
2842 /* Get rid of namespace aliases. */
2843 scope = ORIGINAL_NAMESPACE (scope);
2845 /* It is ok for friends to be qualified in parallel space. */
2846 if (!friendp && !is_ancestor (current_namespace, scope))
2847 error ("declaration of %qD not in a namespace surrounding %qD",
2849 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2851 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2852 if (scope == current_namespace)
2854 if (at_namespace_scope_p ())
2855 error ("explicit qualification in declaration of %qD",
2860 /* See whether this has been declared in the namespace. */
2861 old = namespace_binding (DECL_NAME (decl), scope);
2863 /* No old declaration at all. */
2865 /* A template can be explicitly specialized in any namespace. */
2866 if (processing_explicit_instantiation)
2868 if (!is_overloaded_fn (decl))
2869 /* Don't compare non-function decls with decls_match here, since
2870 it can't check for the correct constness at this
2871 point. pushdecl will find those errors later. */
2873 /* Since decl is a function, old should contain a function decl. */
2874 if (!is_overloaded_fn (old))
2876 if (processing_template_decl || processing_specialization)
2877 /* We have not yet called push_template_decl to turn a
2878 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2879 match. But, we'll check later, when we construct the
2882 if (is_overloaded_fn (old))
2884 for (; old; old = OVL_NEXT (old))
2885 if (decls_match (decl, OVL_CURRENT (old)))
2888 else if (decls_match (decl, old))
2891 error ("%qD should have been declared inside %qD", decl, scope);
2894 /* Return the namespace where the current declaration is declared. */
2897 current_decl_namespace (void)
2900 /* If we have been pushed into a different namespace, use it. */
2901 if (decl_namespace_list)
2902 return TREE_PURPOSE (decl_namespace_list);
2904 if (current_class_type)
2905 result = decl_namespace_context (current_class_type);
2906 else if (current_function_decl)
2907 result = decl_namespace_context (current_function_decl);
2909 result = current_namespace;
2913 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2914 select a name that is unique to this compilation unit. */
2917 push_namespace (tree name)
2921 int implicit_use = 0;
2924 timevar_push (TV_NAME_LOOKUP);
2926 /* We should not get here if the global_namespace is not yet constructed
2927 nor if NAME designates the global namespace: The global scope is
2928 constructed elsewhere. */
2929 gcc_assert (global_namespace != NULL && name != global_scope_name);
2933 /* The name of anonymous namespace is unique for the translation
2935 if (!anonymous_namespace_name)
2936 anonymous_namespace_name = get_file_function_name ('N');
2937 name = anonymous_namespace_name;
2938 d = IDENTIFIER_NAMESPACE_VALUE (name);
2940 /* Reopening anonymous namespace. */
2946 /* Check whether this is an extended namespace definition. */
2947 d = IDENTIFIER_NAMESPACE_VALUE (name);
2948 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2951 if (DECL_NAMESPACE_ALIAS (d))
2953 error ("namespace alias %qD not allowed here, assuming %qD",
2954 d, DECL_NAMESPACE_ALIAS (d));
2955 d = DECL_NAMESPACE_ALIAS (d);
2962 /* Make a new namespace, binding the name to it. */
2963 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2964 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2968 /* Clear DECL_NAME for the benefit of debugging back ends. */
2969 SET_DECL_ASSEMBLER_NAME (d, name);
2970 DECL_NAME (d) = NULL_TREE;
2972 begin_scope (sk_namespace, d);
2975 resume_scope (NAMESPACE_LEVEL (d));
2978 do_using_directive (d);
2979 /* Enter the name space. */
2980 current_namespace = d;
2982 timevar_pop (TV_NAME_LOOKUP);
2985 /* Pop from the scope of the current namespace. */
2988 pop_namespace (void)
2990 gcc_assert (current_namespace != global_namespace);
2991 current_namespace = CP_DECL_CONTEXT (current_namespace);
2992 /* The binding level is not popped, as it might be re-opened later. */
2996 /* Push into the scope of the namespace NS, even if it is deeply
2997 nested within another namespace. */
3000 push_nested_namespace (tree ns)
3002 if (ns == global_namespace)
3003 push_to_top_level ();
3006 push_nested_namespace (CP_DECL_CONTEXT (ns));
3007 push_namespace (DECL_NAME (ns));
3011 /* Pop back from the scope of the namespace NS, which was previously
3012 entered with push_nested_namespace. */
3015 pop_nested_namespace (tree ns)
3017 timevar_push (TV_NAME_LOOKUP);
3018 while (ns != global_namespace)
3021 ns = CP_DECL_CONTEXT (ns);
3024 pop_from_top_level ();
3025 timevar_pop (TV_NAME_LOOKUP);
3028 /* Temporarily set the namespace for the current declaration. */
3031 push_decl_namespace (tree decl)
3033 if (TREE_CODE (decl) != NAMESPACE_DECL)
3034 decl = decl_namespace_context (decl);
3035 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3036 NULL_TREE, decl_namespace_list);
3039 /* [namespace.memdef]/2 */
3042 pop_decl_namespace (void)
3044 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3047 /* Return the namespace that is the common ancestor
3048 of two given namespaces. */
3051 namespace_ancestor (tree ns1, tree ns2)
3053 timevar_push (TV_NAME_LOOKUP);
3054 if (is_ancestor (ns1, ns2))
3055 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3056 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3057 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3060 /* Process a namespace-alias declaration. */
3063 do_namespace_alias (tree alias, tree namespace)
3065 if (namespace == error_mark_node)
3068 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3070 namespace = ORIGINAL_NAMESPACE (namespace);
3072 /* Build the alias. */
3073 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3074 DECL_NAMESPACE_ALIAS (alias) = namespace;
3075 DECL_EXTERNAL (alias) = 1;
3076 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3079 /* Emit debug info for namespace alias. */
3080 (*debug_hooks->global_decl) (alias);
3083 /* Like pushdecl, only it places X in the current namespace,
3087 pushdecl_namespace_level (tree x, bool is_friend)
3089 struct cp_binding_level *b = current_binding_level;
3092 timevar_push (TV_NAME_LOOKUP);
3093 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3095 /* Now, the type_shadowed stack may screw us. Munge it so it does
3097 if (TREE_CODE (t) == TYPE_DECL)
3099 tree name = DECL_NAME (t);
3101 tree *ptr = (tree *)0;
3102 for (; !global_scope_p (b); b = b->level_chain)
3104 tree shadowed = b->type_shadowed;
3105 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3106 if (TREE_PURPOSE (shadowed) == name)
3108 ptr = &TREE_VALUE (shadowed);
3109 /* Can't break out of the loop here because sometimes
3110 a binding level will have duplicate bindings for
3111 PT names. It's gross, but I haven't time to fix it. */
3114 newval = TREE_TYPE (t);
3115 if (ptr == (tree *)0)
3117 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3118 up here if this is changed to an assertion. --KR */
3119 SET_IDENTIFIER_TYPE_VALUE (name, t);
3126 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3129 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3130 directive is not directly from the source. Also find the common
3131 ancestor and let our users know about the new namespace */
3133 add_using_namespace (tree user, tree used, bool indirect)
3136 timevar_push (TV_NAME_LOOKUP);
3137 /* Using oneself is a no-op. */
3140 timevar_pop (TV_NAME_LOOKUP);
3143 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3144 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3145 /* Check if we already have this. */
3146 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3150 /* Promote to direct usage. */
3151 TREE_INDIRECT_USING (t) = 0;
3152 timevar_pop (TV_NAME_LOOKUP);
3156 /* Add used to the user's using list. */
3157 DECL_NAMESPACE_USING (user)
3158 = tree_cons (used, namespace_ancestor (user, used),
3159 DECL_NAMESPACE_USING (user));
3161 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3163 /* Add user to the used's users list. */
3164 DECL_NAMESPACE_USERS (used)
3165 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3167 /* Recursively add all namespaces used. */
3168 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3169 /* indirect usage */
3170 add_using_namespace (user, TREE_PURPOSE (t), 1);
3172 /* Tell everyone using us about the new used namespaces. */
3173 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3174 add_using_namespace (TREE_PURPOSE (t), used, 1);
3175 timevar_pop (TV_NAME_LOOKUP);
3178 /* Process a using-declaration not appearing in class or local scope. */
3181 do_toplevel_using_decl (tree decl, tree scope, tree name)
3183 tree oldval, oldtype, newval, newtype;
3184 tree orig_decl = decl;
3185 cxx_binding *binding;
3187 decl = validate_nonmember_using_decl (decl, scope, name);
3188 if (decl == NULL_TREE)
3191 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3193 oldval = binding->value;
3194 oldtype = binding->type;
3196 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3198 /* Emit debug info. */
3199 if (!processing_template_decl)
3200 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3202 /* Copy declarations found. */
3204 binding->value = newval;
3206 binding->type = newtype;
3210 /* Process a using-directive. */
3213 do_using_directive (tree namespace)
3215 tree context = NULL_TREE;
3217 if (namespace == error_mark_node)
3220 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3222 if (building_stmt_tree ())
3223 add_stmt (build_stmt (USING_STMT, namespace));
3224 namespace = ORIGINAL_NAMESPACE (namespace);
3226 if (!toplevel_bindings_p ())
3228 push_using_directive (namespace);
3229 context = current_scope ();
3234 add_using_namespace (current_namespace, namespace, 0);
3235 if (current_namespace != global_namespace)
3236 context = current_namespace;
3239 /* Emit debugging info. */
3240 if (!processing_template_decl)
3241 (*debug_hooks->imported_module_or_decl) (namespace, context);
3244 /* Deal with a using-directive seen by the parser. Currently we only
3245 handle attributes here, since they cannot appear inside a template. */
3248 parse_using_directive (tree namespace, tree attribs)
3252 do_using_directive (namespace);
3254 for (a = attribs; a; a = TREE_CHAIN (a))
3256 tree name = TREE_PURPOSE (a);
3257 if (is_attribute_p ("strong", name))
3259 if (!toplevel_bindings_p ())
3260 error ("strong using only meaningful at namespace scope");
3261 else if (namespace != error_mark_node)
3262 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3263 = tree_cons (current_namespace, 0,
3264 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3267 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3271 /* Like pushdecl, only it places X in the global scope if appropriate.
3272 Calls cp_finish_decl to register the variable, initializing it with
3273 *INIT, if INIT is non-NULL. */
3276 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3278 timevar_push (TV_NAME_LOOKUP);
3279 push_to_top_level ();
3280 x = pushdecl_namespace_level (x, is_friend);
3282 cp_finish_decl (x, *init, NULL_TREE, 0);
3283 pop_from_top_level ();
3284 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3287 /* Like pushdecl, only it places X in the global scope if appropriate. */
3290 pushdecl_top_level (tree x)
3292 return pushdecl_top_level_1 (x, NULL, false);
3295 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3298 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3300 return pushdecl_top_level_1 (x, NULL, is_friend);
3303 /* Like pushdecl, only it places X in the global scope if
3304 appropriate. Calls cp_finish_decl to register the variable,
3305 initializing it with INIT. */
3308 pushdecl_top_level_and_finish (tree x, tree init)
3310 return pushdecl_top_level_1 (x, &init, false);
3313 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3314 duplicates. The first list becomes the tail of the result.
3316 The algorithm is O(n^2). We could get this down to O(n log n) by
3317 doing a sort on the addresses of the functions, if that becomes
3321 merge_functions (tree s1, tree s2)
3323 for (; s2; s2 = OVL_NEXT (s2))
3325 tree fn2 = OVL_CURRENT (s2);
3328 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3330 tree fn1 = OVL_CURRENT (fns1);
3332 /* If the function from S2 is already in S1, there is no
3333 need to add it again. For `extern "C"' functions, we
3334 might have two FUNCTION_DECLs for the same function, in
3335 different namespaces; again, we only need one of them. */
3337 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3338 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3342 /* If we exhausted all of the functions in S1, FN2 is new. */
3344 s1 = build_overload (fn2, s1);
3349 /* This should return an error not all definitions define functions.
3350 It is not an error if we find two functions with exactly the
3351 same signature, only if these are selected in overload resolution.
3352 old is the current set of bindings, new the freshly-found binding.
3353 XXX Do we want to give *all* candidates in case of ambiguity?
3354 XXX In what way should I treat extern declarations?
3355 XXX I don't want to repeat the entire duplicate_decls here */
3358 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3362 gcc_assert (old != NULL);
3363 /* Copy the value. */
3366 switch (TREE_CODE (val))
3369 /* If we expect types or namespaces, and not templates,
3370 or this is not a template class. */
3371 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3372 && !DECL_CLASS_TEMPLATE_P (val))
3373 || hidden_name_p (val))
3377 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3380 case NAMESPACE_DECL:
3381 if (LOOKUP_TYPES_ONLY (flags))
3385 /* Ignore built-in functions that are still anticipated. */
3386 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3390 if (LOOKUP_QUALIFIERS_ONLY (flags))
3396 else if (val && val != old->value)
3398 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3399 old->value = merge_functions (old->value, val);
3402 /* Some declarations are functions, some are not. */
3403 if (flags & LOOKUP_COMPLAIN)
3405 /* If we've already given this error for this lookup,
3406 old->value is error_mark_node, so let's not
3407 repeat ourselves. */
3408 if (old->value != error_mark_node)
3410 error ("use of %qD is ambiguous", name);
3411 error (" first declared as %q+#D here", old->value);
3413 error (" also declared as %q+#D here", val);
3415 old->value = error_mark_node;
3418 /* ... and copy the type. */
3420 if (LOOKUP_NAMESPACES_ONLY (flags))
3424 else if (type && old->type != type)
3426 if (flags & LOOKUP_COMPLAIN)
3428 error ("%qD denotes an ambiguous type",name);
3429 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3430 error ("%J other type here", TYPE_MAIN_DECL (type));
3435 /* Return the declarations that are members of the namespace NS. */
3438 cp_namespace_decls (tree ns)
3440 return NAMESPACE_LEVEL (ns)->names;
3443 /* Combine prefer_type and namespaces_only into flags. */
3446 lookup_flags (int prefer_type, int namespaces_only)
3448 if (namespaces_only)
3449 return LOOKUP_PREFER_NAMESPACES;
3450 if (prefer_type > 1)
3451 return LOOKUP_PREFER_TYPES;
3452 if (prefer_type > 0)
3453 return LOOKUP_PREFER_BOTH;
3457 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3458 ignore it or not. Subroutine of lookup_name_real and
3459 lookup_type_scope. */
3462 qualify_lookup (tree val, int flags)
3464 if (val == NULL_TREE)
3466 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3468 if ((flags & LOOKUP_PREFER_TYPES)
3469 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3471 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3476 /* Given a lookup that returned VAL, decide if we want to ignore it or
3477 not based on DECL_ANTICIPATED. */
3480 hidden_name_p (tree val)
3483 && DECL_LANG_SPECIFIC (val)
3484 && DECL_ANTICIPATED (val))
3489 /* Remove any hidden friend functions from a possibly overloaded set
3493 remove_hidden_names (tree fns)
3498 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3500 else if (TREE_CODE (fns) == OVERLOAD)
3504 for (o = fns; o; o = OVL_NEXT (o))
3505 if (hidden_name_p (OVL_CURRENT (o)))
3511 for (o = fns; o; o = OVL_NEXT (o))
3512 if (!hidden_name_p (OVL_CURRENT (o)))
3513 n = build_overload (OVL_CURRENT (o), n);
3521 /* Look up NAME in the NAMESPACE. */
3524 lookup_namespace_name (tree namespace, tree name)
3527 tree template_id = NULL_TREE;
3528 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3530 timevar_push (TV_NAME_LOOKUP);
3531 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3533 if (TREE_CODE (name) == NAMESPACE_DECL)
3534 /* This happens for A::B<int> when B is a namespace. */
3535 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3536 else if (TREE_CODE (name) == TEMPLATE_DECL)
3538 /* This happens for A::B where B is a template, and there are no
3539 template arguments. */
3540 error ("invalid use of %qD", name);
3541 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3544 namespace = ORIGINAL_NAMESPACE (namespace);
3546 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3549 name = TREE_OPERAND (name, 0);
3550 if (TREE_CODE (name) == OVERLOAD)
3551 name = DECL_NAME (OVL_CURRENT (name));
3552 else if (DECL_P (name))
3553 name = DECL_NAME (name);
3556 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3558 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3563 val = binding.value;
3567 if (DECL_CLASS_TEMPLATE_P (val))
3568 val = lookup_template_class (val,
3569 TREE_OPERAND (template_id, 1),
3570 /*in_decl=*/NULL_TREE,
3571 /*context=*/NULL_TREE,
3572 /*entering_scope=*/0,
3573 tf_error | tf_warning);
3574 else if (DECL_FUNCTION_TEMPLATE_P (val)
3575 || TREE_CODE (val) == OVERLOAD)
3576 val = lookup_template_function (val,
3577 TREE_OPERAND (template_id, 1));
3580 error ("%<%D::%D%> is not a template", namespace, name);
3581 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3585 /* If we have a single function from a using decl, pull it out. */
3586 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3587 val = OVL_FUNCTION (val);
3589 /* Ignore built-in functions and friends that haven't been declared
3591 if (!val || !hidden_name_p (val))
3592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3595 error ("%qD undeclared in namespace %qD", name, namespace);
3596 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3599 /* Select the right _DECL from multiple choices. */
3602 select_decl (const struct scope_binding *binding, int flags)
3605 val = binding->value;
3607 timevar_push (TV_NAME_LOOKUP);
3608 if (LOOKUP_NAMESPACES_ONLY (flags))
3610 /* We are not interested in types. */
3611 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3612 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3616 /* If looking for a type, or if there is no non-type binding, select
3617 the value binding. */
3618 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3619 val = binding->type;
3620 /* Don't return non-types if we really prefer types. */
3621 else if (val && LOOKUP_TYPES_ONLY (flags)
3622 && ! DECL_DECLARES_TYPE_P (val))
3625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3628 /* Unscoped lookup of a global: iterate over current namespaces,
3629 considering using-directives. */
3632 unqualified_namespace_lookup (tree name, int flags)
3634 tree initial = current_decl_namespace ();
3635 tree scope = initial;
3637 struct cp_binding_level *level;
3638 tree val = NULL_TREE;
3639 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3641 timevar_push (TV_NAME_LOOKUP);
3643 for (; !val; scope = CP_DECL_CONTEXT (scope))
3646 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3650 if (b->value && hidden_name_p (b->value))
3651 /* Ignore anticipated built-in functions and friends. */
3654 binding.value = b->value;
3655 binding.type = b->type;
3658 /* Add all _DECLs seen through local using-directives. */
3659 for (level = current_binding_level;
3660 level->kind != sk_namespace;
3661 level = level->level_chain)
3662 if (!lookup_using_namespace (name, &binding, level->using_directives,
3664 /* Give up because of error. */
3665 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3667 /* Add all _DECLs seen through global using-directives. */
3668 /* XXX local and global using lists should work equally. */
3672 if (!lookup_using_namespace (name, &binding,
3673 DECL_NAMESPACE_USING (siter),
3675 /* Give up because of error. */
3676 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3677 if (siter == scope) break;
3678 siter = CP_DECL_CONTEXT (siter);
3681 val = select_decl (&binding, flags);
3682 if (scope == global_namespace)
3685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3688 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3689 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3692 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3693 declaration found. If no suitable declaration can be found,
3694 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3695 neither a class-type nor a namespace a diagnostic is issued. */
3698 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3702 if (TREE_CODE (scope) == NAMESPACE_DECL)
3704 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3706 flags |= LOOKUP_COMPLAIN;
3708 flags |= LOOKUP_PREFER_TYPES;
3709 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3710 return select_decl (&binding, flags);
3712 else if (is_aggr_type (scope, complain))
3715 t = lookup_member (scope, name, 2, is_type_p);
3720 return error_mark_node;
3723 /* Subroutine of unqualified_namespace_lookup:
3724 Add the bindings of NAME in used namespaces to VAL.
3725 We are currently looking for names in namespace SCOPE, so we
3726 look through USINGS for using-directives of namespaces
3727 which have SCOPE as a common ancestor with the current scope.
3728 Returns false on errors. */
3731 lookup_using_namespace (tree name, struct scope_binding *val,
3732 tree usings, tree scope, int flags)
3735 timevar_push (TV_NAME_LOOKUP);
3736 /* Iterate over all used namespaces in current, searching for using
3737 directives of scope. */
3738 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3739 if (TREE_VALUE (iter) == scope)
3741 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3743 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3744 /* Resolve ambiguities. */
3746 ambiguous_decl (name, val, val1, flags);
3748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3752 Accepts the NAME to lookup and its qualifying SCOPE.
3753 Returns the name/type pair found into the cxx_binding *RESULT,
3754 or false on error. */
3757 qualified_lookup_using_namespace (tree name, tree scope,
3758 struct scope_binding *result, int flags)
3760 /* Maintain a list of namespaces visited... */
3761 tree seen = NULL_TREE;
3762 /* ... and a list of namespace yet to see. */
3763 tree todo = NULL_TREE;
3764 tree todo_maybe = NULL_TREE;
3766 timevar_push (TV_NAME_LOOKUP);
3767 /* Look through namespace aliases. */
3768 scope = ORIGINAL_NAMESPACE (scope);
3769 while (scope && result->value != error_mark_node)
3771 cxx_binding *binding =
3772 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3773 seen = tree_cons (scope, NULL_TREE, seen);
3775 ambiguous_decl (name, result, binding, flags);
3777 /* Consider strong using directives always, and non-strong ones
3778 if we haven't found a binding yet. ??? Shouldn't we consider
3779 non-strong ones if the initial RESULT is non-NULL, but the
3780 binding in the given namespace is? */
3781 for (usings = DECL_NAMESPACE_USING (scope); usings;
3782 usings = TREE_CHAIN (usings))
3783 /* If this was a real directive, and we have not seen it. */
3784 if (!TREE_INDIRECT_USING (usings))
3786 /* Try to avoid queuing the same namespace more than once,
3787 the exception being when a namespace was already
3788 enqueued for todo_maybe and then a strong using is
3789 found for it. We could try to remove it from
3790 todo_maybe, but it's probably not worth the effort. */
3791 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3792 && !purpose_member (TREE_PURPOSE (usings), seen)
3793 && !purpose_member (TREE_PURPOSE (usings), todo))
3794 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3795 else if ((!result->value && !result->type)
3796 && !purpose_member (TREE_PURPOSE (usings), seen)
3797 && !purpose_member (TREE_PURPOSE (usings), todo)
3798 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3799 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3804 scope = TREE_PURPOSE (todo);
3805 todo = TREE_CHAIN (todo);
3808 && (!result->value && !result->type))
3810 scope = TREE_PURPOSE (todo_maybe);
3811 todo = TREE_CHAIN (todo_maybe);
3812 todo_maybe = NULL_TREE;
3815 scope = NULL_TREE; /* If there never was a todo list. */
3817 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3820 /* Return the innermost non-namespace binding for NAME from a scope
3821 containing BINDING, or, if BINDING is NULL, the current scope. If
3822 CLASS_P is false, then class bindings are ignored. */
3825 outer_binding (tree name,
3826 cxx_binding *binding,
3831 cxx_scope *outer_scope;
3835 scope = binding->scope->level_chain;
3836 outer = binding->previous;
3840 scope = current_binding_level;
3841 outer = IDENTIFIER_BINDING (name);
3843 outer_scope = outer ? outer->scope : NULL;
3845 /* Because we create class bindings lazily, we might be missing a
3846 class binding for NAME. If there are any class binding levels
3847 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3848 declared, we must lookup NAME in those class scopes. */
3850 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3852 if (scope->kind == sk_class)
3854 cxx_binding *class_binding;
3856 class_binding = get_class_binding (name, scope);
3859 /* Thread this new class-scope binding onto the
3860 IDENTIFIER_BINDING list so that future lookups
3862 class_binding->previous = outer;
3864 binding->previous = class_binding;
3866 IDENTIFIER_BINDING (name) = class_binding;
3867 return class_binding;
3870 scope = scope->level_chain;
3876 /* Return the innermost block-scope or class-scope value binding for
3877 NAME, or NULL_TREE if there is no such binding. */
3880 innermost_non_namespace_value (tree name)
3882 cxx_binding *binding;
3883 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3884 return binding ? binding->value : NULL_TREE;
3887 /* Look up NAME in the current binding level and its superiors in the
3888 namespace of variables, functions and typedefs. Return a ..._DECL
3889 node of some kind representing its definition if there is only one
3890 such declaration, or return a TREE_LIST with all the overloaded
3891 definitions if there are many, or return 0 if it is undefined.
3892 Hidden name, either friend declaration or built-in function, are
3895 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3896 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3897 Otherwise we prefer non-TYPE_DECLs.
3899 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3900 BLOCK_P is false, bindings in block scopes are ignored. */
3903 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3904 int namespaces_only, int flags)
3907 tree val = NULL_TREE;
3909 timevar_push (TV_NAME_LOOKUP);
3910 /* Conversion operators are handled specially because ordinary
3911 unqualified name lookup will not find template conversion
3913 if (IDENTIFIER_TYPENAME_P (name))
3915 struct cp_binding_level *level;
3917 for (level = current_binding_level;
3918 level && level->kind != sk_namespace;
3919 level = level->level_chain)
3924 /* A conversion operator can only be declared in a class
3926 if (level->kind != sk_class)
3929 /* Lookup the conversion operator in the class. */
3930 class_type = level->this_entity;
3931 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3936 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3939 flags |= lookup_flags (prefer_type, namespaces_only);
3941 /* First, look in non-namespace scopes. */
3943 if (current_class_type == NULL_TREE)
3946 if (block_p || !nonclass)
3947 for (iter = outer_binding (name, NULL, !nonclass);
3949 iter = outer_binding (name, iter, !nonclass))
3953 /* Skip entities we don't want. */
3954 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3957 /* If this is the kind of thing we're looking for, we're done. */
3958 if (qualify_lookup (iter->value, flags)
3959 && !hidden_name_p (iter->value))
3960 binding = iter->value;
3961 else if ((flags & LOOKUP_PREFER_TYPES)
3962 && qualify_lookup (iter->type, flags)
3963 && !hidden_name_p (iter->type))
3964 binding = iter->type;
3966 binding = NULL_TREE;
3975 /* Now lookup in namespace scopes. */
3977 val = unqualified_namespace_lookup (name, flags);
3981 /* If we have a single function from a using decl, pull it out. */
3982 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3983 val = OVL_FUNCTION (val);
3986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3990 lookup_name_nonclass (tree name)
3992 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
3996 lookup_function_nonclass (tree name, tree args, bool block_p)
3999 lookup_arg_dependent (name,
4000 lookup_name_real (name, 0, 1, block_p, 0,
4006 lookup_name (tree name, int prefer_type)
4008 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4009 0, LOOKUP_COMPLAIN);
4012 /* Look up NAME for type used in elaborated name specifier in
4013 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4014 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4015 name, more scopes are checked if cleanup or template parameter
4016 scope is encountered.
4018 Unlike lookup_name_real, we make sure that NAME is actually
4019 declared in the desired scope, not from inheritance, nor using
4020 directive. For using declaration, there is DR138 still waiting
4021 to be resolved. Hidden name coming from an earlier friend
4022 declaration is also returned.
4024 A TYPE_DECL best matching the NAME is returned. Catching error
4025 and issuing diagnostics are caller's responsibility. */
4028 lookup_type_scope (tree name, tag_scope scope)
4030 cxx_binding *iter = NULL;
4031 tree val = NULL_TREE;
4033 timevar_push (TV_NAME_LOOKUP);
4035 /* Look in non-namespace scope first. */
4036 if (current_binding_level->kind != sk_namespace)
4037 iter = outer_binding (name, NULL, /*class_p=*/ true);
4038 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4040 /* Check if this is the kind of thing we're looking for.
4041 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4042 base class. For ITER->VALUE, we can simply use
4043 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4046 We check ITER->TYPE before ITER->VALUE in order to handle
4047 typedef struct C {} C;
4050 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4051 && (scope != ts_current
4052 || LOCAL_BINDING_P (iter)
4053 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4055 else if ((scope != ts_current
4056 || !INHERITED_VALUE_BINDING_P (iter))
4057 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4064 /* Look in namespace scope. */
4067 iter = cxx_scope_find_binding_for_name
4068 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4072 /* If this is the kind of thing we're looking for, we're done. */
4073 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4075 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4081 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4082 and template parameter scopes. */
4085 struct cp_binding_level *b = current_binding_level;
4088 if (iter->scope == b)
4089 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4091 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4093 else if (b->kind == sk_class
4094 && scope == ts_within_enclosing_non_class)
4101 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4104 /* Similar to `lookup_name' but look only in the innermost non-class
4108 lookup_name_innermost_nonclass_level (tree name)
4110 struct cp_binding_level *b;
4113 timevar_push (TV_NAME_LOOKUP);
4114 b = innermost_nonclass_level ();
4116 if (b->kind == sk_namespace)
4118 t = IDENTIFIER_NAMESPACE_VALUE (name);
4120 /* extern "C" function() */
4121 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4124 else if (IDENTIFIER_BINDING (name)
4125 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4127 cxx_binding *binding;
4128 binding = IDENTIFIER_BINDING (name);
4131 if (binding->scope == b
4132 && !(TREE_CODE (binding->value) == VAR_DECL
4133 && DECL_DEAD_FOR_LOCAL (binding->value)))
4134 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4136 if (b->kind == sk_cleanup)
4143 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4146 /* Like lookup_name_innermost_nonclass_level, but for types. */
4149 lookup_type_current_level (tree name)
4153 timevar_push (TV_NAME_LOOKUP);
4154 gcc_assert (current_binding_level->kind != sk_namespace);
4156 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4157 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4159 struct cp_binding_level *b = current_binding_level;
4162 if (purpose_member (name, b->type_shadowed))
4163 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4164 REAL_IDENTIFIER_TYPE_VALUE (name));
4165 if (b->kind == sk_cleanup)
4172 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4175 /* [basic.lookup.koenig] */
4176 /* A nonzero return value in the functions below indicates an error. */
4187 static bool arg_assoc (struct arg_lookup*, tree);
4188 static bool arg_assoc_args (struct arg_lookup*, tree);
4189 static bool arg_assoc_type (struct arg_lookup*, tree);
4190 static bool add_function (struct arg_lookup *, tree);
4191 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4192 static bool arg_assoc_class (struct arg_lookup *, tree);
4193 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4195 /* Add a function to the lookup structure.
4196 Returns true on error. */
4199 add_function (struct arg_lookup *k, tree fn)
4201 /* We used to check here to see if the function was already in the list,
4202 but that's O(n^2), which is just too expensive for function lookup.
4203 Now we deal with the occasional duplicate in joust. In doing this, we
4204 assume that the number of duplicates will be small compared to the
4205 total number of functions being compared, which should usually be the
4208 /* We must find only functions, or exactly one non-function. */
4211 else if (fn == k->functions)
4213 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4214 k->functions = build_overload (fn, k->functions);
4217 tree f1 = OVL_CURRENT (k->functions);
4219 if (is_overloaded_fn (f1))
4221 fn = f1; f1 = f2; f2 = fn;
4223 error ("%q+D is not a function,", f1);
4224 error (" conflict with %q+D", f2);
4225 error (" in call to %qD", k->name);
4232 /* Returns true iff CURRENT has declared itself to be an associated
4233 namespace of SCOPE via a strong using-directive (or transitive chain
4234 thereof). Both are namespaces. */
4237 is_associated_namespace (tree current, tree scope)
4239 tree seen = NULL_TREE;
4240 tree todo = NULL_TREE;
4244 if (scope == current)
4246 seen = tree_cons (scope, NULL_TREE, seen);
4247 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4248 if (!purpose_member (TREE_PURPOSE (t), seen))
4249 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4252 scope = TREE_PURPOSE (todo);
4253 todo = TREE_CHAIN (todo);
4260 /* Return whether FN is a friend of an associated class of ARG. */
4263 friend_of_associated_class_p (tree arg, tree fn)
4269 else if (type_unknown_p (arg))
4272 type = TREE_TYPE (arg);
4274 /* If TYPE is a class, the class itself and all base classes are
4275 associated classes. */
4276 if (CLASS_TYPE_P (type))
4278 if (is_friend (type, fn))
4281 if (TYPE_BINFO (type))
4283 tree binfo, base_binfo;
4286 for (binfo = TYPE_BINFO (type), i = 0;
4287 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4289 if (is_friend (BINFO_TYPE (base_binfo), fn))
4294 /* If TYPE is a class member, the class of which it is a member is
4295 an associated class. */
4296 if ((CLASS_TYPE_P (type)
4297 || TREE_CODE (type) == UNION_TYPE
4298 || TREE_CODE (type) == ENUMERAL_TYPE)
4299 && TYPE_CONTEXT (type)
4300 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4301 && is_friend (TYPE_CONTEXT (type), fn))
4307 /* Add functions of a namespace to the lookup structure.
4308 Returns true on error. */
4311 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4315 if (purpose_member (scope, k->namespaces))
4317 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4319 /* Check out our super-users. */
4320 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4321 value = TREE_CHAIN (value))
4322 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4325 value = namespace_binding (k->name, scope);
4329 for (; value; value = OVL_NEXT (value))
4331 /* We don't want to find arbitrary hidden functions via argument
4332 dependent lookup. We only want to find friends of associated
4334 if (hidden_name_p (OVL_CURRENT (value)))
4338 for (args = k->args; args; args = TREE_CHAIN (args))
4339 if (friend_of_associated_class_p (TREE_VALUE (args),
4340 OVL_CURRENT (value)))
4346 if (add_function (k, OVL_CURRENT (value)))
4353 /* Adds everything associated with a template argument to the lookup
4354 structure. Returns true on error. */
4357 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4359 /* [basic.lookup.koenig]
4361 If T is a template-id, its associated namespaces and classes are
4362 ... the namespaces and classes associated with the types of the
4363 template arguments provided for template type parameters
4364 (excluding template template parameters); the namespaces in which
4365 any template template arguments are defined; and the classes in
4366 which any member templates used as template template arguments
4367 are defined. [Note: non-type template arguments do not
4368 contribute to the set of associated namespaces. ] */
4370 /* Consider first template template arguments. */
4371 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4372 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4374 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4376 tree ctx = CP_DECL_CONTEXT (arg);
4378 /* It's not a member template. */
4379 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4380 return arg_assoc_namespace (k, ctx);
4381 /* Otherwise, it must be member template. */
4383 return arg_assoc_class (k, ctx);
4385 /* It's not a template template argument, but it is a type template
4387 else if (TYPE_P (arg))
4388 return arg_assoc_type (k, arg);
4389 /* It's a non-type template argument. */
4394 /* Adds everything associated with class to the lookup structure.
4395 Returns true on error. */
4398 arg_assoc_class (struct arg_lookup *k, tree type)
4400 tree list, friends, context;
4403 /* Backend build structures, such as __builtin_va_list, aren't
4404 affected by all this. */
4405 if (!CLASS_TYPE_P (type))
4408 if (purpose_member (type, k->classes))
4410 k->classes = tree_cons (type, NULL_TREE, k->classes);
4412 context = decl_namespace_context (type);
4413 if (arg_assoc_namespace (k, context))
4416 if (TYPE_BINFO (type))
4418 /* Process baseclasses. */
4419 tree binfo, base_binfo;
4421 for (binfo = TYPE_BINFO (type), i = 0;
4422 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4423 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4427 /* Process friends. */
4428 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4429 list = TREE_CHAIN (list))
4430 if (k->name == FRIEND_NAME (list))
4431 for (friends = FRIEND_DECLS (list); friends;
4432 friends = TREE_CHAIN (friends))
4434 tree fn = TREE_VALUE (friends);
4436 /* Only interested in global functions with potentially hidden
4437 (i.e. unqualified) declarations. */
4438 if (CP_DECL_CONTEXT (fn) != context)
4440 /* Template specializations are never found by name lookup.
4441 (Templates themselves can be found, but not template
4442 specializations.) */
4443 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4445 if (add_function (k, fn))
4449 /* Process template arguments. */
4450 if (CLASSTYPE_TEMPLATE_INFO (type)
4451 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4453 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4454 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4455 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4461 /* Adds everything associated with a given type.
4462 Returns 1 on error. */
4465 arg_assoc_type (struct arg_lookup *k, tree type)
4467 /* As we do not get the type of non-type dependent expressions
4468 right, we can end up with such things without a type. */
4472 if (TYPE_PTRMEM_P (type))
4474 /* Pointer to member: associate class type and value type. */
4475 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4477 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4479 else switch (TREE_CODE (type))
4492 if (TYPE_PTRMEMFUNC_P (type))
4493 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4494 return arg_assoc_class (k, type);
4496 case REFERENCE_TYPE:
4498 return arg_assoc_type (k, TREE_TYPE (type));
4501 return arg_assoc_namespace (k, decl_namespace_context (type));
4503 /* The basetype is referenced in the first arg type, so just
4506 /* Associate the parameter types. */
4507 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4509 /* Associate the return type. */
4510 return arg_assoc_type (k, TREE_TYPE (type));
4511 case TEMPLATE_TYPE_PARM:
4512 case BOUND_TEMPLATE_TEMPLATE_PARM:
4517 gcc_assert (type == unknown_type_node);
4525 /* Adds everything associated with arguments. Returns true on error. */
4528 arg_assoc_args (struct arg_lookup *k, tree args)
4530 for (; args; args = TREE_CHAIN (args))
4531 if (arg_assoc (k, TREE_VALUE (args)))
4536 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4539 arg_assoc (struct arg_lookup *k, tree n)
4541 if (n == error_mark_node)
4545 return arg_assoc_type (k, n);
4547 if (! type_unknown_p (n))
4548 return arg_assoc_type (k, TREE_TYPE (n));
4550 if (TREE_CODE (n) == ADDR_EXPR)
4551 n = TREE_OPERAND (n, 0);
4552 if (TREE_CODE (n) == COMPONENT_REF)
4553 n = TREE_OPERAND (n, 1);
4554 if (TREE_CODE (n) == OFFSET_REF)
4555 n = TREE_OPERAND (n, 1);
4556 while (TREE_CODE (n) == TREE_LIST)
4558 if (TREE_CODE (n) == BASELINK)
4559 n = BASELINK_FUNCTIONS (n);
4561 if (TREE_CODE (n) == FUNCTION_DECL)
4562 return arg_assoc_type (k, TREE_TYPE (n));
4563 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4565 /* [basic.lookup.koenig]
4567 If T is a template-id, its associated namespaces and classes
4568 are the namespace in which the template is defined; for
4569 member templates, the member template's class... */
4570 tree template = TREE_OPERAND (n, 0);
4571 tree args = TREE_OPERAND (n, 1);
4575 if (TREE_CODE (template) == COMPONENT_REF)
4576 template = TREE_OPERAND (template, 1);
4578 /* First, the template. There may actually be more than one if
4579 this is an overloaded function template. But, in that case,
4580 we only need the first; all the functions will be in the same
4582 template = OVL_CURRENT (template);
4584 ctx = CP_DECL_CONTEXT (template);
4586 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4588 if (arg_assoc_namespace (k, ctx) == 1)
4591 /* It must be a member template. */
4592 else if (arg_assoc_class (k, ctx) == 1)
4595 /* Now the arguments. */
4596 for (ix = TREE_VEC_LENGTH (args); ix--;)
4597 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4600 else if (TREE_CODE (n) == OVERLOAD)
4602 for (; n; n = OVL_CHAIN (n))
4603 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4610 /* Performs Koenig lookup depending on arguments, where fns
4611 are the functions found in normal lookup. */
4614 lookup_arg_dependent (tree name, tree fns, tree args)
4616 struct arg_lookup k;
4618 timevar_push (TV_NAME_LOOKUP);
4620 /* Remove any hidden friend functions from the list of functions
4621 found so far. They will be added back by arg_assoc_class as
4623 fns = remove_hidden_names (fns);
4628 k.classes = NULL_TREE;
4630 /* We previously performed an optimization here by setting
4631 NAMESPACES to the current namespace when it was safe. However, DR
4632 164 says that namespaces that were already searched in the first
4633 stage of template processing are searched again (potentially
4634 picking up later definitions) in the second stage. */
4635 k.namespaces = NULL_TREE;
4637 arg_assoc_args (&k, args);
4638 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4641 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4642 changed (i.e. there was already a directive), or the fresh
4643 TREE_LIST otherwise. */
4646 push_using_directive (tree used)
4648 tree ud = current_binding_level->using_directives;
4649 tree iter, ancestor;
4651 timevar_push (TV_NAME_LOOKUP);
4652 /* Check if we already have this. */
4653 if (purpose_member (used, ud) != NULL_TREE)
4654 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4656 ancestor = namespace_ancestor (current_decl_namespace (), used);
4657 ud = current_binding_level->using_directives;
4658 ud = tree_cons (used, ancestor, ud);
4659 current_binding_level->using_directives = ud;
4661 /* Recursively add all namespaces used. */
4662 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4663 push_using_directive (TREE_PURPOSE (iter));
4665 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4668 /* The type TYPE is being declared. If it is a class template, or a
4669 specialization of a class template, do any processing required and
4670 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4671 being declared a friend. B is the binding level at which this TYPE
4674 Returns the TYPE_DECL for TYPE, which may have been altered by this
4678 maybe_process_template_type_declaration (tree type, int is_friend,
4681 tree decl = TYPE_NAME (type);
4683 if (processing_template_parmlist)
4684 /* You can't declare a new template type in a template parameter
4685 list. But, you can declare a non-template type:
4687 template <class A*> struct S;
4689 is a forward-declaration of `A'. */
4693 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4695 if (processing_template_decl)
4697 /* This may change after the call to
4698 push_template_decl_real, but we want the original value. */
4699 tree name = DECL_NAME (decl);
4701 decl = push_template_decl_real (decl, is_friend);
4702 /* If the current binding level is the binding level for the
4703 template parameters (see the comment in
4704 begin_template_parm_list) and the enclosing level is a class
4705 scope, and we're not looking at a friend, push the
4706 declaration of the member class into the class scope. In the
4707 friend case, push_template_decl will already have put the
4708 friend into global scope, if appropriate. */
4709 if (TREE_CODE (type) != ENUMERAL_TYPE
4710 && !is_friend && b->kind == sk_template_parms
4711 && b->level_chain->kind == sk_class)
4713 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4715 if (!COMPLETE_TYPE_P (current_class_type))
4717 maybe_add_class_template_decl_list (current_class_type,
4718 type, /*friend_p=*/0);
4719 /* Put this UTD in the table of UTDs for the class. */
4720 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4721 CLASSTYPE_NESTED_UTDS (current_class_type) =
4722 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4724 binding_table_insert
4725 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4734 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4735 that the NAME is a class template, the tag is processed but not pushed.
4737 The pushed scope depend on the SCOPE parameter:
4738 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4740 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4741 non-template-parameter scope. This case is needed for forward
4743 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4744 TS_GLOBAL case except that names within template-parameter scopes
4745 are not pushed at all.
4747 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4750 pushtag (tree name, tree type, tag_scope scope)
4752 struct cp_binding_level *b;
4755 timevar_push (TV_NAME_LOOKUP);
4756 b = current_binding_level;
4757 while (/* Cleanup scopes are not scopes from the point of view of
4759 b->kind == sk_cleanup
4760 /* Neither are the scopes used to hold template parameters
4761 for an explicit specialization. For an ordinary template
4762 declaration, these scopes are not scopes from the point of
4763 view of the language. */
4764 || (b->kind == sk_template_parms
4765 && (b->explicit_spec_p || scope == ts_global))
4766 || (b->kind == sk_class
4767 && (scope != ts_current
4768 /* We may be defining a new type in the initializer
4769 of a static member variable. We allow this when
4770 not pedantic, and it is particularly useful for
4771 type punning via an anonymous union. */
4772 || COMPLETE_TYPE_P (b->this_entity))))
4775 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4777 /* Do C++ gratuitous typedefing. */
4778 if (IDENTIFIER_TYPE_VALUE (name) != type)
4782 tree context = TYPE_CONTEXT (type);
4786 tree cs = current_scope ();
4788 if (scope == ts_current)
4790 else if (cs != NULL_TREE && TYPE_P (cs))
4791 /* When declaring a friend class of a local class, we want
4792 to inject the newly named class into the scope
4793 containing the local class, not the namespace
4795 context = decl_function_context (get_type_decl (cs));
4798 context = current_namespace;
4800 if (b->kind == sk_class
4801 || (b->kind == sk_template_parms
4802 && b->level_chain->kind == sk_class))
4805 if (current_lang_name == lang_name_java)
4806 TYPE_FOR_JAVA (type) = 1;
4808 tdef = create_implicit_typedef (name, type);
4809 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4810 if (scope == ts_within_enclosing_non_class)
4812 /* This is a friend. Make this TYPE_DECL node hidden from
4813 ordinary name lookup. Its corresponding TEMPLATE_DECL
4814 will be marked in push_template_decl_real. */
4815 retrofit_lang_decl (tdef);
4816 DECL_ANTICIPATED (tdef) = 1;
4817 DECL_FRIEND_P (tdef) = 1;
4820 decl = maybe_process_template_type_declaration
4821 (type, scope == ts_within_enclosing_non_class, b);
4822 if (decl == error_mark_node)
4823 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4826 set_identifier_type_value_with_scope (name, tdef, b);
4828 if (b->kind == sk_class)
4830 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4831 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4832 class. But if it's a member template class, we want
4833 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4835 finish_member_declaration (decl);
4837 pushdecl_class_level (decl);
4839 else if (b->kind != sk_template_parms)
4840 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4842 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4844 /* If this is a local class, keep track of it. We need this
4845 information for name-mangling, and so that it is possible to
4846 find all function definitions in a translation unit in a
4847 convenient way. (It's otherwise tricky to find a member
4848 function definition it's only pointed to from within a local
4850 if (TYPE_CONTEXT (type)
4851 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4852 VEC_safe_push (tree, gc, local_classes, type);
4854 if (b->kind == sk_class
4855 && !COMPLETE_TYPE_P (current_class_type))
4857 maybe_add_class_template_decl_list (current_class_type,
4858 type, /*friend_p=*/0);
4860 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4861 CLASSTYPE_NESTED_UTDS (current_class_type)
4862 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4864 binding_table_insert
4865 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4868 decl = TYPE_NAME (type);
4869 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4870 TYPE_STUB_DECL (type) = decl;
4872 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4875 /* Subroutines for reverting temporarily to top-level for instantiation
4876 of templates and such. We actually need to clear out the class- and
4877 local-value slots of all identifiers, so that only the global values
4878 are at all visible. Simply setting current_binding_level to the global
4879 scope isn't enough, because more binding levels may be pushed. */
4880 struct saved_scope *scope_chain;
4882 /* If ID has not already been marked, add an appropriate binding to
4886 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4888 cxx_saved_binding *saved;
4890 if (!id || !IDENTIFIER_BINDING (id))
4893 if (IDENTIFIER_MARKED (id))
4896 IDENTIFIER_MARKED (id) = 1;
4898 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4899 saved->identifier = id;
4900 saved->binding = IDENTIFIER_BINDING (id);
4901 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4902 IDENTIFIER_BINDING (id) = NULL;
4906 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4910 timevar_push (TV_NAME_LOOKUP);
4911 for (t = names; t; t = TREE_CHAIN (t))
4915 if (TREE_CODE (t) == TREE_LIST)
4916 id = TREE_PURPOSE (t);
4920 store_binding (id, old_bindings);
4922 timevar_pop (TV_NAME_LOOKUP);
4925 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4926 objects, rather than a TREE_LIST. */
4929 store_class_bindings (VEC(cp_class_binding,gc) *names,
4930 VEC(cxx_saved_binding,gc) **old_bindings)
4933 cp_class_binding *cb;
4935 timevar_push (TV_NAME_LOOKUP);
4936 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4937 store_binding (cb->identifier, old_bindings);
4938 timevar_pop (TV_NAME_LOOKUP);
4942 push_to_top_level (void)
4944 struct saved_scope *s;
4945 struct cp_binding_level *b;
4946 cxx_saved_binding *sb;
4950 timevar_push (TV_NAME_LOOKUP);
4951 s = GGC_CNEW (struct saved_scope);
4953 b = scope_chain ? current_binding_level : 0;
4955 /* If we're in the middle of some function, save our state. */
4959 push_function_context_to (NULL_TREE);
4964 if (scope_chain && previous_class_level)
4965 store_class_bindings (previous_class_level->class_shadowed,
4968 /* Have to include the global scope, because class-scope decls
4969 aren't listed anywhere useful. */
4970 for (; b; b = b->level_chain)
4974 /* Template IDs are inserted into the global level. If they were
4975 inserted into namespace level, finish_file wouldn't find them
4976 when doing pending instantiations. Therefore, don't stop at
4977 namespace level, but continue until :: . */
4978 if (global_scope_p (b))
4981 store_bindings (b->names, &s->old_bindings);
4982 /* We also need to check class_shadowed to save class-level type
4983 bindings, since pushclass doesn't fill in b->names. */
4984 if (b->kind == sk_class)
4985 store_class_bindings (b->class_shadowed, &s->old_bindings);
4987 /* Unwind type-value slots back to top level. */
4988 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4989 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4992 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
4993 IDENTIFIER_MARKED (sb->identifier) = 0;
4995 s->prev = scope_chain;
4997 s->need_pop_function_context = need_pop;
4998 s->function_decl = current_function_decl;
4999 s->skip_evaluation = skip_evaluation;
5002 current_function_decl = NULL_TREE;
5003 current_lang_base = VEC_alloc (tree, gc, 10);
5004 current_lang_name = lang_name_cplusplus;
5005 current_namespace = global_namespace;
5006 skip_evaluation = 0;
5007 timevar_pop (TV_NAME_LOOKUP);
5011 pop_from_top_level (void)
5013 struct saved_scope *s = scope_chain;
5014 cxx_saved_binding *saved;
5017 timevar_push (TV_NAME_LOOKUP);
5018 /* Clear out class-level bindings cache. */
5019 if (previous_class_level)
5020 invalidate_class_lookup_cache ();
5022 current_lang_base = 0;
5024 scope_chain = s->prev;
5025 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5027 tree id = saved->identifier;
5029 IDENTIFIER_BINDING (id) = saved->binding;
5030 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5033 /* If we were in the middle of compiling a function, restore our
5035 if (s->need_pop_function_context)
5036 pop_function_context_from (NULL_TREE);
5037 current_function_decl = s->function_decl;
5038 skip_evaluation = s->skip_evaluation;
5039 timevar_pop (TV_NAME_LOOKUP);
5042 /* Pop off extraneous binding levels left over due to syntax errors.
5044 We don't pop past namespaces, as they might be valid. */
5047 pop_everything (void)
5049 if (ENABLE_SCOPE_CHECKING)
5050 verbatim ("XXX entering pop_everything ()\n");
5051 while (!toplevel_bindings_p ())
5053 if (current_binding_level->kind == sk_class)
5054 pop_nested_class ();
5058 if (ENABLE_SCOPE_CHECKING)
5059 verbatim ("XXX leaving pop_everything ()\n");
5062 /* Emit debugging information for using declarations and directives.
5063 If input tree is overloaded fn then emit debug info for all
5067 cp_emit_debug_info_for_using (tree t, tree context)
5069 /* Don't try to emit any debug information if we have errors. */
5070 if (sorrycount || errorcount)
5073 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5074 of a builtin function. */
5075 if (TREE_CODE (t) == FUNCTION_DECL
5076 && DECL_EXTERNAL (t)
5077 && DECL_BUILT_IN (t))
5080 /* Do not supply context to imported_module_or_decl, if
5081 it is a global namespace. */
5082 if (context == global_namespace)
5083 context = NULL_TREE;
5086 t = BASELINK_FUNCTIONS (t);
5088 /* FIXME: Handle TEMPLATE_DECLs. */
5089 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5090 if (TREE_CODE (t) != TEMPLATE_DECL)
5091 (*debug_hooks->imported_module_or_decl) (t, context);
5094 #include "gt-cp-name-lookup.h"