1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006 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"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding {
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope *innermost_nonclass_level (void);
45 static tree select_decl (const struct scope_binding *, int);
46 static cxx_binding *binding_for_name (cxx_scope *, tree);
47 static tree lookup_name_innermost_nonclass_level (tree);
48 static tree push_overloaded_decl (tree, int, bool);
49 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
51 static bool qualified_lookup_using_namespace (tree, tree,
52 struct scope_binding *, int);
53 static tree lookup_type_current_level (tree);
54 static tree push_using_directive (tree);
56 /* The :: namespace. */
58 tree global_namespace;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name;
65 /* Compute the chain index of a binding_entry given the HASH value of its
66 name and the total COUNT of chains. COUNT is assumed to be a power
69 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
71 /* A free list of "binding_entry"s awaiting for re-use. */
73 static GTY((deletable)) binding_entry free_binding_entry = NULL;
75 /* Create a binding_entry object for (NAME, TYPE). */
77 static inline binding_entry
78 binding_entry_make (tree name, tree type)
82 if (free_binding_entry)
84 entry = free_binding_entry;
85 free_binding_entry = entry->chain;
88 entry = GGC_NEW (struct binding_entry_s);
97 /* Put ENTRY back on the free list. */
100 binding_entry_free (binding_entry entry)
104 entry->chain = free_binding_entry;
105 free_binding_entry = entry;
109 /* The datatype used to implement the mapping from names to types at
111 struct binding_table_s GTY(())
113 /* Array of chains of "binding_entry"s */
114 binding_entry * GTY((length ("%h.chain_count"))) chain;
116 /* The number of chains in this table. This is the length of the
117 the member "chain" considered as an array. */
120 /* Number of "binding_entry"s in this table. */
124 /* Construct TABLE with an initial CHAIN_COUNT. */
127 binding_table_construct (binding_table table, size_t chain_count)
129 table->chain_count = chain_count;
130 table->entry_count = 0;
131 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
134 /* Make TABLE's entries ready for reuse. */
137 binding_table_free (binding_table table)
145 for (i = 0, count = table->chain_count; i < count; ++i)
147 binding_entry temp = table->chain[i];
150 binding_entry entry = temp;
152 binding_entry_free (entry);
154 table->chain[i] = NULL;
156 table->entry_count = 0;
160 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
162 static inline binding_table
163 binding_table_new (size_t chain_count)
165 binding_table table = GGC_NEW (struct binding_table_s);
167 binding_table_construct (table, chain_count);
171 /* Expand TABLE to twice its current chain_count. */
174 binding_table_expand (binding_table table)
176 const size_t old_chain_count = table->chain_count;
177 const size_t old_entry_count = table->entry_count;
178 const size_t new_chain_count = 2 * old_chain_count;
179 binding_entry *old_chains = table->chain;
182 binding_table_construct (table, new_chain_count);
183 for (i = 0; i < old_chain_count; ++i)
185 binding_entry entry = old_chains[i];
186 for (; entry != NULL; entry = old_chains[i])
188 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
189 const size_t j = ENTRY_INDEX (hash, new_chain_count);
191 old_chains[i] = entry->chain;
192 entry->chain = table->chain[j];
193 table->chain[j] = entry;
196 table->entry_count = old_entry_count;
199 /* Insert a binding for NAME to TYPE into TABLE. */
202 binding_table_insert (binding_table table, tree name, tree type)
204 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
205 const size_t i = ENTRY_INDEX (hash, table->chain_count);
206 binding_entry entry = binding_entry_make (name, type);
208 entry->chain = table->chain[i];
209 table->chain[i] = entry;
210 ++table->entry_count;
212 if (3 * table->chain_count < 5 * table->entry_count)
213 binding_table_expand (table);
216 /* Return the binding_entry, if any, that maps NAME. */
219 binding_table_find (binding_table table, tree name)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
224 while (entry != NULL && entry->name != name)
225 entry = entry->chain;
230 /* Apply PROC -- with DATA -- to all entries in TABLE. */
233 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
235 const size_t chain_count = table->chain_count;
238 for (i = 0; i < chain_count; ++i)
240 binding_entry entry = table->chain[i];
241 for (; entry != NULL; entry = entry->chain)
246 #ifndef ENABLE_SCOPE_CHECKING
247 # define ENABLE_SCOPE_CHECKING 0
249 # define ENABLE_SCOPE_CHECKING 1
252 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
254 static GTY((deletable)) cxx_binding *free_bindings;
256 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
260 cxx_binding_init (cxx_binding *binding, tree value, tree type)
262 binding->value = value;
263 binding->type = type;
264 binding->previous = NULL;
267 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
270 cxx_binding_make (tree value, tree type)
272 cxx_binding *binding;
275 binding = free_bindings;
276 free_bindings = binding->previous;
279 binding = GGC_NEW (cxx_binding);
281 cxx_binding_init (binding, value, type);
286 /* Put BINDING back on the free list. */
289 cxx_binding_free (cxx_binding *binding)
291 binding->scope = NULL;
292 binding->previous = free_bindings;
293 free_bindings = binding;
296 /* Create a new binding for NAME (with the indicated VALUE and TYPE
297 bindings) in the class scope indicated by SCOPE. */
300 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
302 cp_class_binding *cb;
303 cxx_binding *binding;
305 if (VEC_length (cp_class_binding, scope->class_shadowed))
307 cp_class_binding *old_base;
308 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
309 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
311 /* Fixup the current bindings, as they might have moved. */
315 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
319 b = &IDENTIFIER_BINDING (cb->identifier);
320 while (*b != &old_base[i].base)
321 b = &((*b)->previous);
325 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
328 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
330 cb->identifier = name;
332 binding->scope = scope;
333 cxx_binding_init (binding, value, type);
337 /* Make DECL the innermost binding for ID. The LEVEL is the binding
338 level at which this declaration is being bound. */
341 push_binding (tree id, tree decl, cxx_scope* level)
343 cxx_binding *binding;
345 if (level != class_binding_level)
347 binding = cxx_binding_make (decl, NULL_TREE);
348 binding->scope = level;
351 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
353 /* Now, fill in the binding information. */
354 binding->previous = IDENTIFIER_BINDING (id);
355 INHERITED_VALUE_BINDING_P (binding) = 0;
356 LOCAL_BINDING_P (binding) = (level != class_binding_level);
358 /* And put it on the front of the list of bindings for ID. */
359 IDENTIFIER_BINDING (id) = binding;
362 /* Remove the binding for DECL which should be the innermost binding
366 pop_binding (tree id, tree decl)
368 cxx_binding *binding;
371 /* It's easiest to write the loops that call this function without
372 checking whether or not the entities involved have names. We
373 get here for such an entity. */
376 /* Get the innermost binding for ID. */
377 binding = IDENTIFIER_BINDING (id);
379 /* The name should be bound. */
380 gcc_assert (binding != NULL);
382 /* The DECL will be either the ordinary binding or the type
383 binding for this identifier. Remove that binding. */
384 if (binding->value == decl)
385 binding->value = NULL_TREE;
388 gcc_assert (binding->type == decl);
389 binding->type = NULL_TREE;
392 if (!binding->value && !binding->type)
394 /* We're completely done with the innermost binding for this
395 identifier. Unhook it from the list of bindings. */
396 IDENTIFIER_BINDING (id) = binding->previous;
398 /* Add it to the free list. */
399 cxx_binding_free (binding);
403 /* BINDING records an existing declaration for a name in the current scope.
404 But, DECL is another declaration for that same identifier in the
405 same scope. This is the `struct stat' hack whereby a non-typedef
406 class name or enum-name can be bound at the same level as some other
410 A class name (9.1) or enumeration name (7.2) can be hidden by the
411 name of an object, function, or enumerator declared in the same scope.
412 If a class or enumeration name and an object, function, or enumerator
413 are declared in the same scope (in any order) with the same name, the
414 class or enumeration name is hidden wherever the object, function, or
415 enumerator name is visible.
417 It's the responsibility of the caller to check that
418 inserting this name is valid here. Returns nonzero if the new binding
422 supplement_binding (cxx_binding *binding, tree decl)
424 tree bval = binding->value;
427 timevar_push (TV_NAME_LOOKUP);
428 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
429 /* The new name is the type name. */
430 binding->type = decl;
431 else if (/* BVAL is null when push_class_level_binding moves an
432 inherited type-binding out of the way to make room for a
433 new value binding. */
435 /* BVAL is error_mark_node when DECL's name has been used
436 in a non-class scope prior declaration. In that case,
437 we should have already issued a diagnostic; for graceful
438 error recovery purpose, pretend this was the intended
439 declaration for that name. */
440 || bval == error_mark_node
441 /* If BVAL is anticipated but has not yet been declared,
442 pretend it is not there at all. */
443 || (TREE_CODE (bval) == FUNCTION_DECL
444 && DECL_ANTICIPATED (bval)
445 && !DECL_HIDDEN_FRIEND_P (bval)))
446 binding->value = decl;
447 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
449 /* The old binding was a type name. It was placed in
450 VALUE field because it was thought, at the point it was
451 declared, to be the only entity with such a name. Move the
452 type name into the type slot; it is now hidden by the new
454 binding->type = bval;
455 binding->value = decl;
456 binding->value_is_inherited = false;
458 else if (TREE_CODE (bval) == TYPE_DECL
459 && TREE_CODE (decl) == TYPE_DECL
460 && DECL_NAME (decl) == DECL_NAME (bval)
461 && binding->scope->kind != sk_class
462 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
463 /* If either type involves template parameters, we must
464 wait until instantiation. */
465 || uses_template_parms (TREE_TYPE (decl))
466 || uses_template_parms (TREE_TYPE (bval))))
467 /* We have two typedef-names, both naming the same type to have
468 the same name. In general, this is OK because of:
472 In a given scope, a typedef specifier can be used to redefine
473 the name of any type declared in that scope to refer to the
474 type to which it already refers.
476 However, in class scopes, this rule does not apply due to the
477 stricter language in [class.mem] prohibiting redeclarations of
480 /* There can be two block-scope declarations of the same variable,
481 so long as they are `extern' declarations. However, there cannot
482 be two declarations of the same static data member:
486 A member shall not be declared twice in the
487 member-specification. */
488 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
489 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
490 && !DECL_CLASS_SCOPE_P (decl))
492 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
495 else if (TREE_CODE (decl) == NAMESPACE_DECL
496 && TREE_CODE (bval) == NAMESPACE_DECL
497 && DECL_NAMESPACE_ALIAS (decl)
498 && DECL_NAMESPACE_ALIAS (bval)
499 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
502 In a declarative region, a namespace-alias-definition can be
503 used to redefine a namespace-alias declared in that declarative
504 region to refer only to the namespace to which it already
509 error ("declaration of %q#D", decl);
510 error ("conflicts with previous declaration %q+#D", bval);
514 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
517 /* Add DECL to the list of things declared in B. */
520 add_decl_to_level (tree decl, cxx_scope *b)
522 if (TREE_CODE (decl) == NAMESPACE_DECL
523 && !DECL_NAMESPACE_ALIAS (decl))
525 TREE_CHAIN (decl) = b->namespaces;
526 b->namespaces = decl;
528 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
530 TREE_CHAIN (decl) = b->vtables;
535 /* We build up the list in reverse order, and reverse it later if
537 TREE_CHAIN (decl) = b->names;
541 /* If appropriate, add decl to separate list of statics. We
542 include extern variables because they might turn out to be
543 static later. It's OK for this list to contain a few false
545 if (b->kind == sk_namespace)
546 if ((TREE_CODE (decl) == VAR_DECL
547 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
548 || (TREE_CODE (decl) == FUNCTION_DECL
549 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
550 VEC_safe_push (tree, gc, b->static_decls, decl);
554 /* Record a decl-node X as belonging to the current lexical scope.
555 Check for errors (such as an incompatible declaration for the same
556 name already seen in the same scope). IS_FRIEND is true if X is
557 declared as a friend.
559 Returns either X or an old decl for the same name.
560 If an old decl is returned, it may have been smashed
561 to agree with what X says. */
564 pushdecl_maybe_friend (tree x, bool is_friend)
568 int need_new_binding;
570 timevar_push (TV_NAME_LOOKUP);
572 need_new_binding = 1;
574 if (DECL_TEMPLATE_PARM_P (x))
575 /* Template parameters have no context; they are not X::T even
576 when declared within a class or namespace. */
580 if (current_function_decl && x != current_function_decl
581 /* A local declaration for a function doesn't constitute
583 && TREE_CODE (x) != FUNCTION_DECL
584 /* A local declaration for an `extern' variable is in the
585 scope of the current namespace, not the current
587 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
588 && !DECL_CONTEXT (x))
589 DECL_CONTEXT (x) = current_function_decl;
591 /* If this is the declaration for a namespace-scope function,
592 but the declaration itself is in a local scope, mark the
594 if (TREE_CODE (x) == FUNCTION_DECL
595 && DECL_NAMESPACE_SCOPE_P (x)
596 && current_function_decl
597 && x != current_function_decl)
598 DECL_LOCAL_FUNCTION_P (x) = 1;
601 name = DECL_NAME (x);
604 int different_binding_level = 0;
606 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
607 check_default_args (x);
609 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
610 name = TREE_OPERAND (name, 0);
612 /* In case this decl was explicitly namespace-qualified, look it
613 up in its namespace context. */
614 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
615 t = namespace_binding (name, DECL_CONTEXT (x));
617 t = lookup_name_innermost_nonclass_level (name);
619 /* [basic.link] If there is a visible declaration of an entity
620 with linkage having the same name and type, ignoring entities
621 declared outside the innermost enclosing namespace scope, the
622 block scope declaration declares that same entity and
623 receives the linkage of the previous declaration. */
624 if (! t && current_function_decl && x != current_function_decl
625 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
626 && DECL_EXTERNAL (x))
628 /* Look in block scope. */
629 t = innermost_non_namespace_value (name);
630 /* Or in the innermost namespace. */
632 t = namespace_binding (name, DECL_CONTEXT (x));
633 /* Does it have linkage? Note that if this isn't a DECL, it's an
634 OVERLOAD, which is OK. */
635 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
638 different_binding_level = 1;
641 /* If we are declaring a function, and the result of name-lookup
642 was an OVERLOAD, look for an overloaded instance that is
643 actually the same as the function we are declaring. (If
644 there is one, we have to merge our declaration with the
645 previous declaration.) */
646 if (t && TREE_CODE (t) == OVERLOAD)
650 if (TREE_CODE (x) == FUNCTION_DECL)
651 for (match = t; match; match = OVL_NEXT (match))
653 if (decls_match (OVL_CURRENT (match), x))
657 /* Just choose one. */
661 t = OVL_CURRENT (match);
666 if (t && t != error_mark_node)
668 if (different_binding_level)
670 if (decls_match (x, t))
671 /* The standard only says that the local extern
672 inherits linkage from the previous decl; in
673 particular, default args are not shared. We must
674 also tell cgraph to treat these decls as the same,
675 or we may neglect to emit an "unused" static - we
676 do this by making the DECL_UIDs equal, which should
677 be viewed as a kludge. FIXME. */
679 TREE_PUBLIC (x) = TREE_PUBLIC (t);
680 DECL_UID (x) = DECL_UID (t);
683 else if (TREE_CODE (t) == PARM_DECL)
685 gcc_assert (DECL_CONTEXT (t));
687 /* Check for duplicate params. */
688 if (duplicate_decls (x, t, is_friend))
689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
691 else if ((DECL_EXTERN_C_FUNCTION_P (x)
692 || DECL_FUNCTION_TEMPLATE_P (x))
693 && is_overloaded_fn (t))
694 /* Don't do anything just yet. */;
695 else if (t == wchar_decl_node)
697 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
698 pedwarn ("redeclaration of %<wchar_t%> as %qT",
701 /* Throw away the redeclaration. */
702 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
706 tree olddecl = duplicate_decls (x, t, is_friend);
708 /* If the redeclaration failed, we can stop at this
710 if (olddecl == error_mark_node)
711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
715 if (TREE_CODE (t) == TYPE_DECL)
716 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
720 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
722 /* A redeclaration of main, but not a duplicate of the
727 This function shall not be overloaded. */
728 error ("invalid redeclaration of %q+D", t);
730 /* We don't try to push this declaration since that
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
737 check_template_shadow (x);
739 /* If this is a function conjured up by the backend, massage it
740 so it looks friendly. */
741 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
743 retrofit_lang_decl (x);
744 SET_DECL_LANGUAGE (x, lang_c);
747 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
749 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
752 if (!namespace_bindings_p ())
753 /* We do not need to create a binding for this name;
754 push_overloaded_decl will have already done so if
756 need_new_binding = 0;
758 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
760 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
762 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
766 /* If declaring a type as a typedef, copy the type (unless we're
767 at line 0), and install this TYPE_DECL as the new type's typedef
768 name. See the extensive comment in ../c-decl.c (pushdecl). */
769 if (TREE_CODE (x) == TYPE_DECL)
771 tree type = TREE_TYPE (x);
772 if (DECL_IS_BUILTIN (x))
774 if (TYPE_NAME (type) == 0)
775 TYPE_NAME (type) = x;
777 else if (type != error_mark_node && TYPE_NAME (type) != x
778 /* We don't want to copy the type when all we're
779 doing is making a TYPE_DECL for the purposes of
781 && (!TYPE_NAME (type)
782 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
784 DECL_ORIGINAL_TYPE (x) = type;
785 type = build_variant_type_copy (type);
786 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
787 TYPE_NAME (type) = x;
788 TREE_TYPE (x) = type;
791 if (type != error_mark_node
793 && TYPE_IDENTIFIER (type))
794 set_identifier_type_value (DECL_NAME (x), x);
797 /* Multiple external decls of the same identifier ought to match.
799 We get warnings about inline functions where they are defined.
800 We get warnings about other functions from push_overloaded_decl.
802 Avoid duplicate warnings where they are used. */
803 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
807 decl = IDENTIFIER_NAMESPACE_VALUE (name);
808 if (decl && TREE_CODE (decl) == OVERLOAD)
809 decl = OVL_FUNCTION (decl);
811 if (decl && decl != error_mark_node
812 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
813 /* If different sort of thing, we already gave an error. */
814 && TREE_CODE (decl) == TREE_CODE (x)
815 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
817 pedwarn ("type mismatch with previous external decl of %q#D", x);
818 pedwarn ("previous external decl of %q+#D", decl);
822 if (TREE_CODE (x) == FUNCTION_DECL
824 && !flag_friend_injection)
826 /* This is a new declaration of a friend function, so hide
827 it from ordinary function lookup. */
828 DECL_ANTICIPATED (x) = 1;
829 DECL_HIDDEN_FRIEND_P (x) = 1;
832 /* This name is new in its binding level.
833 Install the new declaration and return it. */
834 if (namespace_bindings_p ())
836 /* Install a global value. */
838 /* If the first global decl has external linkage,
839 warn if we later see static one. */
840 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
841 TREE_PUBLIC (name) = 1;
843 /* Bind the name for the entity. */
844 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
846 && (TREE_CODE (x) == TYPE_DECL
847 || TREE_CODE (x) == VAR_DECL
848 || TREE_CODE (x) == NAMESPACE_DECL
849 || TREE_CODE (x) == CONST_DECL
850 || TREE_CODE (x) == TEMPLATE_DECL))
851 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
853 /* If new decl is `static' and an `extern' was seen previously,
855 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
856 warn_extern_redeclared_static (x, t);
860 /* Here to install a non-global value. */
861 tree oldlocal = innermost_non_namespace_value (name);
862 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
864 if (need_new_binding)
866 push_local_binding (name, x, 0);
867 /* Because push_local_binding will hook X on to the
868 current_binding_level's name list, we don't want to
869 do that again below. */
870 need_new_binding = 0;
873 /* If this is a TYPE_DECL, push it into the type value slot. */
874 if (TREE_CODE (x) == TYPE_DECL)
875 set_identifier_type_value (name, x);
877 /* Clear out any TYPE_DECL shadowed by a namespace so that
878 we won't think this is a type. The C struct hack doesn't
879 go through namespaces. */
880 if (TREE_CODE (x) == NAMESPACE_DECL)
881 set_identifier_type_value (name, NULL_TREE);
888 && TREE_CODE (oldlocal) == VAR_DECL
889 && DECL_DEAD_FOR_LOCAL (oldlocal))
890 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
892 if (oldlocal == NULL_TREE)
893 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
896 /* If this is an extern function declaration, see if we
897 have a global definition or declaration for the function. */
898 if (oldlocal == NULL_TREE
900 && oldglobal != NULL_TREE
901 && TREE_CODE (x) == FUNCTION_DECL
902 && TREE_CODE (oldglobal) == FUNCTION_DECL)
904 /* We have one. Their types must agree. */
905 if (decls_match (x, oldglobal))
909 warning (0, "extern declaration of %q#D doesn't match", x);
910 warning (0, "global declaration %q+#D", oldglobal);
913 /* If we have a local external declaration,
914 and no file-scope declaration has yet been seen,
915 then if we later have a file-scope decl it must not be static. */
916 if (oldlocal == NULL_TREE
917 && oldglobal == NULL_TREE
920 TREE_PUBLIC (name) = 1;
922 /* Warn if shadowing an argument at the top level of the body. */
923 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
924 /* Inline decls shadow nothing. */
925 && !DECL_FROM_INLINE (x)
926 && TREE_CODE (oldlocal) == PARM_DECL
927 /* Don't check the `this' parameter. */
928 && !DECL_ARTIFICIAL (oldlocal))
932 /* Don't complain if it's from an enclosing function. */
933 if (DECL_CONTEXT (oldlocal) == current_function_decl
934 && TREE_CODE (x) != PARM_DECL)
936 /* Go to where the parms should be and see if we find
938 struct cp_binding_level *b = current_binding_level->level_chain;
940 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
941 /* Skip the ctor/dtor cleanup level. */
945 if (b->kind == sk_function_parms)
947 error ("declaration of %q#D shadows a parameter", x);
952 if (warn_shadow && !err)
954 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
955 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
959 /* Maybe warn if shadowing something else. */
960 else if (warn_shadow && !DECL_EXTERNAL (x)
961 /* No shadow warnings for internally generated vars. */
962 && ! DECL_ARTIFICIAL (x)
963 /* No shadow warnings for vars made for inlining. */
964 && ! DECL_FROM_INLINE (x))
968 if (current_class_ptr)
969 member = lookup_member (current_class_type,
972 /*want_type=*/false);
976 if (member && !TREE_STATIC (member))
978 /* Location of previous decl is not useful in this case. */
979 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
982 else if (oldlocal != NULL_TREE
983 && TREE_CODE (oldlocal) == VAR_DECL)
985 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
986 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
988 else if (oldglobal != NULL_TREE
989 && TREE_CODE (oldglobal) == VAR_DECL)
990 /* XXX shadow warnings in outer-more namespaces */
992 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
994 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
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:
1283 scope->keep = keep_next_level_flag;
1287 NAMESPACE_LEVEL (entity) = scope;
1288 scope->static_decls =
1289 VEC_alloc (tree, gc,
1290 DECL_NAME (entity) == std_identifier
1291 || DECL_NAME (entity) == global_scope_name
1296 /* Should not happen. */
1302 push_binding_level (scope);
1307 /* We're about to leave current scope. Pop the top of the stack of
1308 currently active scopes. Return the enclosing scope, now active. */
1313 cxx_scope *scope = current_binding_level;
1315 if (scope->kind == sk_namespace && class_binding_level)
1316 current_binding_level = class_binding_level;
1318 /* We cannot leave a scope, if there are none left. */
1319 if (NAMESPACE_LEVEL (global_namespace))
1320 gcc_assert (!global_scope_p (scope));
1322 if (ENABLE_SCOPE_CHECKING)
1324 indent (--binding_depth);
1325 cxx_scope_debug (scope, input_line, "leave");
1326 if (is_class_level != (scope == class_binding_level))
1328 indent (binding_depth);
1329 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1334 #ifdef HANDLE_PRAGMA_VISIBILITY
1335 if (scope->has_visibility)
1339 /* Move one nesting level up. */
1340 current_binding_level = scope->level_chain;
1342 /* Namespace-scopes are left most probably temporarily, not
1343 completely; they can be reopened later, e.g. in namespace-extension
1344 or any name binding activity that requires us to resume a
1345 namespace. For classes, we cache some binding levels. For other
1346 scopes, we just make the structure available for reuse. */
1347 if (scope->kind != sk_namespace
1348 && scope->kind != sk_class)
1350 scope->level_chain = free_binding_level;
1351 gcc_assert (!ENABLE_SCOPE_CHECKING
1352 || scope->binding_depth == binding_depth);
1353 free_binding_level = scope;
1356 /* Find the innermost enclosing class scope, and reset
1357 CLASS_BINDING_LEVEL appropriately. */
1358 if (scope->kind == sk_class)
1360 class_binding_level = NULL;
1361 for (scope = current_binding_level; scope; scope = scope->level_chain)
1362 if (scope->kind == sk_class)
1364 class_binding_level = scope;
1369 return current_binding_level;
1373 resume_scope (struct cp_binding_level* b)
1375 /* Resuming binding levels is meant only for namespaces,
1376 and those cannot nest into classes. */
1377 gcc_assert (!class_binding_level);
1378 /* Also, resuming a non-directly nested namespace is a no-no. */
1379 gcc_assert (b->level_chain == current_binding_level);
1380 current_binding_level = b;
1381 if (ENABLE_SCOPE_CHECKING)
1383 b->binding_depth = binding_depth;
1384 indent (binding_depth);
1385 cxx_scope_debug (b, input_line, "resume");
1391 /* Return the innermost binding level that is not for a class scope. */
1394 innermost_nonclass_level (void)
1398 b = current_binding_level;
1399 while (b->kind == sk_class)
1405 /* We're defining an object of type TYPE. If it needs a cleanup, but
1406 we're not allowed to add any more objects with cleanups to the current
1407 scope, create a new binding level. */
1410 maybe_push_cleanup_level (tree type)
1412 if (type != error_mark_node
1413 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1414 && current_binding_level->more_cleanups_ok == 0)
1416 begin_scope (sk_cleanup, NULL);
1417 current_binding_level->statement_list = push_stmt_list ();
1421 /* Nonzero if we are currently in the global binding level. */
1424 global_bindings_p (void)
1426 return global_scope_p (current_binding_level);
1429 /* True if we are currently in a toplevel binding level. This
1430 means either the global binding level or a namespace in a toplevel
1431 binding level. Since there are no non-toplevel namespace levels,
1432 this really means any namespace or template parameter level. We
1433 also include a class whose context is toplevel. */
1436 toplevel_bindings_p (void)
1438 struct cp_binding_level *b = innermost_nonclass_level ();
1440 return b->kind == sk_namespace || b->kind == sk_template_parms;
1443 /* True if this is a namespace scope, or if we are defining a class
1444 which is itself at namespace scope, or whose enclosing class is
1445 such a class, etc. */
1448 namespace_bindings_p (void)
1450 struct cp_binding_level *b = innermost_nonclass_level ();
1452 return b->kind == sk_namespace;
1455 /* True if the current level needs to have a BLOCK made. */
1460 return (current_binding_level->blocks != NULL_TREE
1461 || current_binding_level->keep
1462 || current_binding_level->kind == sk_cleanup
1463 || current_binding_level->names != NULL_TREE);
1466 /* Returns the kind of the innermost scope. */
1469 innermost_scope_kind (void)
1471 return current_binding_level->kind;
1474 /* Returns true if this scope was created to store template parameters. */
1477 template_parm_scope_p (void)
1479 return innermost_scope_kind () == sk_template_parms;
1482 /* If KEEP is true, make a BLOCK node for the next binding level,
1483 unconditionally. Otherwise, use the normal logic to decide whether
1484 or not to create a BLOCK. */
1487 keep_next_level (bool keep)
1489 keep_next_level_flag = keep;
1492 /* Return the list of declarations of the current level.
1493 Note that this list is in reverse order unless/until
1494 you nreverse it; and when you do nreverse it, you must
1495 store the result back using `storedecls' or you will lose. */
1500 return current_binding_level->names;
1503 /* For debugging. */
1504 static int no_print_functions = 0;
1505 static int no_print_builtins = 0;
1508 print_binding_level (struct cp_binding_level* lvl)
1512 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1513 if (lvl->more_cleanups_ok)
1514 fprintf (stderr, " more-cleanups-ok");
1515 if (lvl->have_cleanups)
1516 fprintf (stderr, " have-cleanups");
1517 fprintf (stderr, "\n");
1520 fprintf (stderr, " names:\t");
1521 /* We can probably fit 3 names to a line? */
1522 for (t = lvl->names; t; t = TREE_CHAIN (t))
1524 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1526 if (no_print_builtins
1527 && (TREE_CODE (t) == TYPE_DECL)
1528 && DECL_IS_BUILTIN (t))
1531 /* Function decls tend to have longer names. */
1532 if (TREE_CODE (t) == FUNCTION_DECL)
1539 fprintf (stderr, "\n\t");
1542 print_node_brief (stderr, "", t, 0);
1543 if (t == error_mark_node)
1547 fprintf (stderr, "\n");
1549 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1552 cp_class_binding *b;
1553 fprintf (stderr, " class-shadowed:");
1555 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1557 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1558 fprintf (stderr, "\n");
1560 if (lvl->type_shadowed)
1562 fprintf (stderr, " type-shadowed:");
1563 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1565 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1567 fprintf (stderr, "\n");
1572 print_other_binding_stack (struct cp_binding_level *stack)
1574 struct cp_binding_level *level;
1575 for (level = stack; !global_scope_p (level); level = level->level_chain)
1577 fprintf (stderr, "binding level %p\n", (void *) level);
1578 print_binding_level (level);
1583 print_binding_stack (void)
1585 struct cp_binding_level *b;
1586 fprintf (stderr, "current_binding_level=%p\n"
1587 "class_binding_level=%p\n"
1588 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1589 (void *) current_binding_level, (void *) class_binding_level,
1590 (void *) NAMESPACE_LEVEL (global_namespace));
1591 if (class_binding_level)
1593 for (b = class_binding_level; b; b = b->level_chain)
1594 if (b == current_binding_level)
1597 b = class_binding_level;
1599 b = current_binding_level;
1602 b = current_binding_level;
1603 print_other_binding_stack (b);
1604 fprintf (stderr, "global:\n");
1605 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1608 /* Return the type associated with id. */
1611 identifier_type_value (tree id)
1613 timevar_push (TV_NAME_LOOKUP);
1614 /* There is no type with that name, anywhere. */
1615 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1616 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1617 /* This is not the type marker, but the real thing. */
1618 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1619 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1620 /* Have to search for it. It must be on the global level, now.
1621 Ask lookup_name not to return non-types. */
1622 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1624 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1628 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1629 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1632 identifier_global_value (tree t)
1634 return IDENTIFIER_GLOBAL_VALUE (t);
1637 /* Push a definition of struct, union or enum tag named ID. into
1638 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1639 the tag ID is not already defined. */
1642 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1646 if (b->kind != sk_namespace)
1648 /* Shadow the marker, not the real thing, so that the marker
1649 gets restored later. */
1650 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1652 = tree_cons (id, old_type_value, b->type_shadowed);
1653 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1654 TREE_TYPE (b->type_shadowed) = type;
1658 cxx_binding *binding =
1659 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1662 supplement_binding (binding, decl);
1664 binding->value = decl;
1666 /* Store marker instead of real type. */
1667 type = global_type_node;
1669 SET_IDENTIFIER_TYPE_VALUE (id, type);
1672 /* As set_identifier_type_value_with_scope, but using
1673 current_binding_level. */
1676 set_identifier_type_value (tree id, tree decl)
1678 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1681 /* Return the name for the constructor (or destructor) for the
1682 specified class TYPE. When given a template, this routine doesn't
1683 lose the specialization. */
1686 constructor_name_full (tree type)
1688 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1691 /* Return the name for the constructor (or destructor) for the
1692 specified class. When given a template, return the plain
1693 unspecialized name. */
1696 constructor_name (tree type)
1699 name = constructor_name_full (type);
1700 if (IDENTIFIER_TEMPLATE (name))
1701 name = IDENTIFIER_TEMPLATE (name);
1705 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1708 constructor_name_p (tree name, tree type)
1715 if (TREE_CODE (name) != IDENTIFIER_NODE)
1718 ctor_name = constructor_name_full (type);
1719 if (name == ctor_name)
1721 if (IDENTIFIER_TEMPLATE (ctor_name)
1722 && name == IDENTIFIER_TEMPLATE (ctor_name))
1727 /* Counter used to create anonymous type names. */
1729 static GTY(()) int anon_cnt;
1731 /* Return an IDENTIFIER which can be used as a name for
1732 anonymous structs and unions. */
1735 make_anon_name (void)
1739 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1740 return get_identifier (buf);
1743 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1745 static inline cxx_binding *
1746 find_binding (cxx_scope *scope, cxx_binding *binding)
1748 timevar_push (TV_NAME_LOOKUP);
1750 for (; binding != NULL; binding = binding->previous)
1751 if (binding->scope == scope)
1752 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1757 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1759 static inline cxx_binding *
1760 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1762 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1765 /* Fold-in case where NAME is used only once. */
1766 if (scope == b->scope && b->previous == NULL)
1768 return find_binding (scope, b);
1773 /* Always returns a binding for name in scope. If no binding is
1774 found, make a new one. */
1776 static cxx_binding *
1777 binding_for_name (cxx_scope *scope, tree name)
1779 cxx_binding *result;
1781 result = cxx_scope_find_binding_for_name (scope, name);
1784 /* Not found, make a new one. */
1785 result = cxx_binding_make (NULL, NULL);
1786 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1787 result->scope = scope;
1788 result->is_local = false;
1789 result->value_is_inherited = false;
1790 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1794 /* Insert another USING_DECL into the current binding level, returning
1795 this declaration. If this is a redeclaration, do nothing, and
1796 return NULL_TREE if this not in namespace scope (in namespace
1797 scope, a using decl might extend any previous bindings). */
1800 push_using_decl (tree scope, tree name)
1804 timevar_push (TV_NAME_LOOKUP);
1805 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1806 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1807 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1808 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1811 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1812 namespace_bindings_p () ? decl : NULL_TREE);
1813 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1814 USING_DECL_SCOPE (decl) = scope;
1815 TREE_CHAIN (decl) = current_binding_level->usings;
1816 current_binding_level->usings = decl;
1817 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1820 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1821 caller to set DECL_CONTEXT properly. */
1824 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1826 struct cp_binding_level *b;
1827 tree function_decl = current_function_decl;
1829 timevar_push (TV_NAME_LOOKUP);
1830 current_function_decl = NULL_TREE;
1831 if (level->kind == sk_class)
1833 b = class_binding_level;
1834 class_binding_level = level;
1835 pushdecl_class_level (x);
1836 class_binding_level = b;
1840 b = current_binding_level;
1841 current_binding_level = level;
1842 x = pushdecl_maybe_friend (x, is_friend);
1843 current_binding_level = b;
1845 current_function_decl = function_decl;
1846 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1849 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1850 other definitions already in place. We get around this by making
1851 the value of the identifier point to a list of all the things that
1852 want to be referenced by that name. It is then up to the users of
1853 that name to decide what to do with that list.
1855 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1856 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1858 FLAGS is a bitwise-or of the following values:
1859 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1861 PUSH_USING: DECL is being pushed as the result of a using
1864 IS_FRIEND is true if this is a friend declaration.
1866 The value returned may be a previous declaration if we guessed wrong
1867 about what language DECL should belong to (C or C++). Otherwise,
1868 it's always DECL (and never something that's not a _DECL). */
1871 push_overloaded_decl (tree decl, int flags, bool is_friend)
1873 tree name = DECL_NAME (decl);
1876 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1878 timevar_push (TV_NAME_LOOKUP);
1880 old = namespace_binding (name, DECL_CONTEXT (decl));
1882 old = lookup_name_innermost_nonclass_level (name);
1886 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1888 tree t = TREE_TYPE (old);
1889 if (IS_AGGR_TYPE (t) && warn_shadow
1890 && (! DECL_IN_SYSTEM_HEADER (decl)
1891 || ! DECL_IN_SYSTEM_HEADER (old)))
1892 warning (0, "%q#D hides constructor for %q#T", decl, t);
1895 else if (is_overloaded_fn (old))
1899 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1901 tree fn = OVL_CURRENT (tmp);
1904 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1905 && !(flags & PUSH_USING)
1906 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1907 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1908 && ! decls_match (fn, decl))
1909 error ("%q#D conflicts with previous using declaration %q#D",
1912 dup = duplicate_decls (decl, fn, is_friend);
1913 /* If DECL was a redeclaration of FN -- even an invalid
1914 one -- pass that information along to our caller. */
1915 if (dup == fn || dup == error_mark_node)
1916 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1919 /* We don't overload implicit built-ins. duplicate_decls()
1920 may fail to merge the decls if the new decl is e.g. a
1921 template function. */
1922 if (TREE_CODE (old) == FUNCTION_DECL
1923 && DECL_ANTICIPATED (old)
1924 && !DECL_HIDDEN_FRIEND_P (old))
1927 else if (old == error_mark_node)
1928 /* Ignore the undefined symbol marker. */
1932 error ("previous non-function declaration %q+#D", old);
1933 error ("conflicts with function declaration %q#D", decl);
1934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1938 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1939 /* If it's a using declaration, we always need to build an OVERLOAD,
1940 because it's the only way to remember that the declaration comes
1941 from 'using', and have the lookup behave correctly. */
1942 || (flags & PUSH_USING))
1944 if (old && TREE_CODE (old) != OVERLOAD)
1945 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1947 new_binding = ovl_cons (decl, old);
1948 if (flags & PUSH_USING)
1949 OVL_USED (new_binding) = 1;
1952 /* NAME is not ambiguous. */
1956 set_namespace_binding (name, current_namespace, new_binding);
1959 /* We only create an OVERLOAD if there was a previous binding at
1960 this level, or if decl is a template. In the former case, we
1961 need to remove the old binding and replace it with the new
1962 binding. We must also run through the NAMES on the binding
1963 level where the name was bound to update the chain. */
1965 if (TREE_CODE (new_binding) == OVERLOAD && old)
1969 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1971 d = &TREE_CHAIN (*d))
1973 || (TREE_CODE (*d) == TREE_LIST
1974 && TREE_VALUE (*d) == old))
1976 if (TREE_CODE (*d) == TREE_LIST)
1977 /* Just replace the old binding with the new. */
1978 TREE_VALUE (*d) = new_binding;
1980 /* Build a TREE_LIST to wrap the OVERLOAD. */
1981 *d = tree_cons (NULL_TREE, new_binding,
1984 /* And update the cxx_binding node. */
1985 IDENTIFIER_BINDING (name)->value = new_binding;
1986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1989 /* We should always find a previous binding in this case. */
1993 /* Install the new binding. */
1994 push_local_binding (name, new_binding, flags);
1997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2000 /* Check a non-member using-declaration. Return the name and scope
2001 being used, and the USING_DECL, or NULL_TREE on failure. */
2004 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2006 /* [namespace.udecl]
2007 A using-declaration for a class member shall be a
2008 member-declaration. */
2011 error ("%qT is not a namespace", scope);
2014 else if (scope == error_mark_node)
2017 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2020 A using-declaration shall not name a template-id. */
2021 error ("a using-declaration cannot specify a template-id. "
2022 "Try %<using %D%>", name);
2026 if (TREE_CODE (decl) == NAMESPACE_DECL)
2028 error ("namespace %qD not allowed in using-declaration", decl);
2032 if (TREE_CODE (decl) == SCOPE_REF)
2034 /* It's a nested name with template parameter dependent scope.
2035 This can only be using-declaration for class member. */
2036 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2040 if (is_overloaded_fn (decl))
2041 decl = get_first_fn (decl);
2043 gcc_assert (DECL_P (decl));
2045 /* Make a USING_DECL. */
2046 return push_using_decl (scope, name);
2049 /* Process local and global using-declarations. */
2052 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2053 tree *newval, tree *newtype)
2055 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2057 *newval = *newtype = NULL_TREE;
2058 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2062 if (!decls.value && !decls.type)
2064 error ("%qD not declared", name);
2068 /* It is impossible to overload a built-in function; any explicit
2069 declaration eliminates the built-in declaration. So, if OLDVAL
2070 is a built-in, then we can just pretend it isn't there. */
2072 && TREE_CODE (oldval) == FUNCTION_DECL
2073 && DECL_ANTICIPATED (oldval)
2074 && !DECL_HIDDEN_FRIEND_P (oldval))
2077 /* Check for using functions. */
2078 if (decls.value && is_overloaded_fn (decls.value))
2082 if (oldval && !is_overloaded_fn (oldval))
2084 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2085 error ("%qD is already declared in this scope", name);
2090 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2092 tree new_fn = OVL_CURRENT (tmp);
2094 /* [namespace.udecl]
2096 If a function declaration in namespace scope or block
2097 scope has the same name and the same parameter types as a
2098 function introduced by a using declaration the program is
2100 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2102 tree old_fn = OVL_CURRENT (tmp1);
2104 if (new_fn == old_fn)
2105 /* The function already exists in the current namespace. */
2107 else if (OVL_USED (tmp1))
2108 continue; /* this is a using decl */
2109 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2110 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2112 gcc_assert (!DECL_ANTICIPATED (old_fn)
2113 || DECL_HIDDEN_FRIEND_P (old_fn));
2115 /* There was already a non-using declaration in
2116 this scope with the same parameter types. If both
2117 are the same extern "C" functions, that's ok. */
2118 if (decls_match (new_fn, old_fn))
2122 error ("%qD is already declared in this scope", name);
2128 /* If we broke out of the loop, there's no reason to add
2129 this function to the using declarations for this
2134 /* If we are adding to an existing OVERLOAD, then we no
2135 longer know the type of the set of functions. */
2136 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2137 TREE_TYPE (*newval) = unknown_type_node;
2138 /* Add this new function to the set. */
2139 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2140 /* If there is only one function, then we use its type. (A
2141 using-declaration naming a single function can be used in
2142 contexts where overload resolution cannot be
2144 if (TREE_CODE (*newval) != OVERLOAD)
2146 *newval = ovl_cons (*newval, NULL_TREE);
2147 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2149 OVL_USED (*newval) = 1;
2154 *newval = decls.value;
2155 if (oldval && !decls_match (*newval, oldval))
2156 error ("%qD is already declared in this scope", name);
2159 *newtype = decls.type;
2160 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2162 error ("using declaration %qD introduced ambiguous type %qT",
2168 /* Process a using-declaration at function scope. */
2171 do_local_using_decl (tree decl, tree scope, tree name)
2173 tree oldval, oldtype, newval, newtype;
2174 tree orig_decl = decl;
2176 decl = validate_nonmember_using_decl (decl, scope, name);
2177 if (decl == NULL_TREE)
2180 if (building_stmt_tree ()
2181 && at_function_scope_p ())
2182 add_decl_expr (decl);
2184 oldval = lookup_name_innermost_nonclass_level (name);
2185 oldtype = lookup_type_current_level (name);
2187 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2191 if (is_overloaded_fn (newval))
2195 /* We only need to push declarations for those functions
2196 that were not already bound in the current level.
2197 The old value might be NULL_TREE, it might be a single
2198 function, or an OVERLOAD. */
2199 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2200 term = OVL_FUNCTION (oldval);
2203 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2205 push_overloaded_decl (OVL_CURRENT (fn),
2206 PUSH_LOCAL | PUSH_USING,
2210 push_local_binding (name, newval, PUSH_USING);
2214 push_local_binding (name, newtype, PUSH_USING);
2215 set_identifier_type_value (name, newtype);
2218 /* Emit debug info. */
2219 if (!processing_template_decl)
2220 cp_emit_debug_info_for_using (orig_decl, current_scope());
2223 /* Returns true if ROOT (a namespace, class, or function) encloses
2224 CHILD. CHILD may be either a class type or a namespace. */
2227 is_ancestor (tree root, tree child)
2229 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2230 || TREE_CODE (root) == FUNCTION_DECL
2231 || CLASS_TYPE_P (root)));
2232 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2233 || CLASS_TYPE_P (child)));
2235 /* The global namespace encloses everything. */
2236 if (root == global_namespace)
2241 /* If we've run out of scopes, stop. */
2244 /* If we've reached the ROOT, it encloses CHILD. */
2247 /* Go out one level. */
2249 child = TYPE_NAME (child);
2250 child = DECL_CONTEXT (child);
2254 /* Enter the class or namespace scope indicated by T suitable for name
2255 lookup. T can be arbitrary scope, not necessary nested inside the
2256 current scope. Returns a non-null scope to pop iff pop_scope
2257 should be called later to exit this scope. */
2262 if (TREE_CODE (t) == NAMESPACE_DECL)
2263 push_decl_namespace (t);
2264 else if (CLASS_TYPE_P (t))
2266 if (!at_class_scope_p ()
2267 || !same_type_p (current_class_type, t))
2268 push_nested_class (t);
2270 /* T is the same as the current scope. There is therefore no
2271 need to re-enter the scope. Since we are not actually
2272 pushing a new scope, our caller should not call
2280 /* Leave scope pushed by push_scope. */
2285 if (TREE_CODE (t) == NAMESPACE_DECL)
2286 pop_decl_namespace ();
2287 else if CLASS_TYPE_P (t)
2288 pop_nested_class ();
2291 /* Subroutine of push_inner_scope. */
2294 push_inner_scope_r (tree outer, tree inner)
2299 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2302 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2304 push_inner_scope_r (outer, prev);
2305 if (TREE_CODE (inner) == NAMESPACE_DECL)
2307 struct cp_binding_level *save_template_parm = 0;
2308 /* Temporary take out template parameter scopes. They are saved
2309 in reversed order in save_template_parm. */
2310 while (current_binding_level->kind == sk_template_parms)
2312 struct cp_binding_level *b = current_binding_level;
2313 current_binding_level = b->level_chain;
2314 b->level_chain = save_template_parm;
2315 save_template_parm = b;
2318 resume_scope (NAMESPACE_LEVEL (inner));
2319 current_namespace = inner;
2321 /* Restore template parameter scopes. */
2322 while (save_template_parm)
2324 struct cp_binding_level *b = save_template_parm;
2325 save_template_parm = b->level_chain;
2326 b->level_chain = current_binding_level;
2327 current_binding_level = b;
2334 /* Enter the scope INNER from current scope. INNER must be a scope
2335 nested inside current scope. This works with both name lookup and
2336 pushing name into scope. In case a template parameter scope is present,
2337 namespace is pushed under the template parameter scope according to
2338 name lookup rule in 14.6.1/6.
2340 Return the former current scope suitable for pop_inner_scope. */
2343 push_inner_scope (tree inner)
2345 tree outer = current_scope ();
2347 outer = current_namespace;
2349 push_inner_scope_r (outer, inner);
2353 /* Exit the current scope INNER back to scope OUTER. */
2356 pop_inner_scope (tree outer, tree inner)
2359 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2362 while (outer != inner)
2364 if (TREE_CODE (inner) == NAMESPACE_DECL)
2366 struct cp_binding_level *save_template_parm = 0;
2367 /* Temporary take out template parameter scopes. They are saved
2368 in reversed order in save_template_parm. */
2369 while (current_binding_level->kind == sk_template_parms)
2371 struct cp_binding_level *b = current_binding_level;
2372 current_binding_level = b->level_chain;
2373 b->level_chain = save_template_parm;
2374 save_template_parm = b;
2379 /* Restore template parameter scopes. */
2380 while (save_template_parm)
2382 struct cp_binding_level *b = save_template_parm;
2383 save_template_parm = b->level_chain;
2384 b->level_chain = current_binding_level;
2385 current_binding_level = b;
2391 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2395 /* Do a pushlevel for class declarations. */
2398 pushlevel_class (void)
2400 if (ENABLE_SCOPE_CHECKING)
2403 class_binding_level = begin_scope (sk_class, current_class_type);
2406 /* ...and a poplevel for class declarations. */
2409 poplevel_class (void)
2411 struct cp_binding_level *level = class_binding_level;
2412 cp_class_binding *cb;
2416 timevar_push (TV_NAME_LOOKUP);
2417 gcc_assert (level != 0);
2419 /* If we're leaving a toplevel class, cache its binding level. */
2420 if (current_class_depth == 1)
2421 previous_class_level = level;
2422 for (shadowed = level->type_shadowed;
2424 shadowed = TREE_CHAIN (shadowed))
2425 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2427 /* Remove the bindings for all of the class-level declarations. */
2428 if (level->class_shadowed)
2431 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2433 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2434 ggc_free (level->class_shadowed);
2435 level->class_shadowed = NULL;
2438 /* Now, pop out of the binding level which we created up in the
2439 `pushlevel_class' routine. */
2440 if (ENABLE_SCOPE_CHECKING)
2444 timevar_pop (TV_NAME_LOOKUP);
2447 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2448 appropriate. DECL is the value to which a name has just been
2449 bound. CLASS_TYPE is the class in which the lookup occurred. */
2452 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2455 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2459 if (TREE_CODE (decl) == OVERLOAD)
2460 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2463 gcc_assert (DECL_P (decl));
2464 context = context_for_name_lookup (decl);
2467 if (is_properly_derived_from (class_type, context))
2468 INHERITED_VALUE_BINDING_P (binding) = 1;
2470 INHERITED_VALUE_BINDING_P (binding) = 0;
2472 else if (binding->value == decl)
2473 /* We only encounter a TREE_LIST when there is an ambiguity in the
2474 base classes. Such an ambiguity can be overridden by a
2475 definition in this class. */
2476 INHERITED_VALUE_BINDING_P (binding) = 1;
2478 INHERITED_VALUE_BINDING_P (binding) = 0;
2481 /* Make the declaration of X appear in CLASS scope. */
2484 pushdecl_class_level (tree x)
2487 bool is_valid = true;
2489 timevar_push (TV_NAME_LOOKUP);
2490 /* Get the name of X. */
2491 if (TREE_CODE (x) == OVERLOAD)
2492 name = DECL_NAME (get_first_fn (x));
2494 name = DECL_NAME (x);
2498 is_valid = push_class_level_binding (name, x);
2499 if (TREE_CODE (x) == TYPE_DECL)
2500 set_identifier_type_value (name, x);
2502 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2504 /* If X is an anonymous aggregate, all of its members are
2505 treated as if they were members of the class containing the
2506 aggregate, for naming purposes. */
2509 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2511 location_t save_location = input_location;
2512 input_location = DECL_SOURCE_LOCATION (f);
2513 if (!pushdecl_class_level (f))
2515 input_location = save_location;
2518 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2521 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2522 scope. If the value returned is non-NULL, and the PREVIOUS field
2523 is not set, callers must set the PREVIOUS field explicitly. */
2525 static cxx_binding *
2526 get_class_binding (tree name, cxx_scope *scope)
2531 cxx_binding *binding;
2533 class_type = scope->this_entity;
2535 /* Get the type binding. */
2536 type_binding = lookup_member (class_type, name,
2537 /*protect=*/2, /*want_type=*/true);
2538 /* Get the value binding. */
2539 value_binding = lookup_member (class_type, name,
2540 /*protect=*/2, /*want_type=*/false);
2543 && (TREE_CODE (value_binding) == TYPE_DECL
2544 || DECL_CLASS_TEMPLATE_P (value_binding)
2545 || (TREE_CODE (value_binding) == TREE_LIST
2546 && TREE_TYPE (value_binding) == error_mark_node
2547 && (TREE_CODE (TREE_VALUE (value_binding))
2549 /* We found a type binding, even when looking for a non-type
2550 binding. This means that we already processed this binding
2553 else if (value_binding)
2555 if (TREE_CODE (value_binding) == TREE_LIST
2556 && TREE_TYPE (value_binding) == error_mark_node)
2557 /* NAME is ambiguous. */
2559 else if (BASELINK_P (value_binding))
2560 /* NAME is some overloaded functions. */
2561 value_binding = BASELINK_FUNCTIONS (value_binding);
2564 /* If we found either a type binding or a value binding, create a
2565 new binding object. */
2566 if (type_binding || value_binding)
2568 binding = new_class_binding (name,
2572 /* This is a class-scope binding, not a block-scope binding. */
2573 LOCAL_BINDING_P (binding) = 0;
2574 set_inherited_value_binding_p (binding, value_binding, class_type);
2582 /* Make the declaration(s) of X appear in CLASS scope under the name
2583 NAME. Returns true if the binding is valid. */
2586 push_class_level_binding (tree name, tree x)
2588 cxx_binding *binding;
2592 timevar_push (TV_NAME_LOOKUP);
2593 /* The class_binding_level will be NULL if x is a template
2594 parameter name in a member template. */
2595 if (!class_binding_level)
2596 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2598 /* Check for invalid member names. */
2599 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2600 /* We could have been passed a tree list if this is an ambiguous
2601 declaration. If so, pull the declaration out because
2602 check_template_shadow will not handle a TREE_LIST. */
2603 if (TREE_CODE (decl) == TREE_LIST
2604 && TREE_TYPE (decl) == error_mark_node)
2605 decl = TREE_VALUE (decl);
2607 check_template_shadow (decl);
2611 If T is the name of a class, then each of the following shall
2612 have a name different from T:
2614 -- every static data member of class T;
2616 -- every member of class T that is itself a type;
2618 -- every enumerator of every member of class T that is an
2621 -- every member of every anonymous union that is a member of
2624 (Non-static data members were also forbidden to have the same
2625 name as T until TC1.) */
2626 if ((TREE_CODE (x) == VAR_DECL
2627 || TREE_CODE (x) == CONST_DECL
2628 || (TREE_CODE (x) == TYPE_DECL
2629 && !DECL_SELF_REFERENCE_P (x))
2630 /* A data member of an anonymous union. */
2631 || (TREE_CODE (x) == FIELD_DECL
2632 && DECL_CONTEXT (x) != current_class_type))
2633 && DECL_NAME (x) == constructor_name (current_class_type))
2635 tree scope = context_for_name_lookup (x);
2636 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2638 error ("%qD has the same name as the class in which it is "
2641 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2645 /* Get the current binding for NAME in this class, if any. */
2646 binding = IDENTIFIER_BINDING (name);
2647 if (!binding || binding->scope != class_binding_level)
2649 binding = get_class_binding (name, class_binding_level);
2650 /* If a new binding was created, put it at the front of the
2651 IDENTIFIER_BINDING list. */
2654 binding->previous = IDENTIFIER_BINDING (name);
2655 IDENTIFIER_BINDING (name) = binding;
2659 /* If there is already a binding, then we may need to update the
2661 if (binding && binding->value)
2663 tree bval = binding->value;
2664 tree old_decl = NULL_TREE;
2666 if (INHERITED_VALUE_BINDING_P (binding))
2668 /* If the old binding was from a base class, and was for a
2669 tag name, slide it over to make room for the new binding.
2670 The old binding is still visible if explicitly qualified
2671 with a class-key. */
2672 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2673 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2675 old_decl = binding->type;
2676 binding->type = bval;
2677 binding->value = NULL_TREE;
2678 INHERITED_VALUE_BINDING_P (binding) = 0;
2683 /* Any inherited type declaration is hidden by the type
2684 declaration in the derived class. */
2685 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2686 binding->type = NULL_TREE;
2689 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2691 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2692 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2693 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2695 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2698 if (old_decl && binding->scope == class_binding_level)
2701 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2702 here. This function is only used to register bindings
2703 from with the class definition itself. */
2704 INHERITED_VALUE_BINDING_P (binding) = 0;
2705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2709 /* Note that we declared this value so that we can issue an error if
2710 this is an invalid redeclaration of a name already used for some
2712 note_name_declared_in_class (name, decl);
2714 /* If we didn't replace an existing binding, put the binding on the
2715 stack of bindings for the identifier, and update the shadowed
2717 if (binding && binding->scope == class_binding_level)
2718 /* Supplement the existing binding. */
2719 ok = supplement_binding (binding, decl);
2722 /* Create a new binding. */
2723 push_binding (name, decl, class_binding_level);
2727 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2730 /* Process "using SCOPE::NAME" in a class scope. Return the
2731 USING_DECL created. */
2734 do_class_using_decl (tree scope, tree name)
2736 /* The USING_DECL returned by this function. */
2738 /* The declaration (or declarations) name by this using
2739 declaration. NULL if we are in a template and cannot figure out
2740 what has been named. */
2742 /* True if SCOPE is a dependent type. */
2743 bool scope_dependent_p;
2744 /* True if SCOPE::NAME is dependent. */
2745 bool name_dependent_p;
2746 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2747 bool bases_dependent_p;
2752 if (!scope || !TYPE_P (scope))
2754 error ("using-declaration for non-member at class scope");
2758 /* Make sure the name is not invalid */
2759 if (TREE_CODE (name) == BIT_NOT_EXPR)
2761 error ("%<%T::%D%> names destructor", scope, name);
2764 if (constructor_name_p (name, scope))
2766 error ("%<%T::%D%> names constructor", scope, name);
2769 if (constructor_name_p (name, current_class_type))
2771 error ("%<%T::%D%> names constructor in %qT",
2772 scope, name, current_class_type);
2776 scope_dependent_p = dependent_type_p (scope);
2777 name_dependent_p = (scope_dependent_p
2778 || (IDENTIFIER_TYPENAME_P (name)
2779 && dependent_type_p (TREE_TYPE (name))));
2781 bases_dependent_p = false;
2782 if (processing_template_decl)
2783 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2784 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2786 if (dependent_type_p (TREE_TYPE (base_binfo)))
2788 bases_dependent_p = true;
2794 /* From [namespace.udecl]:
2796 A using-declaration used as a member-declaration shall refer to a
2797 member of a base class of the class being defined.
2799 In general, we cannot check this constraint in a template because
2800 we do not know the entire set of base classes of the current
2801 class type. However, if all of the base classes are
2802 non-dependent, then we can avoid delaying the check until
2804 if (!scope_dependent_p && !bases_dependent_p)
2808 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2809 if (b_kind < bk_proper_base)
2811 error_not_base_type (scope, current_class_type);
2815 if (!name_dependent_p)
2817 decl = lookup_member (binfo, name, 0, false);
2820 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2824 /* The binfo from which the functions came does not matter. */
2825 if (BASELINK_P (decl))
2826 decl = BASELINK_FUNCTIONS (decl);
2830 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2831 USING_DECL_DECLS (value) = decl;
2832 USING_DECL_SCOPE (value) = scope;
2833 DECL_DEPENDENT_P (value) = !decl;
2839 /* Return the binding value for name in scope. */
2842 namespace_binding (tree name, tree scope)
2844 cxx_binding *binding;
2847 scope = global_namespace;
2849 /* Unnecessary for the global namespace because it can't be an alias. */
2850 scope = ORIGINAL_NAMESPACE (scope);
2852 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2854 return binding ? binding->value : NULL_TREE;
2857 /* Set the binding value for name in scope. */
2860 set_namespace_binding (tree name, tree scope, tree val)
2864 timevar_push (TV_NAME_LOOKUP);
2865 if (scope == NULL_TREE)
2866 scope = global_namespace;
2867 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2868 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2871 supplement_binding (b, val);
2872 timevar_pop (TV_NAME_LOOKUP);
2875 /* Set the context of a declaration to scope. Complain if we are not
2879 set_decl_namespace (tree decl, tree scope, bool friendp)
2883 /* Get rid of namespace aliases. */
2884 scope = ORIGINAL_NAMESPACE (scope);
2886 /* It is ok for friends to be qualified in parallel space. */
2887 if (!friendp && !is_ancestor (current_namespace, scope))
2888 error ("declaration of %qD not in a namespace surrounding %qD",
2890 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2892 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2893 if (scope == current_namespace)
2895 if (at_namespace_scope_p ())
2896 error ("explicit qualification in declaration of %qD",
2901 /* See whether this has been declared in the namespace. */
2902 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2904 /* No old declaration at all. */
2906 if (!is_overloaded_fn (decl))
2907 /* Don't compare non-function decls with decls_match here, since
2908 it can't check for the correct constness at this
2909 point. pushdecl will find those errors later. */
2911 /* Since decl is a function, old should contain a function decl. */
2912 if (!is_overloaded_fn (old))
2914 fn = OVL_CURRENT (old);
2915 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2917 /* A template can be explicitly specialized in any namespace. */
2918 if (processing_explicit_instantiation)
2920 if (processing_template_decl || processing_specialization)
2921 /* We have not yet called push_template_decl to turn a
2922 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2923 match. But, we'll check later, when we construct the
2926 /* Instantiations or specializations of templates may be declared as
2927 friends in any namespace. */
2928 if (friendp && DECL_USE_TEMPLATE (decl))
2930 if (is_overloaded_fn (old))
2932 for (; old; old = OVL_NEXT (old))
2933 if (decls_match (decl, OVL_CURRENT (old)))
2936 else if (decls_match (decl, old))
2939 error ("%qD should have been declared inside %qD", decl, scope);
2942 /* Return the namespace where the current declaration is declared. */
2945 current_decl_namespace (void)
2948 /* If we have been pushed into a different namespace, use it. */
2949 if (decl_namespace_list)
2950 return TREE_PURPOSE (decl_namespace_list);
2952 if (current_class_type)
2953 result = decl_namespace_context (current_class_type);
2954 else if (current_function_decl)
2955 result = decl_namespace_context (current_function_decl);
2957 result = current_namespace;
2961 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2962 select a name that is unique to this compilation unit. */
2965 push_namespace (tree name)
2967 push_namespace_with_attribs (name, NULL_TREE);
2970 /* Same, but specify attributes to apply to the namespace. The attributes
2971 only apply to the current namespace-body, not to any later extensions. */
2974 push_namespace_with_attribs (tree name, tree attributes)
2978 int implicit_use = 0;
2981 timevar_push (TV_NAME_LOOKUP);
2983 /* We should not get here if the global_namespace is not yet constructed
2984 nor if NAME designates the global namespace: The global scope is
2985 constructed elsewhere. */
2986 gcc_assert (global_namespace != NULL && name != global_scope_name);
2990 /* The name of anonymous namespace is unique for the translation
2992 if (!anonymous_namespace_name)
2993 anonymous_namespace_name = get_file_function_name ('N');
2994 name = anonymous_namespace_name;
2995 d = IDENTIFIER_NAMESPACE_VALUE (name);
2997 /* Reopening anonymous namespace. */
3003 /* Check whether this is an extended namespace definition. */
3004 d = IDENTIFIER_NAMESPACE_VALUE (name);
3005 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3008 if (DECL_NAMESPACE_ALIAS (d))
3010 error ("namespace alias %qD not allowed here, assuming %qD",
3011 d, DECL_NAMESPACE_ALIAS (d));
3012 d = DECL_NAMESPACE_ALIAS (d);
3019 /* Make a new namespace, binding the name to it. */
3020 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3021 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3022 TREE_PUBLIC (d) = 1;
3026 /* Clear DECL_NAME for the benefit of debugging back ends. */
3027 SET_DECL_ASSEMBLER_NAME (d, name);
3028 DECL_NAME (d) = NULL_TREE;
3030 begin_scope (sk_namespace, d);
3033 resume_scope (NAMESPACE_LEVEL (d));
3036 do_using_directive (d);
3037 /* Enter the name space. */
3038 current_namespace = d;
3040 #ifdef HANDLE_PRAGMA_VISIBILITY
3041 /* Clear has_visibility in case a previous namespace-definition had a
3042 visibility attribute and this one doesn't. */
3043 current_binding_level->has_visibility = 0;
3044 for (d = attributes; d; d = TREE_CHAIN (d))
3046 tree name = TREE_PURPOSE (d);
3047 tree args = TREE_VALUE (d);
3050 if (! is_attribute_p ("visibility", name))
3052 warning (OPT_Wattributes, "%qs attribute directive ignored",
3053 IDENTIFIER_POINTER (name));
3057 x = args ? TREE_VALUE (args) : NULL_TREE;
3058 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3060 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3061 IDENTIFIER_POINTER (name));
3065 current_binding_level->has_visibility = 1;
3066 push_visibility (TREE_STRING_POINTER (x));
3071 /* Anonymous namespaces default to hidden visibility. This might
3072 change once we implement export. */
3073 current_binding_level->has_visibility = 1;
3074 push_visibility ("hidden");
3079 timevar_pop (TV_NAME_LOOKUP);
3082 /* Pop from the scope of the current namespace. */
3085 pop_namespace (void)
3087 gcc_assert (current_namespace != global_namespace);
3088 current_namespace = CP_DECL_CONTEXT (current_namespace);
3089 /* The binding level is not popped, as it might be re-opened later. */
3093 /* Push into the scope of the namespace NS, even if it is deeply
3094 nested within another namespace. */
3097 push_nested_namespace (tree ns)
3099 if (ns == global_namespace)
3100 push_to_top_level ();
3103 push_nested_namespace (CP_DECL_CONTEXT (ns));
3104 push_namespace (DECL_NAME (ns));
3108 /* Pop back from the scope of the namespace NS, which was previously
3109 entered with push_nested_namespace. */
3112 pop_nested_namespace (tree ns)
3114 timevar_push (TV_NAME_LOOKUP);
3115 while (ns != global_namespace)
3118 ns = CP_DECL_CONTEXT (ns);
3121 pop_from_top_level ();
3122 timevar_pop (TV_NAME_LOOKUP);
3125 /* Temporarily set the namespace for the current declaration. */
3128 push_decl_namespace (tree decl)
3130 if (TREE_CODE (decl) != NAMESPACE_DECL)
3131 decl = decl_namespace_context (decl);
3132 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3133 NULL_TREE, decl_namespace_list);
3136 /* [namespace.memdef]/2 */
3139 pop_decl_namespace (void)
3141 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3144 /* Return the namespace that is the common ancestor
3145 of two given namespaces. */
3148 namespace_ancestor (tree ns1, tree ns2)
3150 timevar_push (TV_NAME_LOOKUP);
3151 if (is_ancestor (ns1, ns2))
3152 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3153 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3154 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3157 /* Process a namespace-alias declaration. */
3160 do_namespace_alias (tree alias, tree namespace)
3162 if (namespace == error_mark_node)
3165 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3167 namespace = ORIGINAL_NAMESPACE (namespace);
3169 /* Build the alias. */
3170 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3171 DECL_NAMESPACE_ALIAS (alias) = namespace;
3172 DECL_EXTERNAL (alias) = 1;
3173 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3176 /* Emit debug info for namespace alias. */
3177 (*debug_hooks->global_decl) (alias);
3180 /* Like pushdecl, only it places X in the current namespace,
3184 pushdecl_namespace_level (tree x, bool is_friend)
3186 struct cp_binding_level *b = current_binding_level;
3189 timevar_push (TV_NAME_LOOKUP);
3190 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3192 /* Now, the type_shadowed stack may screw us. Munge it so it does
3194 if (TREE_CODE (t) == TYPE_DECL)
3196 tree name = DECL_NAME (t);
3198 tree *ptr = (tree *)0;
3199 for (; !global_scope_p (b); b = b->level_chain)
3201 tree shadowed = b->type_shadowed;
3202 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3203 if (TREE_PURPOSE (shadowed) == name)
3205 ptr = &TREE_VALUE (shadowed);
3206 /* Can't break out of the loop here because sometimes
3207 a binding level will have duplicate bindings for
3208 PT names. It's gross, but I haven't time to fix it. */
3211 newval = TREE_TYPE (t);
3212 if (ptr == (tree *)0)
3214 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3215 up here if this is changed to an assertion. --KR */
3216 SET_IDENTIFIER_TYPE_VALUE (name, t);
3223 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3226 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3227 directive is not directly from the source. Also find the common
3228 ancestor and let our users know about the new namespace */
3230 add_using_namespace (tree user, tree used, bool indirect)
3233 timevar_push (TV_NAME_LOOKUP);
3234 /* Using oneself is a no-op. */
3237 timevar_pop (TV_NAME_LOOKUP);
3240 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3241 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3242 /* Check if we already have this. */
3243 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3247 /* Promote to direct usage. */
3248 TREE_INDIRECT_USING (t) = 0;
3249 timevar_pop (TV_NAME_LOOKUP);
3253 /* Add used to the user's using list. */
3254 DECL_NAMESPACE_USING (user)
3255 = tree_cons (used, namespace_ancestor (user, used),
3256 DECL_NAMESPACE_USING (user));
3258 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3260 /* Add user to the used's users list. */
3261 DECL_NAMESPACE_USERS (used)
3262 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3264 /* Recursively add all namespaces used. */
3265 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3266 /* indirect usage */
3267 add_using_namespace (user, TREE_PURPOSE (t), 1);
3269 /* Tell everyone using us about the new used namespaces. */
3270 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3271 add_using_namespace (TREE_PURPOSE (t), used, 1);
3272 timevar_pop (TV_NAME_LOOKUP);
3275 /* Process a using-declaration not appearing in class or local scope. */
3278 do_toplevel_using_decl (tree decl, tree scope, tree name)
3280 tree oldval, oldtype, newval, newtype;
3281 tree orig_decl = decl;
3282 cxx_binding *binding;
3284 decl = validate_nonmember_using_decl (decl, scope, name);
3285 if (decl == NULL_TREE)
3288 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3290 oldval = binding->value;
3291 oldtype = binding->type;
3293 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3295 /* Emit debug info. */
3296 if (!processing_template_decl)
3297 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3299 /* Copy declarations found. */
3301 binding->value = newval;
3303 binding->type = newtype;
3306 /* Process a using-directive. */
3309 do_using_directive (tree namespace)
3311 tree context = NULL_TREE;
3313 if (namespace == error_mark_node)
3316 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3318 if (building_stmt_tree ())
3319 add_stmt (build_stmt (USING_STMT, namespace));
3320 namespace = ORIGINAL_NAMESPACE (namespace);
3322 if (!toplevel_bindings_p ())
3324 push_using_directive (namespace);
3325 context = current_scope ();
3330 add_using_namespace (current_namespace, namespace, 0);
3331 if (current_namespace != global_namespace)
3332 context = current_namespace;
3335 /* Emit debugging info. */
3336 if (!processing_template_decl)
3337 (*debug_hooks->imported_module_or_decl) (namespace, context);
3340 /* Deal with a using-directive seen by the parser. Currently we only
3341 handle attributes here, since they cannot appear inside a template. */
3344 parse_using_directive (tree namespace, tree attribs)
3348 do_using_directive (namespace);
3350 for (a = attribs; a; a = TREE_CHAIN (a))
3352 tree name = TREE_PURPOSE (a);
3353 if (is_attribute_p ("strong", name))
3355 if (!toplevel_bindings_p ())
3356 error ("strong using only meaningful at namespace scope");
3357 else if (namespace != error_mark_node)
3359 if (!is_ancestor (current_namespace, namespace))
3360 error ("current namespace %qD does not enclose strongly used namespace %qD",
3361 current_namespace, namespace);
3362 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3363 = tree_cons (current_namespace, 0,
3364 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3368 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3372 /* Like pushdecl, only it places X in the global scope if appropriate.
3373 Calls cp_finish_decl to register the variable, initializing it with
3374 *INIT, if INIT is non-NULL. */
3377 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3379 timevar_push (TV_NAME_LOOKUP);
3380 push_to_top_level ();
3381 x = pushdecl_namespace_level (x, is_friend);
3383 finish_decl (x, *init, NULL_TREE);
3384 pop_from_top_level ();
3385 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3388 /* Like pushdecl, only it places X in the global scope if appropriate. */
3391 pushdecl_top_level (tree x)
3393 return pushdecl_top_level_1 (x, NULL, false);
3396 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3399 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3401 return pushdecl_top_level_1 (x, NULL, is_friend);
3404 /* Like pushdecl, only it places X in the global scope if
3405 appropriate. Calls cp_finish_decl to register the variable,
3406 initializing it with INIT. */
3409 pushdecl_top_level_and_finish (tree x, tree init)
3411 return pushdecl_top_level_1 (x, &init, false);
3414 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3415 duplicates. The first list becomes the tail of the result.
3417 The algorithm is O(n^2). We could get this down to O(n log n) by
3418 doing a sort on the addresses of the functions, if that becomes
3422 merge_functions (tree s1, tree s2)
3424 for (; s2; s2 = OVL_NEXT (s2))
3426 tree fn2 = OVL_CURRENT (s2);
3429 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3431 tree fn1 = OVL_CURRENT (fns1);
3433 /* If the function from S2 is already in S1, there is no
3434 need to add it again. For `extern "C"' functions, we
3435 might have two FUNCTION_DECLs for the same function, in
3436 different namespaces; again, we only need one of them. */
3438 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3439 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3443 /* If we exhausted all of the functions in S1, FN2 is new. */
3445 s1 = build_overload (fn2, s1);
3450 /* This should return an error not all definitions define functions.
3451 It is not an error if we find two functions with exactly the
3452 same signature, only if these are selected in overload resolution.
3453 old is the current set of bindings, new the freshly-found binding.
3454 XXX Do we want to give *all* candidates in case of ambiguity?
3455 XXX In what way should I treat extern declarations?
3456 XXX I don't want to repeat the entire duplicate_decls here */
3459 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3463 gcc_assert (old != NULL);
3464 /* Copy the value. */
3467 switch (TREE_CODE (val))
3470 /* If we expect types or namespaces, and not templates,
3471 or this is not a template class. */
3472 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3473 && !DECL_CLASS_TEMPLATE_P (val))
3474 || hidden_name_p (val))
3478 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3481 case NAMESPACE_DECL:
3482 if (LOOKUP_TYPES_ONLY (flags))
3486 /* Ignore built-in functions that are still anticipated. */
3487 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3491 if (LOOKUP_QUALIFIERS_ONLY (flags))
3497 else if (val && val != old->value)
3499 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3500 old->value = merge_functions (old->value, val);
3503 old->value = tree_cons (NULL_TREE, old->value,
3504 build_tree_list (NULL_TREE, new->value));
3505 TREE_TYPE (old->value) = error_mark_node;
3508 /* ... and copy the type. */
3510 if (LOOKUP_NAMESPACES_ONLY (flags))
3514 else if (type && old->type != type)
3516 if (flags & LOOKUP_COMPLAIN)
3518 error ("%qD denotes an ambiguous type",name);
3519 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3520 error ("%J other type here", TYPE_MAIN_DECL (type));
3525 /* Return the declarations that are members of the namespace NS. */
3528 cp_namespace_decls (tree ns)
3530 return NAMESPACE_LEVEL (ns)->names;
3533 /* Combine prefer_type and namespaces_only into flags. */
3536 lookup_flags (int prefer_type, int namespaces_only)
3538 if (namespaces_only)
3539 return LOOKUP_PREFER_NAMESPACES;
3540 if (prefer_type > 1)
3541 return LOOKUP_PREFER_TYPES;
3542 if (prefer_type > 0)
3543 return LOOKUP_PREFER_BOTH;
3547 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3548 ignore it or not. Subroutine of lookup_name_real and
3549 lookup_type_scope. */
3552 qualify_lookup (tree val, int flags)
3554 if (val == NULL_TREE)
3556 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3558 if ((flags & LOOKUP_PREFER_TYPES)
3559 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3561 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3566 /* Given a lookup that returned VAL, decide if we want to ignore it or
3567 not based on DECL_ANTICIPATED. */
3570 hidden_name_p (tree val)
3573 && DECL_LANG_SPECIFIC (val)
3574 && DECL_ANTICIPATED (val))
3579 /* Remove any hidden friend functions from a possibly overloaded set
3583 remove_hidden_names (tree fns)
3588 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3590 else if (TREE_CODE (fns) == OVERLOAD)
3594 for (o = fns; o; o = OVL_NEXT (o))
3595 if (hidden_name_p (OVL_CURRENT (o)))
3601 for (o = fns; o; o = OVL_NEXT (o))
3602 if (!hidden_name_p (OVL_CURRENT (o)))
3603 n = build_overload (OVL_CURRENT (o), n);
3611 /* Select the right _DECL from multiple choices. */
3614 select_decl (const struct scope_binding *binding, int flags)
3617 val = binding->value;
3619 timevar_push (TV_NAME_LOOKUP);
3620 if (LOOKUP_NAMESPACES_ONLY (flags))
3622 /* We are not interested in types. */
3623 if (val && (TREE_CODE (val) == NAMESPACE_DECL
3624 || TREE_CODE (val) == TREE_LIST))
3625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3626 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3629 /* If looking for a type, or if there is no non-type binding, select
3630 the value binding. */
3631 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3632 val = binding->type;
3633 /* Don't return non-types if we really prefer types. */
3634 else if (val && LOOKUP_TYPES_ONLY (flags)
3635 && ! DECL_DECLARES_TYPE_P (val))
3638 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3641 /* Unscoped lookup of a global: iterate over current namespaces,
3642 considering using-directives. */
3645 unqualified_namespace_lookup (tree name, int flags)
3647 tree initial = current_decl_namespace ();
3648 tree scope = initial;
3650 struct cp_binding_level *level;
3651 tree val = NULL_TREE;
3652 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3654 timevar_push (TV_NAME_LOOKUP);
3656 for (; !val; scope = CP_DECL_CONTEXT (scope))
3659 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3663 if (b->value && hidden_name_p (b->value))
3664 /* Ignore anticipated built-in functions and friends. */
3667 binding.value = b->value;
3668 binding.type = b->type;
3671 /* Add all _DECLs seen through local using-directives. */
3672 for (level = current_binding_level;
3673 level->kind != sk_namespace;
3674 level = level->level_chain)
3675 if (!lookup_using_namespace (name, &binding, level->using_directives,
3677 /* Give up because of error. */
3678 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3680 /* Add all _DECLs seen through global using-directives. */
3681 /* XXX local and global using lists should work equally. */
3685 if (!lookup_using_namespace (name, &binding,
3686 DECL_NAMESPACE_USING (siter),
3688 /* Give up because of error. */
3689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3690 if (siter == scope) break;
3691 siter = CP_DECL_CONTEXT (siter);
3694 val = select_decl (&binding, flags);
3695 if (scope == global_namespace)
3698 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3701 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3702 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3705 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3706 declaration found. If no suitable declaration can be found,
3707 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3708 neither a class-type nor a namespace a diagnostic is issued. */
3711 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3715 if (TREE_CODE (scope) == NAMESPACE_DECL)
3717 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3719 flags |= LOOKUP_COMPLAIN;
3721 flags |= LOOKUP_PREFER_TYPES;
3722 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3723 return select_decl (&binding, flags);
3725 else if (is_aggr_type (scope, complain))
3728 t = lookup_member (scope, name, 2, is_type_p);
3733 return error_mark_node;
3736 /* Subroutine of unqualified_namespace_lookup:
3737 Add the bindings of NAME in used namespaces to VAL.
3738 We are currently looking for names in namespace SCOPE, so we
3739 look through USINGS for using-directives of namespaces
3740 which have SCOPE as a common ancestor with the current scope.
3741 Returns false on errors. */
3744 lookup_using_namespace (tree name, struct scope_binding *val,
3745 tree usings, tree scope, int flags)
3748 timevar_push (TV_NAME_LOOKUP);
3749 /* Iterate over all used namespaces in current, searching for using
3750 directives of scope. */
3751 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3752 if (TREE_VALUE (iter) == scope)
3754 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3756 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3757 /* Resolve ambiguities. */
3759 ambiguous_decl (name, val, val1, flags);
3761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3765 Accepts the NAME to lookup and its qualifying SCOPE.
3766 Returns the name/type pair found into the cxx_binding *RESULT,
3767 or false on error. */
3770 qualified_lookup_using_namespace (tree name, tree scope,
3771 struct scope_binding *result, int flags)
3773 /* Maintain a list of namespaces visited... */
3774 tree seen = NULL_TREE;
3775 /* ... and a list of namespace yet to see. */
3776 tree todo = NULL_TREE;
3777 tree todo_maybe = NULL_TREE;
3779 timevar_push (TV_NAME_LOOKUP);
3780 /* Look through namespace aliases. */
3781 scope = ORIGINAL_NAMESPACE (scope);
3782 while (scope && result->value != error_mark_node)
3784 cxx_binding *binding =
3785 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3786 seen = tree_cons (scope, NULL_TREE, seen);
3788 ambiguous_decl (name, result, binding, flags);
3790 /* Consider strong using directives always, and non-strong ones
3791 if we haven't found a binding yet. ??? Shouldn't we consider
3792 non-strong ones if the initial RESULT is non-NULL, but the
3793 binding in the given namespace is? */
3794 for (usings = DECL_NAMESPACE_USING (scope); usings;
3795 usings = TREE_CHAIN (usings))
3796 /* If this was a real directive, and we have not seen it. */
3797 if (!TREE_INDIRECT_USING (usings))
3799 /* Try to avoid queuing the same namespace more than once,
3800 the exception being when a namespace was already
3801 enqueued for todo_maybe and then a strong using is
3802 found for it. We could try to remove it from
3803 todo_maybe, but it's probably not worth the effort. */
3804 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3805 && !purpose_member (TREE_PURPOSE (usings), seen)
3806 && !purpose_member (TREE_PURPOSE (usings), todo))
3807 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3808 else if ((!result->value && !result->type)
3809 && !purpose_member (TREE_PURPOSE (usings), seen)
3810 && !purpose_member (TREE_PURPOSE (usings), todo)
3811 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3812 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3817 scope = TREE_PURPOSE (todo);
3818 todo = TREE_CHAIN (todo);
3821 && (!result->value && !result->type))
3823 scope = TREE_PURPOSE (todo_maybe);
3824 todo = TREE_CHAIN (todo_maybe);
3825 todo_maybe = NULL_TREE;
3828 scope = NULL_TREE; /* If there never was a todo list. */
3830 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3833 /* Return the innermost non-namespace binding for NAME from a scope
3834 containing BINDING, or, if BINDING is NULL, the current scope. If
3835 CLASS_P is false, then class bindings are ignored. */
3838 outer_binding (tree name,
3839 cxx_binding *binding,
3844 cxx_scope *outer_scope;
3848 scope = binding->scope->level_chain;
3849 outer = binding->previous;
3853 scope = current_binding_level;
3854 outer = IDENTIFIER_BINDING (name);
3856 outer_scope = outer ? outer->scope : NULL;
3858 /* Because we create class bindings lazily, we might be missing a
3859 class binding for NAME. If there are any class binding levels
3860 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3861 declared, we must lookup NAME in those class scopes. */
3863 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3865 if (scope->kind == sk_class)
3867 cxx_binding *class_binding;
3869 class_binding = get_class_binding (name, scope);
3872 /* Thread this new class-scope binding onto the
3873 IDENTIFIER_BINDING list so that future lookups
3875 class_binding->previous = outer;
3877 binding->previous = class_binding;
3879 IDENTIFIER_BINDING (name) = class_binding;
3880 return class_binding;
3883 scope = scope->level_chain;
3889 /* Return the innermost block-scope or class-scope value binding for
3890 NAME, or NULL_TREE if there is no such binding. */
3893 innermost_non_namespace_value (tree name)
3895 cxx_binding *binding;
3896 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3897 return binding ? binding->value : NULL_TREE;
3900 /* Look up NAME in the current binding level and its superiors in the
3901 namespace of variables, functions and typedefs. Return a ..._DECL
3902 node of some kind representing its definition if there is only one
3903 such declaration, or return a TREE_LIST with all the overloaded
3904 definitions if there are many, or return 0 if it is undefined.
3905 Hidden name, either friend declaration or built-in function, are
3908 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3909 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3910 Otherwise we prefer non-TYPE_DECLs.
3912 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3913 BLOCK_P is false, bindings in block scopes are ignored. */
3916 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3917 int namespaces_only, int flags)
3920 tree val = NULL_TREE;
3922 timevar_push (TV_NAME_LOOKUP);
3923 /* Conversion operators are handled specially because ordinary
3924 unqualified name lookup will not find template conversion
3926 if (IDENTIFIER_TYPENAME_P (name))
3928 struct cp_binding_level *level;
3930 for (level = current_binding_level;
3931 level && level->kind != sk_namespace;
3932 level = level->level_chain)
3937 /* A conversion operator can only be declared in a class
3939 if (level->kind != sk_class)
3942 /* Lookup the conversion operator in the class. */
3943 class_type = level->this_entity;
3944 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3949 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3952 flags |= lookup_flags (prefer_type, namespaces_only);
3954 /* First, look in non-namespace scopes. */
3956 if (current_class_type == NULL_TREE)
3959 if (block_p || !nonclass)
3960 for (iter = outer_binding (name, NULL, !nonclass);
3962 iter = outer_binding (name, iter, !nonclass))
3966 /* Skip entities we don't want. */
3967 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3970 /* If this is the kind of thing we're looking for, we're done. */
3971 if (qualify_lookup (iter->value, flags)
3972 && !hidden_name_p (iter->value))
3973 binding = iter->value;
3974 else if ((flags & LOOKUP_PREFER_TYPES)
3975 && qualify_lookup (iter->type, flags)
3976 && !hidden_name_p (iter->type))
3977 binding = iter->type;
3979 binding = NULL_TREE;
3988 /* Now lookup in namespace scopes. */
3990 val = unqualified_namespace_lookup (name, flags);
3992 /* If we have a single function from a using decl, pull it out. */
3993 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
3994 val = OVL_FUNCTION (val);
3996 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4000 lookup_name_nonclass (tree name)
4002 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4006 lookup_function_nonclass (tree name, tree args, bool block_p)
4009 lookup_arg_dependent (name,
4010 lookup_name_real (name, 0, 1, block_p, 0,
4016 lookup_name (tree name)
4018 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4022 lookup_name_prefer_type (tree name, int prefer_type)
4024 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4025 0, LOOKUP_COMPLAIN);
4028 /* Look up NAME for type used in elaborated name specifier in
4029 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4030 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4031 name, more scopes are checked if cleanup or template parameter
4032 scope is encountered.
4034 Unlike lookup_name_real, we make sure that NAME is actually
4035 declared in the desired scope, not from inheritance, nor using
4036 directive. For using declaration, there is DR138 still waiting
4037 to be resolved. Hidden name coming from an earlier friend
4038 declaration is also returned.
4040 A TYPE_DECL best matching the NAME is returned. Catching error
4041 and issuing diagnostics are caller's responsibility. */
4044 lookup_type_scope (tree name, tag_scope scope)
4046 cxx_binding *iter = NULL;
4047 tree val = NULL_TREE;
4049 timevar_push (TV_NAME_LOOKUP);
4051 /* Look in non-namespace scope first. */
4052 if (current_binding_level->kind != sk_namespace)
4053 iter = outer_binding (name, NULL, /*class_p=*/ true);
4054 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4056 /* Check if this is the kind of thing we're looking for.
4057 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4058 base class. For ITER->VALUE, we can simply use
4059 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4062 We check ITER->TYPE before ITER->VALUE in order to handle
4063 typedef struct C {} C;
4066 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4067 && (scope != ts_current
4068 || LOCAL_BINDING_P (iter)
4069 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4071 else if ((scope != ts_current
4072 || !INHERITED_VALUE_BINDING_P (iter))
4073 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4080 /* Look in namespace scope. */
4083 iter = cxx_scope_find_binding_for_name
4084 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4088 /* If this is the kind of thing we're looking for, we're done. */
4089 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4091 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4097 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4098 and template parameter scopes. */
4101 struct cp_binding_level *b = current_binding_level;
4104 if (iter->scope == b)
4105 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4107 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4109 else if (b->kind == sk_class
4110 && scope == ts_within_enclosing_non_class)
4117 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4120 /* Similar to `lookup_name' but look only in the innermost non-class
4124 lookup_name_innermost_nonclass_level (tree name)
4126 struct cp_binding_level *b;
4129 timevar_push (TV_NAME_LOOKUP);
4130 b = innermost_nonclass_level ();
4132 if (b->kind == sk_namespace)
4134 t = IDENTIFIER_NAMESPACE_VALUE (name);
4136 /* extern "C" function() */
4137 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4140 else if (IDENTIFIER_BINDING (name)
4141 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4143 cxx_binding *binding;
4144 binding = IDENTIFIER_BINDING (name);
4147 if (binding->scope == b
4148 && !(TREE_CODE (binding->value) == VAR_DECL
4149 && DECL_DEAD_FOR_LOCAL (binding->value)))
4150 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4152 if (b->kind == sk_cleanup)
4159 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4162 /* Like lookup_name_innermost_nonclass_level, but for types. */
4165 lookup_type_current_level (tree name)
4169 timevar_push (TV_NAME_LOOKUP);
4170 gcc_assert (current_binding_level->kind != sk_namespace);
4172 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4173 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4175 struct cp_binding_level *b = current_binding_level;
4178 if (purpose_member (name, b->type_shadowed))
4179 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4180 REAL_IDENTIFIER_TYPE_VALUE (name));
4181 if (b->kind == sk_cleanup)
4188 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4191 /* [basic.lookup.koenig] */
4192 /* A nonzero return value in the functions below indicates an error. */
4203 static bool arg_assoc (struct arg_lookup*, tree);
4204 static bool arg_assoc_args (struct arg_lookup*, tree);
4205 static bool arg_assoc_type (struct arg_lookup*, tree);
4206 static bool add_function (struct arg_lookup *, tree);
4207 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4208 static bool arg_assoc_class (struct arg_lookup *, tree);
4209 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4211 /* Add a function to the lookup structure.
4212 Returns true on error. */
4215 add_function (struct arg_lookup *k, tree fn)
4217 /* We used to check here to see if the function was already in the list,
4218 but that's O(n^2), which is just too expensive for function lookup.
4219 Now we deal with the occasional duplicate in joust. In doing this, we
4220 assume that the number of duplicates will be small compared to the
4221 total number of functions being compared, which should usually be the
4224 /* We must find only functions, or exactly one non-function. */
4227 else if (fn == k->functions)
4229 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4230 k->functions = build_overload (fn, k->functions);
4233 tree f1 = OVL_CURRENT (k->functions);
4235 if (is_overloaded_fn (f1))
4237 fn = f1; f1 = f2; f2 = fn;
4239 error ("%q+D is not a function,", f1);
4240 error (" conflict with %q+D", f2);
4241 error (" in call to %qD", k->name);
4248 /* Returns true iff CURRENT has declared itself to be an associated
4249 namespace of SCOPE via a strong using-directive (or transitive chain
4250 thereof). Both are namespaces. */
4253 is_associated_namespace (tree current, tree scope)
4255 tree seen = NULL_TREE;
4256 tree todo = NULL_TREE;
4260 if (scope == current)
4262 seen = tree_cons (scope, NULL_TREE, seen);
4263 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4264 if (!purpose_member (TREE_PURPOSE (t), seen))
4265 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4268 scope = TREE_PURPOSE (todo);
4269 todo = TREE_CHAIN (todo);
4276 /* Return whether FN is a friend of an associated class of ARG. */
4279 friend_of_associated_class_p (tree arg, tree fn)
4285 else if (type_unknown_p (arg))
4288 type = TREE_TYPE (arg);
4290 /* If TYPE is a class, the class itself and all base classes are
4291 associated classes. */
4292 if (CLASS_TYPE_P (type))
4294 if (is_friend (type, fn))
4297 if (TYPE_BINFO (type))
4299 tree binfo, base_binfo;
4302 for (binfo = TYPE_BINFO (type), i = 0;
4303 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4305 if (is_friend (BINFO_TYPE (base_binfo), fn))
4310 /* If TYPE is a class member, the class of which it is a member is
4311 an associated class. */
4312 if ((CLASS_TYPE_P (type)
4313 || TREE_CODE (type) == UNION_TYPE
4314 || TREE_CODE (type) == ENUMERAL_TYPE)
4315 && TYPE_CONTEXT (type)
4316 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4317 && is_friend (TYPE_CONTEXT (type), fn))
4323 /* Add functions of a namespace to the lookup structure.
4324 Returns true on error. */
4327 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4331 if (purpose_member (scope, k->namespaces))
4333 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4335 /* Check out our super-users. */
4336 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4337 value = TREE_CHAIN (value))
4338 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4341 value = namespace_binding (k->name, scope);
4345 for (; value; value = OVL_NEXT (value))
4347 /* We don't want to find arbitrary hidden functions via argument
4348 dependent lookup. We only want to find friends of associated
4350 if (hidden_name_p (OVL_CURRENT (value)))
4354 for (args = k->args; args; args = TREE_CHAIN (args))
4355 if (friend_of_associated_class_p (TREE_VALUE (args),
4356 OVL_CURRENT (value)))
4362 if (add_function (k, OVL_CURRENT (value)))
4369 /* Adds everything associated with a template argument to the lookup
4370 structure. Returns true on error. */
4373 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4375 /* [basic.lookup.koenig]
4377 If T is a template-id, its associated namespaces and classes are
4378 ... the namespaces and classes associated with the types of the
4379 template arguments provided for template type parameters
4380 (excluding template template parameters); the namespaces in which
4381 any template template arguments are defined; and the classes in
4382 which any member templates used as template template arguments
4383 are defined. [Note: non-type template arguments do not
4384 contribute to the set of associated namespaces. ] */
4386 /* Consider first template template arguments. */
4387 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4388 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4390 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4392 tree ctx = CP_DECL_CONTEXT (arg);
4394 /* It's not a member template. */
4395 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4396 return arg_assoc_namespace (k, ctx);
4397 /* Otherwise, it must be member template. */
4399 return arg_assoc_class (k, ctx);
4401 /* It's not a template template argument, but it is a type template
4403 else if (TYPE_P (arg))
4404 return arg_assoc_type (k, arg);
4405 /* It's a non-type template argument. */
4410 /* Adds everything associated with class to the lookup structure.
4411 Returns true on error. */
4414 arg_assoc_class (struct arg_lookup *k, tree type)
4416 tree list, friends, context;
4419 /* Backend build structures, such as __builtin_va_list, aren't
4420 affected by all this. */
4421 if (!CLASS_TYPE_P (type))
4424 if (purpose_member (type, k->classes))
4426 k->classes = tree_cons (type, NULL_TREE, k->classes);
4428 context = decl_namespace_context (type);
4429 if (arg_assoc_namespace (k, context))
4432 if (TYPE_BINFO (type))
4434 /* Process baseclasses. */
4435 tree binfo, base_binfo;
4437 for (binfo = TYPE_BINFO (type), i = 0;
4438 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4439 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4443 /* Process friends. */
4444 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4445 list = TREE_CHAIN (list))
4446 if (k->name == FRIEND_NAME (list))
4447 for (friends = FRIEND_DECLS (list); friends;
4448 friends = TREE_CHAIN (friends))
4450 tree fn = TREE_VALUE (friends);
4452 /* Only interested in global functions with potentially hidden
4453 (i.e. unqualified) declarations. */
4454 if (CP_DECL_CONTEXT (fn) != context)
4456 /* Template specializations are never found by name lookup.
4457 (Templates themselves can be found, but not template
4458 specializations.) */
4459 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4461 if (add_function (k, fn))
4465 /* Process template arguments. */
4466 if (CLASSTYPE_TEMPLATE_INFO (type)
4467 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4469 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4470 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4471 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4477 /* Adds everything associated with a given type.
4478 Returns 1 on error. */
4481 arg_assoc_type (struct arg_lookup *k, tree type)
4483 /* As we do not get the type of non-type dependent expressions
4484 right, we can end up with such things without a type. */
4488 if (TYPE_PTRMEM_P (type))
4490 /* Pointer to member: associate class type and value type. */
4491 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4493 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4495 else switch (TREE_CODE (type))
4507 if (TYPE_PTRMEMFUNC_P (type))
4508 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4509 return arg_assoc_class (k, type);
4511 case REFERENCE_TYPE:
4513 return arg_assoc_type (k, TREE_TYPE (type));
4516 return arg_assoc_namespace (k, decl_namespace_context (type));
4518 /* The basetype is referenced in the first arg type, so just
4521 /* Associate the parameter types. */
4522 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4524 /* Associate the return type. */
4525 return arg_assoc_type (k, TREE_TYPE (type));
4526 case TEMPLATE_TYPE_PARM:
4527 case BOUND_TEMPLATE_TEMPLATE_PARM:
4532 gcc_assert (type == unknown_type_node);
4540 /* Adds everything associated with arguments. Returns true on error. */
4543 arg_assoc_args (struct arg_lookup *k, tree args)
4545 for (; args; args = TREE_CHAIN (args))
4546 if (arg_assoc (k, TREE_VALUE (args)))
4551 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4554 arg_assoc (struct arg_lookup *k, tree n)
4556 if (n == error_mark_node)
4560 return arg_assoc_type (k, n);
4562 if (! type_unknown_p (n))
4563 return arg_assoc_type (k, TREE_TYPE (n));
4565 if (TREE_CODE (n) == ADDR_EXPR)
4566 n = TREE_OPERAND (n, 0);
4567 if (TREE_CODE (n) == COMPONENT_REF)
4568 n = TREE_OPERAND (n, 1);
4569 if (TREE_CODE (n) == OFFSET_REF)
4570 n = TREE_OPERAND (n, 1);
4571 while (TREE_CODE (n) == TREE_LIST)
4573 if (TREE_CODE (n) == BASELINK)
4574 n = BASELINK_FUNCTIONS (n);
4576 if (TREE_CODE (n) == FUNCTION_DECL)
4577 return arg_assoc_type (k, TREE_TYPE (n));
4578 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4580 /* [basic.lookup.koenig]
4582 If T is a template-id, its associated namespaces and classes
4583 are the namespace in which the template is defined; for
4584 member templates, the member template's class... */
4585 tree template = TREE_OPERAND (n, 0);
4586 tree args = TREE_OPERAND (n, 1);
4590 if (TREE_CODE (template) == COMPONENT_REF)
4591 template = TREE_OPERAND (template, 1);
4593 /* First, the template. There may actually be more than one if
4594 this is an overloaded function template. But, in that case,
4595 we only need the first; all the functions will be in the same
4597 template = OVL_CURRENT (template);
4599 ctx = CP_DECL_CONTEXT (template);
4601 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4603 if (arg_assoc_namespace (k, ctx) == 1)
4606 /* It must be a member template. */
4607 else if (arg_assoc_class (k, ctx) == 1)
4610 /* Now the arguments. */
4612 for (ix = TREE_VEC_LENGTH (args); ix--;)
4613 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4616 else if (TREE_CODE (n) == OVERLOAD)
4618 for (; n; n = OVL_CHAIN (n))
4619 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4626 /* Performs Koenig lookup depending on arguments, where fns
4627 are the functions found in normal lookup. */
4630 lookup_arg_dependent (tree name, tree fns, tree args)
4632 struct arg_lookup k;
4634 timevar_push (TV_NAME_LOOKUP);
4636 /* Remove any hidden friend functions from the list of functions
4637 found so far. They will be added back by arg_assoc_class as
4639 fns = remove_hidden_names (fns);
4644 k.classes = NULL_TREE;
4646 /* We previously performed an optimization here by setting
4647 NAMESPACES to the current namespace when it was safe. However, DR
4648 164 says that namespaces that were already searched in the first
4649 stage of template processing are searched again (potentially
4650 picking up later definitions) in the second stage. */
4651 k.namespaces = NULL_TREE;
4653 arg_assoc_args (&k, args);
4654 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4657 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4658 changed (i.e. there was already a directive), or the fresh
4659 TREE_LIST otherwise. */
4662 push_using_directive (tree used)
4664 tree ud = current_binding_level->using_directives;
4665 tree iter, ancestor;
4667 timevar_push (TV_NAME_LOOKUP);
4668 /* Check if we already have this. */
4669 if (purpose_member (used, ud) != NULL_TREE)
4670 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4672 ancestor = namespace_ancestor (current_decl_namespace (), used);
4673 ud = current_binding_level->using_directives;
4674 ud = tree_cons (used, ancestor, ud);
4675 current_binding_level->using_directives = ud;
4677 /* Recursively add all namespaces used. */
4678 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4679 push_using_directive (TREE_PURPOSE (iter));
4681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4684 /* The type TYPE is being declared. If it is a class template, or a
4685 specialization of a class template, do any processing required and
4686 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4687 being declared a friend. B is the binding level at which this TYPE
4690 Returns the TYPE_DECL for TYPE, which may have been altered by this
4694 maybe_process_template_type_declaration (tree type, int is_friend,
4697 tree decl = TYPE_NAME (type);
4699 if (processing_template_parmlist)
4700 /* You can't declare a new template type in a template parameter
4701 list. But, you can declare a non-template type:
4703 template <class A*> struct S;
4705 is a forward-declaration of `A'. */
4707 else if (b->kind == sk_namespace
4708 && current_binding_level->kind != sk_namespace)
4709 /* If this new type is being injected into a containing scope,
4710 then it's not a template type. */
4714 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4716 if (processing_template_decl)
4718 /* This may change after the call to
4719 push_template_decl_real, but we want the original value. */
4720 tree name = DECL_NAME (decl);
4722 decl = push_template_decl_real (decl, is_friend);
4723 /* If the current binding level is the binding level for the
4724 template parameters (see the comment in
4725 begin_template_parm_list) and the enclosing level is a class
4726 scope, and we're not looking at a friend, push the
4727 declaration of the member class into the class scope. In the
4728 friend case, push_template_decl will already have put the
4729 friend into global scope, if appropriate. */
4730 if (TREE_CODE (type) != ENUMERAL_TYPE
4731 && !is_friend && b->kind == sk_template_parms
4732 && b->level_chain->kind == sk_class)
4734 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4736 if (!COMPLETE_TYPE_P (current_class_type))
4738 maybe_add_class_template_decl_list (current_class_type,
4739 type, /*friend_p=*/0);
4740 /* Put this UTD in the table of UTDs for the class. */
4741 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4742 CLASSTYPE_NESTED_UTDS (current_class_type) =
4743 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4745 binding_table_insert
4746 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4755 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4756 that the NAME is a class template, the tag is processed but not pushed.
4758 The pushed scope depend on the SCOPE parameter:
4759 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4761 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4762 non-template-parameter scope. This case is needed for forward
4764 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4765 TS_GLOBAL case except that names within template-parameter scopes
4766 are not pushed at all.
4768 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4771 pushtag (tree name, tree type, tag_scope scope)
4773 struct cp_binding_level *b;
4776 timevar_push (TV_NAME_LOOKUP);
4777 b = current_binding_level;
4778 while (/* Cleanup scopes are not scopes from the point of view of
4780 b->kind == sk_cleanup
4781 /* Neither are the scopes used to hold template parameters
4782 for an explicit specialization. For an ordinary template
4783 declaration, these scopes are not scopes from the point of
4784 view of the language. */
4785 || (b->kind == sk_template_parms
4786 && (b->explicit_spec_p || scope == ts_global))
4787 || (b->kind == sk_class
4788 && (scope != ts_current
4789 /* We may be defining a new type in the initializer
4790 of a static member variable. We allow this when
4791 not pedantic, and it is particularly useful for
4792 type punning via an anonymous union. */
4793 || COMPLETE_TYPE_P (b->this_entity))))
4796 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4798 /* Do C++ gratuitous typedefing. */
4799 if (IDENTIFIER_TYPE_VALUE (name) != type)
4803 tree context = TYPE_CONTEXT (type);
4807 tree cs = current_scope ();
4809 if (scope == ts_current)
4811 else if (cs != NULL_TREE && TYPE_P (cs))
4812 /* When declaring a friend class of a local class, we want
4813 to inject the newly named class into the scope
4814 containing the local class, not the namespace
4816 context = decl_function_context (get_type_decl (cs));
4819 context = current_namespace;
4821 if (b->kind == sk_class
4822 || (b->kind == sk_template_parms
4823 && b->level_chain->kind == sk_class))
4826 if (current_lang_name == lang_name_java)
4827 TYPE_FOR_JAVA (type) = 1;
4829 tdef = create_implicit_typedef (name, type);
4830 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4831 if (scope == ts_within_enclosing_non_class)
4833 /* This is a friend. Make this TYPE_DECL node hidden from
4834 ordinary name lookup. Its corresponding TEMPLATE_DECL
4835 will be marked in push_template_decl_real. */
4836 retrofit_lang_decl (tdef);
4837 DECL_ANTICIPATED (tdef) = 1;
4838 DECL_FRIEND_P (tdef) = 1;
4841 decl = maybe_process_template_type_declaration
4842 (type, scope == ts_within_enclosing_non_class, b);
4843 if (decl == error_mark_node)
4844 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4847 set_identifier_type_value_with_scope (name, tdef, b);
4849 if (b->kind == sk_class)
4851 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4852 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4853 class. But if it's a member template class, we want
4854 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4856 finish_member_declaration (decl);
4858 pushdecl_class_level (decl);
4860 else if (b->kind != sk_template_parms)
4861 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4863 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4865 /* If this is a local class, keep track of it. We need this
4866 information for name-mangling, and so that it is possible to
4867 find all function definitions in a translation unit in a
4868 convenient way. (It's otherwise tricky to find a member
4869 function definition it's only pointed to from within a local
4871 if (TYPE_CONTEXT (type)
4872 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4873 VEC_safe_push (tree, gc, local_classes, type);
4875 if (b->kind == sk_class
4876 && !COMPLETE_TYPE_P (current_class_type))
4878 maybe_add_class_template_decl_list (current_class_type,
4879 type, /*friend_p=*/0);
4881 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4882 CLASSTYPE_NESTED_UTDS (current_class_type)
4883 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4885 binding_table_insert
4886 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4889 decl = TYPE_NAME (type);
4890 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4891 TYPE_STUB_DECL (type) = decl;
4893 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4896 /* Subroutines for reverting temporarily to top-level for instantiation
4897 of templates and such. We actually need to clear out the class- and
4898 local-value slots of all identifiers, so that only the global values
4899 are at all visible. Simply setting current_binding_level to the global
4900 scope isn't enough, because more binding levels may be pushed. */
4901 struct saved_scope *scope_chain;
4903 /* If ID has not already been marked, add an appropriate binding to
4907 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4909 cxx_saved_binding *saved;
4911 if (!id || !IDENTIFIER_BINDING (id))
4914 if (IDENTIFIER_MARKED (id))
4917 IDENTIFIER_MARKED (id) = 1;
4919 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4920 saved->identifier = id;
4921 saved->binding = IDENTIFIER_BINDING (id);
4922 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4923 IDENTIFIER_BINDING (id) = NULL;
4927 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4931 timevar_push (TV_NAME_LOOKUP);
4932 for (t = names; t; t = TREE_CHAIN (t))
4936 if (TREE_CODE (t) == TREE_LIST)
4937 id = TREE_PURPOSE (t);
4941 store_binding (id, old_bindings);
4943 timevar_pop (TV_NAME_LOOKUP);
4946 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4947 objects, rather than a TREE_LIST. */
4950 store_class_bindings (VEC(cp_class_binding,gc) *names,
4951 VEC(cxx_saved_binding,gc) **old_bindings)
4954 cp_class_binding *cb;
4956 timevar_push (TV_NAME_LOOKUP);
4957 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4958 store_binding (cb->identifier, old_bindings);
4959 timevar_pop (TV_NAME_LOOKUP);
4963 push_to_top_level (void)
4965 struct saved_scope *s;
4966 struct cp_binding_level *b;
4967 cxx_saved_binding *sb;
4971 timevar_push (TV_NAME_LOOKUP);
4972 s = GGC_CNEW (struct saved_scope);
4974 b = scope_chain ? current_binding_level : 0;
4976 /* If we're in the middle of some function, save our state. */
4980 push_function_context_to (NULL_TREE);
4985 if (scope_chain && previous_class_level)
4986 store_class_bindings (previous_class_level->class_shadowed,
4989 /* Have to include the global scope, because class-scope decls
4990 aren't listed anywhere useful. */
4991 for (; b; b = b->level_chain)
4995 /* Template IDs are inserted into the global level. If they were
4996 inserted into namespace level, finish_file wouldn't find them
4997 when doing pending instantiations. Therefore, don't stop at
4998 namespace level, but continue until :: . */
4999 if (global_scope_p (b))
5002 store_bindings (b->names, &s->old_bindings);
5003 /* We also need to check class_shadowed to save class-level type
5004 bindings, since pushclass doesn't fill in b->names. */
5005 if (b->kind == sk_class)
5006 store_class_bindings (b->class_shadowed, &s->old_bindings);
5008 /* Unwind type-value slots back to top level. */
5009 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5010 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5013 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5014 IDENTIFIER_MARKED (sb->identifier) = 0;
5016 s->prev = scope_chain;
5018 s->need_pop_function_context = need_pop;
5019 s->function_decl = current_function_decl;
5020 s->skip_evaluation = skip_evaluation;
5023 current_function_decl = NULL_TREE;
5024 current_lang_base = VEC_alloc (tree, gc, 10);
5025 current_lang_name = lang_name_cplusplus;
5026 current_namespace = global_namespace;
5027 push_class_stack ();
5028 skip_evaluation = 0;
5029 timevar_pop (TV_NAME_LOOKUP);
5033 pop_from_top_level (void)
5035 struct saved_scope *s = scope_chain;
5036 cxx_saved_binding *saved;
5039 timevar_push (TV_NAME_LOOKUP);
5040 /* Clear out class-level bindings cache. */
5041 if (previous_class_level)
5042 invalidate_class_lookup_cache ();
5045 current_lang_base = 0;
5047 scope_chain = s->prev;
5048 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5050 tree id = saved->identifier;
5052 IDENTIFIER_BINDING (id) = saved->binding;
5053 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5056 /* If we were in the middle of compiling a function, restore our
5058 if (s->need_pop_function_context)
5059 pop_function_context_from (NULL_TREE);
5060 current_function_decl = s->function_decl;
5061 skip_evaluation = s->skip_evaluation;
5062 timevar_pop (TV_NAME_LOOKUP);
5065 /* Pop off extraneous binding levels left over due to syntax errors.
5067 We don't pop past namespaces, as they might be valid. */
5070 pop_everything (void)
5072 if (ENABLE_SCOPE_CHECKING)
5073 verbatim ("XXX entering pop_everything ()\n");
5074 while (!toplevel_bindings_p ())
5076 if (current_binding_level->kind == sk_class)
5077 pop_nested_class ();
5081 if (ENABLE_SCOPE_CHECKING)
5082 verbatim ("XXX leaving pop_everything ()\n");
5085 /* Emit debugging information for using declarations and directives.
5086 If input tree is overloaded fn then emit debug info for all
5090 cp_emit_debug_info_for_using (tree t, tree context)
5092 /* Don't try to emit any debug information if we have errors. */
5093 if (sorrycount || errorcount)
5096 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5097 of a builtin function. */
5098 if (TREE_CODE (t) == FUNCTION_DECL
5099 && DECL_EXTERNAL (t)
5100 && DECL_BUILT_IN (t))
5103 /* Do not supply context to imported_module_or_decl, if
5104 it is a global namespace. */
5105 if (context == global_namespace)
5106 context = NULL_TREE;
5109 t = BASELINK_FUNCTIONS (t);
5111 /* FIXME: Handle TEMPLATE_DECLs. */
5112 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5113 if (TREE_CODE (t) != TEMPLATE_DECL)
5114 (*debug_hooks->imported_module_or_decl) (t, context);
5117 #include "gt-cp-name-lookup.h"