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. Add
674 the decl into a hash table to make sure only
675 the previous decl in this case is seen by the
678 struct cxx_int_tree_map *h;
681 TREE_PUBLIC (x) = TREE_PUBLIC (t);
683 if (cp_function_chain->extern_decl_map == NULL)
684 cp_function_chain->extern_decl_map
685 = htab_create_ggc (20, cxx_int_tree_map_hash,
686 cxx_int_tree_map_eq, NULL);
688 h = GGC_NEW (struct cxx_int_tree_map);
689 h->uid = DECL_UID (x);
691 loc = htab_find_slot_with_hash
692 (cp_function_chain->extern_decl_map, h,
694 *(struct cxx_int_tree_map **) loc = h;
697 else if (TREE_CODE (t) == PARM_DECL)
699 gcc_assert (DECL_CONTEXT (t));
701 /* Check for duplicate params. */
702 if (duplicate_decls (x, t, is_friend))
703 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
705 else if ((DECL_EXTERN_C_FUNCTION_P (x)
706 || DECL_FUNCTION_TEMPLATE_P (x))
707 && is_overloaded_fn (t))
708 /* Don't do anything just yet. */;
709 else if (t == wchar_decl_node)
711 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
712 pedwarn ("redeclaration of %<wchar_t%> as %qT",
715 /* Throw away the redeclaration. */
716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
720 tree olddecl = duplicate_decls (x, t, is_friend);
722 /* If the redeclaration failed, we can stop at this
724 if (olddecl == error_mark_node)
725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
729 if (TREE_CODE (t) == TYPE_DECL)
730 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
734 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
736 /* A redeclaration of main, but not a duplicate of the
741 This function shall not be overloaded. */
742 error ("invalid redeclaration of %q+D", t);
744 /* We don't try to push this declaration since that
746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
751 check_template_shadow (x);
753 /* If this is a function conjured up by the backend, massage it
754 so it looks friendly. */
755 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
757 retrofit_lang_decl (x);
758 SET_DECL_LANGUAGE (x, lang_c);
761 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
763 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
766 if (!namespace_bindings_p ())
767 /* We do not need to create a binding for this name;
768 push_overloaded_decl will have already done so if
770 need_new_binding = 0;
772 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
774 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
776 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
780 /* If declaring a type as a typedef, copy the type (unless we're
781 at line 0), and install this TYPE_DECL as the new type's typedef
782 name. See the extensive comment in ../c-decl.c (pushdecl). */
783 if (TREE_CODE (x) == TYPE_DECL)
785 tree type = TREE_TYPE (x);
786 if (DECL_IS_BUILTIN (x))
788 if (TYPE_NAME (type) == 0)
789 TYPE_NAME (type) = x;
791 else if (type != error_mark_node && TYPE_NAME (type) != x
792 /* We don't want to copy the type when all we're
793 doing is making a TYPE_DECL for the purposes of
795 && (!TYPE_NAME (type)
796 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
798 DECL_ORIGINAL_TYPE (x) = type;
799 type = build_variant_type_copy (type);
800 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
801 TYPE_NAME (type) = x;
802 TREE_TYPE (x) = type;
805 if (type != error_mark_node
807 && TYPE_IDENTIFIER (type))
808 set_identifier_type_value (DECL_NAME (x), x);
811 /* Multiple external decls of the same identifier ought to match.
813 We get warnings about inline functions where they are defined.
814 We get warnings about other functions from push_overloaded_decl.
816 Avoid duplicate warnings where they are used. */
817 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
821 decl = IDENTIFIER_NAMESPACE_VALUE (name);
822 if (decl && TREE_CODE (decl) == OVERLOAD)
823 decl = OVL_FUNCTION (decl);
825 if (decl && decl != error_mark_node
826 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
827 /* If different sort of thing, we already gave an error. */
828 && TREE_CODE (decl) == TREE_CODE (x)
829 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
831 pedwarn ("type mismatch with previous external decl of %q#D", x);
832 pedwarn ("previous external decl of %q+#D", decl);
836 if (TREE_CODE (x) == FUNCTION_DECL
838 && !flag_friend_injection)
840 /* This is a new declaration of a friend function, so hide
841 it from ordinary function lookup. */
842 DECL_ANTICIPATED (x) = 1;
843 DECL_HIDDEN_FRIEND_P (x) = 1;
846 /* This name is new in its binding level.
847 Install the new declaration and return it. */
848 if (namespace_bindings_p ())
850 /* Install a global value. */
852 /* If the first global decl has external linkage,
853 warn if we later see static one. */
854 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
855 TREE_PUBLIC (name) = 1;
857 /* Bind the name for the entity. */
858 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
860 && (TREE_CODE (x) == TYPE_DECL
861 || TREE_CODE (x) == VAR_DECL
862 || TREE_CODE (x) == NAMESPACE_DECL
863 || TREE_CODE (x) == CONST_DECL
864 || TREE_CODE (x) == TEMPLATE_DECL))
865 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
867 /* If new decl is `static' and an `extern' was seen previously,
869 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
870 warn_extern_redeclared_static (x, t);
874 /* Here to install a non-global value. */
875 tree oldlocal = innermost_non_namespace_value (name);
876 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
878 if (need_new_binding)
880 push_local_binding (name, x, 0);
881 /* Because push_local_binding will hook X on to the
882 current_binding_level's name list, we don't want to
883 do that again below. */
884 need_new_binding = 0;
887 /* If this is a TYPE_DECL, push it into the type value slot. */
888 if (TREE_CODE (x) == TYPE_DECL)
889 set_identifier_type_value (name, x);
891 /* Clear out any TYPE_DECL shadowed by a namespace so that
892 we won't think this is a type. The C struct hack doesn't
893 go through namespaces. */
894 if (TREE_CODE (x) == NAMESPACE_DECL)
895 set_identifier_type_value (name, NULL_TREE);
902 && TREE_CODE (oldlocal) == VAR_DECL
903 && DECL_DEAD_FOR_LOCAL (oldlocal))
904 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
906 if (oldlocal == NULL_TREE)
907 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
910 /* If this is an extern function declaration, see if we
911 have a global definition or declaration for the function. */
912 if (oldlocal == NULL_TREE
914 && oldglobal != NULL_TREE
915 && TREE_CODE (x) == FUNCTION_DECL
916 && TREE_CODE (oldglobal) == FUNCTION_DECL)
918 /* We have one. Their types must agree. */
919 if (decls_match (x, oldglobal))
923 warning (0, "extern declaration of %q#D doesn't match", x);
924 warning (0, "global declaration %q+#D", oldglobal);
927 /* If we have a local external declaration,
928 and no file-scope declaration has yet been seen,
929 then if we later have a file-scope decl it must not be static. */
930 if (oldlocal == NULL_TREE
931 && oldglobal == NULL_TREE
934 TREE_PUBLIC (name) = 1;
936 /* Warn if shadowing an argument at the top level of the body. */
937 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
938 /* Inline decls shadow nothing. */
939 && !DECL_FROM_INLINE (x)
940 && TREE_CODE (oldlocal) == PARM_DECL
941 /* Don't check the `this' parameter. */
942 && !DECL_ARTIFICIAL (oldlocal))
946 /* Don't complain if it's from an enclosing function. */
947 if (DECL_CONTEXT (oldlocal) == current_function_decl
948 && TREE_CODE (x) != PARM_DECL)
950 /* Go to where the parms should be and see if we find
952 struct cp_binding_level *b = current_binding_level->level_chain;
954 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
955 /* Skip the ctor/dtor cleanup level. */
959 if (b->kind == sk_function_parms)
961 error ("declaration of %q#D shadows a parameter", x);
966 if (warn_shadow && !err)
968 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
969 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
973 /* Maybe warn if shadowing something else. */
974 else if (warn_shadow && !DECL_EXTERNAL (x)
975 /* No shadow warnings for internally generated vars. */
976 && ! DECL_ARTIFICIAL (x)
977 /* No shadow warnings for vars made for inlining. */
978 && ! DECL_FROM_INLINE (x))
982 if (current_class_ptr)
983 member = lookup_member (current_class_type,
986 /*want_type=*/false);
990 if (member && !TREE_STATIC (member))
992 /* Location of previous decl is not useful in this case. */
993 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
996 else if (oldlocal != NULL_TREE
997 && TREE_CODE (oldlocal) == VAR_DECL)
999 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1000 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1002 else if (oldglobal != NULL_TREE
1003 && TREE_CODE (oldglobal) == VAR_DECL)
1004 /* XXX shadow warnings in outer-more namespaces */
1006 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1008 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1013 if (TREE_CODE (x) == VAR_DECL)
1014 maybe_register_incomplete_var (x);
1017 if (need_new_binding)
1018 add_decl_to_level (x,
1019 DECL_NAMESPACE_SCOPE_P (x)
1020 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1021 : current_binding_level);
1023 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1026 /* Record a decl-node X as belonging to the current lexical scope. */
1031 return pushdecl_maybe_friend (x, false);
1034 /* Enter DECL into the symbol table, if that's appropriate. Returns
1035 DECL, or a modified version thereof. */
1038 maybe_push_decl (tree decl)
1040 tree type = TREE_TYPE (decl);
1042 /* Add this decl to the current binding level, but not if it comes
1043 from another scope, e.g. a static member variable. TEM may equal
1044 DECL or it may be a previous decl of the same name. */
1045 if (decl == error_mark_node
1046 || (TREE_CODE (decl) != PARM_DECL
1047 && DECL_CONTEXT (decl) != NULL_TREE
1048 /* Definitions of namespace members outside their namespace are
1050 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1051 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1052 || TREE_CODE (type) == UNKNOWN_TYPE
1053 /* The declaration of a template specialization does not affect
1054 the functions available for overload resolution, so we do not
1056 || (TREE_CODE (decl) == FUNCTION_DECL
1057 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1060 return pushdecl (decl);
1063 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1064 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1065 doesn't really belong to this binding level, that it got here
1066 through a using-declaration. */
1069 push_local_binding (tree id, tree decl, int flags)
1071 struct cp_binding_level *b;
1073 /* Skip over any local classes. This makes sense if we call
1074 push_local_binding with a friend decl of a local class. */
1075 b = innermost_nonclass_level ();
1077 if (lookup_name_innermost_nonclass_level (id))
1079 /* Supplement the existing binding. */
1080 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1081 /* It didn't work. Something else must be bound at this
1082 level. Do not add DECL to the list of things to pop
1087 /* Create a new binding. */
1088 push_binding (id, decl, b);
1090 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1091 /* We must put the OVERLOAD into a TREE_LIST since the
1092 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1093 decls that got here through a using-declaration. */
1094 decl = build_tree_list (NULL_TREE, decl);
1096 /* And put DECL on the list of things declared by the current
1098 add_decl_to_level (decl, b);
1101 /* Check to see whether or not DECL is a variable that would have been
1102 in scope under the ARM, but is not in scope under the ANSI/ISO
1103 standard. If so, issue an error message. If name lookup would
1104 work in both cases, but return a different result, this function
1105 returns the result of ANSI/ISO lookup. Otherwise, it returns
1109 check_for_out_of_scope_variable (tree decl)
1113 /* We only care about out of scope variables. */
1114 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1117 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1118 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1119 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1120 && DECL_DEAD_FOR_LOCAL (shadowed))
1121 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1122 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1124 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1127 if (!DECL_ERROR_REPORTED (decl))
1129 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1130 warning (0, " matches this %q+D under ISO standard rules",
1132 warning (0, " matches this %q+D under old rules", decl);
1133 DECL_ERROR_REPORTED (decl) = 1;
1138 /* If we have already complained about this declaration, there's no
1139 need to do it again. */
1140 if (DECL_ERROR_REPORTED (decl))
1143 DECL_ERROR_REPORTED (decl) = 1;
1145 if (TREE_TYPE (decl) == error_mark_node)
1148 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1150 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1152 error (" cannot use obsolete binding at %q+D because "
1153 "it has a destructor", decl);
1154 return error_mark_node;
1158 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1160 pedwarn (" using obsolete binding at %q+D", decl);
1166 /* true means unconditionally make a BLOCK for the next level pushed. */
1168 static bool keep_next_level_flag;
1170 static int binding_depth = 0;
1171 static int is_class_level = 0;
1178 for (i = 0; i < depth * 2; i++)
1182 /* Return a string describing the kind of SCOPE we have. */
1184 cxx_scope_descriptor (cxx_scope *scope)
1186 /* The order of this table must match the "scope_kind"
1188 static const char* scope_kind_names[] = {
1194 "function-parameter-scope",
1197 "template-parameter-scope",
1198 "template-explicit-spec-scope"
1200 const scope_kind kind = scope->explicit_spec_p
1201 ? sk_template_spec : scope->kind;
1203 return scope_kind_names[kind];
1206 /* Output a debugging information about SCOPE when performing
1209 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1211 const char *desc = cxx_scope_descriptor (scope);
1212 if (scope->this_entity)
1213 verbatim ("%s %s(%E) %p %d\n", action, desc,
1214 scope->this_entity, (void *) scope, line);
1216 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1219 /* Return the estimated initial size of the hashtable of a NAMESPACE
1222 static inline size_t
1223 namespace_scope_ht_size (tree ns)
1225 tree name = DECL_NAME (ns);
1227 return name == std_identifier
1228 ? NAMESPACE_STD_HT_SIZE
1229 : (name == global_scope_name
1230 ? GLOBAL_SCOPE_HT_SIZE
1231 : NAMESPACE_ORDINARY_HT_SIZE);
1234 /* A chain of binding_level structures awaiting reuse. */
1236 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1238 /* Insert SCOPE as the innermost binding level. */
1241 push_binding_level (struct cp_binding_level *scope)
1243 /* Add it to the front of currently active scopes stack. */
1244 scope->level_chain = current_binding_level;
1245 current_binding_level = scope;
1246 keep_next_level_flag = false;
1248 if (ENABLE_SCOPE_CHECKING)
1250 scope->binding_depth = binding_depth;
1251 indent (binding_depth);
1252 cxx_scope_debug (scope, input_line, "push");
1258 /* Create a new KIND scope and make it the top of the active scopes stack.
1259 ENTITY is the scope of the associated C++ entity (namespace, class,
1260 function); it is NULL otherwise. */
1263 begin_scope (scope_kind kind, tree entity)
1267 /* Reuse or create a struct for this binding level. */
1268 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1270 scope = free_binding_level;
1271 free_binding_level = scope->level_chain;
1274 scope = GGC_NEW (cxx_scope);
1275 memset (scope, 0, sizeof (cxx_scope));
1277 scope->this_entity = entity;
1278 scope->more_cleanups_ok = true;
1285 case sk_template_spec:
1286 scope->explicit_spec_p = true;
1287 kind = sk_template_parms;
1289 case sk_template_parms:
1295 case sk_function_parms:
1297 scope->keep = keep_next_level_flag;
1301 NAMESPACE_LEVEL (entity) = scope;
1302 scope->static_decls =
1303 VEC_alloc (tree, gc,
1304 DECL_NAME (entity) == std_identifier
1305 || DECL_NAME (entity) == global_scope_name
1310 /* Should not happen. */
1316 push_binding_level (scope);
1321 /* We're about to leave current scope. Pop the top of the stack of
1322 currently active scopes. Return the enclosing scope, now active. */
1327 cxx_scope *scope = current_binding_level;
1329 if (scope->kind == sk_namespace && class_binding_level)
1330 current_binding_level = class_binding_level;
1332 /* We cannot leave a scope, if there are none left. */
1333 if (NAMESPACE_LEVEL (global_namespace))
1334 gcc_assert (!global_scope_p (scope));
1336 if (ENABLE_SCOPE_CHECKING)
1338 indent (--binding_depth);
1339 cxx_scope_debug (scope, input_line, "leave");
1340 if (is_class_level != (scope == class_binding_level))
1342 indent (binding_depth);
1343 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1348 #ifdef HANDLE_PRAGMA_VISIBILITY
1349 if (scope->has_visibility)
1353 /* Move one nesting level up. */
1354 current_binding_level = scope->level_chain;
1356 /* Namespace-scopes are left most probably temporarily, not
1357 completely; they can be reopened later, e.g. in namespace-extension
1358 or any name binding activity that requires us to resume a
1359 namespace. For classes, we cache some binding levels. For other
1360 scopes, we just make the structure available for reuse. */
1361 if (scope->kind != sk_namespace
1362 && scope->kind != sk_class)
1364 scope->level_chain = free_binding_level;
1365 gcc_assert (!ENABLE_SCOPE_CHECKING
1366 || scope->binding_depth == binding_depth);
1367 free_binding_level = scope;
1370 /* Find the innermost enclosing class scope, and reset
1371 CLASS_BINDING_LEVEL appropriately. */
1372 if (scope->kind == sk_class)
1374 class_binding_level = NULL;
1375 for (scope = current_binding_level; scope; scope = scope->level_chain)
1376 if (scope->kind == sk_class)
1378 class_binding_level = scope;
1383 return current_binding_level;
1387 resume_scope (struct cp_binding_level* b)
1389 /* Resuming binding levels is meant only for namespaces,
1390 and those cannot nest into classes. */
1391 gcc_assert (!class_binding_level);
1392 /* Also, resuming a non-directly nested namespace is a no-no. */
1393 gcc_assert (b->level_chain == current_binding_level);
1394 current_binding_level = b;
1395 if (ENABLE_SCOPE_CHECKING)
1397 b->binding_depth = binding_depth;
1398 indent (binding_depth);
1399 cxx_scope_debug (b, input_line, "resume");
1405 /* Return the innermost binding level that is not for a class scope. */
1408 innermost_nonclass_level (void)
1412 b = current_binding_level;
1413 while (b->kind == sk_class)
1419 /* We're defining an object of type TYPE. If it needs a cleanup, but
1420 we're not allowed to add any more objects with cleanups to the current
1421 scope, create a new binding level. */
1424 maybe_push_cleanup_level (tree type)
1426 if (type != error_mark_node
1427 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1428 && current_binding_level->more_cleanups_ok == 0)
1430 begin_scope (sk_cleanup, NULL);
1431 current_binding_level->statement_list = push_stmt_list ();
1435 /* Nonzero if we are currently in the global binding level. */
1438 global_bindings_p (void)
1440 return global_scope_p (current_binding_level);
1443 /* True if we are currently in a toplevel binding level. This
1444 means either the global binding level or a namespace in a toplevel
1445 binding level. Since there are no non-toplevel namespace levels,
1446 this really means any namespace or template parameter level. We
1447 also include a class whose context is toplevel. */
1450 toplevel_bindings_p (void)
1452 struct cp_binding_level *b = innermost_nonclass_level ();
1454 return b->kind == sk_namespace || b->kind == sk_template_parms;
1457 /* True if this is a namespace scope, or if we are defining a class
1458 which is itself at namespace scope, or whose enclosing class is
1459 such a class, etc. */
1462 namespace_bindings_p (void)
1464 struct cp_binding_level *b = innermost_nonclass_level ();
1466 return b->kind == sk_namespace;
1469 /* True if the current level needs to have a BLOCK made. */
1474 return (current_binding_level->blocks != NULL_TREE
1475 || current_binding_level->keep
1476 || current_binding_level->kind == sk_cleanup
1477 || current_binding_level->names != NULL_TREE);
1480 /* Returns the kind of the innermost scope. */
1483 innermost_scope_kind (void)
1485 return current_binding_level->kind;
1488 /* Returns true if this scope was created to store template parameters. */
1491 template_parm_scope_p (void)
1493 return innermost_scope_kind () == sk_template_parms;
1496 /* If KEEP is true, make a BLOCK node for the next binding level,
1497 unconditionally. Otherwise, use the normal logic to decide whether
1498 or not to create a BLOCK. */
1501 keep_next_level (bool keep)
1503 keep_next_level_flag = keep;
1506 /* Return the list of declarations of the current level.
1507 Note that this list is in reverse order unless/until
1508 you nreverse it; and when you do nreverse it, you must
1509 store the result back using `storedecls' or you will lose. */
1514 return current_binding_level->names;
1517 /* For debugging. */
1518 static int no_print_functions = 0;
1519 static int no_print_builtins = 0;
1522 print_binding_level (struct cp_binding_level* lvl)
1526 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1527 if (lvl->more_cleanups_ok)
1528 fprintf (stderr, " more-cleanups-ok");
1529 if (lvl->have_cleanups)
1530 fprintf (stderr, " have-cleanups");
1531 fprintf (stderr, "\n");
1534 fprintf (stderr, " names:\t");
1535 /* We can probably fit 3 names to a line? */
1536 for (t = lvl->names; t; t = TREE_CHAIN (t))
1538 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1540 if (no_print_builtins
1541 && (TREE_CODE (t) == TYPE_DECL)
1542 && DECL_IS_BUILTIN (t))
1545 /* Function decls tend to have longer names. */
1546 if (TREE_CODE (t) == FUNCTION_DECL)
1553 fprintf (stderr, "\n\t");
1556 print_node_brief (stderr, "", t, 0);
1557 if (t == error_mark_node)
1561 fprintf (stderr, "\n");
1563 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1566 cp_class_binding *b;
1567 fprintf (stderr, " class-shadowed:");
1569 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1571 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1572 fprintf (stderr, "\n");
1574 if (lvl->type_shadowed)
1576 fprintf (stderr, " type-shadowed:");
1577 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1579 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1581 fprintf (stderr, "\n");
1586 print_other_binding_stack (struct cp_binding_level *stack)
1588 struct cp_binding_level *level;
1589 for (level = stack; !global_scope_p (level); level = level->level_chain)
1591 fprintf (stderr, "binding level %p\n", (void *) level);
1592 print_binding_level (level);
1597 print_binding_stack (void)
1599 struct cp_binding_level *b;
1600 fprintf (stderr, "current_binding_level=%p\n"
1601 "class_binding_level=%p\n"
1602 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1603 (void *) current_binding_level, (void *) class_binding_level,
1604 (void *) NAMESPACE_LEVEL (global_namespace));
1605 if (class_binding_level)
1607 for (b = class_binding_level; b; b = b->level_chain)
1608 if (b == current_binding_level)
1611 b = class_binding_level;
1613 b = current_binding_level;
1616 b = current_binding_level;
1617 print_other_binding_stack (b);
1618 fprintf (stderr, "global:\n");
1619 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1622 /* Return the type associated with id. */
1625 identifier_type_value (tree id)
1627 timevar_push (TV_NAME_LOOKUP);
1628 /* There is no type with that name, anywhere. */
1629 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1630 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1631 /* This is not the type marker, but the real thing. */
1632 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1633 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1634 /* Have to search for it. It must be on the global level, now.
1635 Ask lookup_name not to return non-types. */
1636 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1638 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1639 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1642 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1643 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1646 identifier_global_value (tree t)
1648 return IDENTIFIER_GLOBAL_VALUE (t);
1651 /* Push a definition of struct, union or enum tag named ID. into
1652 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1653 the tag ID is not already defined. */
1656 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1660 if (b->kind != sk_namespace)
1662 /* Shadow the marker, not the real thing, so that the marker
1663 gets restored later. */
1664 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1666 = tree_cons (id, old_type_value, b->type_shadowed);
1667 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1668 TREE_TYPE (b->type_shadowed) = type;
1672 cxx_binding *binding =
1673 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1676 supplement_binding (binding, decl);
1678 binding->value = decl;
1680 /* Store marker instead of real type. */
1681 type = global_type_node;
1683 SET_IDENTIFIER_TYPE_VALUE (id, type);
1686 /* As set_identifier_type_value_with_scope, but using
1687 current_binding_level. */
1690 set_identifier_type_value (tree id, tree decl)
1692 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1695 /* Return the name for the constructor (or destructor) for the
1696 specified class TYPE. When given a template, this routine doesn't
1697 lose the specialization. */
1700 constructor_name_full (tree type)
1702 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1705 /* Return the name for the constructor (or destructor) for the
1706 specified class. When given a template, return the plain
1707 unspecialized name. */
1710 constructor_name (tree type)
1713 name = constructor_name_full (type);
1714 if (IDENTIFIER_TEMPLATE (name))
1715 name = IDENTIFIER_TEMPLATE (name);
1719 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1722 constructor_name_p (tree name, tree type)
1729 if (TREE_CODE (name) != IDENTIFIER_NODE)
1732 ctor_name = constructor_name_full (type);
1733 if (name == ctor_name)
1735 if (IDENTIFIER_TEMPLATE (ctor_name)
1736 && name == IDENTIFIER_TEMPLATE (ctor_name))
1741 /* Counter used to create anonymous type names. */
1743 static GTY(()) int anon_cnt;
1745 /* Return an IDENTIFIER which can be used as a name for
1746 anonymous structs and unions. */
1749 make_anon_name (void)
1753 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1754 return get_identifier (buf);
1757 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1759 static inline cxx_binding *
1760 find_binding (cxx_scope *scope, cxx_binding *binding)
1762 timevar_push (TV_NAME_LOOKUP);
1764 for (; binding != NULL; binding = binding->previous)
1765 if (binding->scope == scope)
1766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1771 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1773 static inline cxx_binding *
1774 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1776 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1779 /* Fold-in case where NAME is used only once. */
1780 if (scope == b->scope && b->previous == NULL)
1782 return find_binding (scope, b);
1787 /* Always returns a binding for name in scope. If no binding is
1788 found, make a new one. */
1790 static cxx_binding *
1791 binding_for_name (cxx_scope *scope, tree name)
1793 cxx_binding *result;
1795 result = cxx_scope_find_binding_for_name (scope, name);
1798 /* Not found, make a new one. */
1799 result = cxx_binding_make (NULL, NULL);
1800 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1801 result->scope = scope;
1802 result->is_local = false;
1803 result->value_is_inherited = false;
1804 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1808 /* Insert another USING_DECL into the current binding level, returning
1809 this declaration. If this is a redeclaration, do nothing, and
1810 return NULL_TREE if this not in namespace scope (in namespace
1811 scope, a using decl might extend any previous bindings). */
1814 push_using_decl (tree scope, tree name)
1818 timevar_push (TV_NAME_LOOKUP);
1819 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1820 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1821 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1822 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1825 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1826 namespace_bindings_p () ? decl : NULL_TREE);
1827 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1828 USING_DECL_SCOPE (decl) = scope;
1829 TREE_CHAIN (decl) = current_binding_level->usings;
1830 current_binding_level->usings = decl;
1831 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1834 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1835 caller to set DECL_CONTEXT properly. */
1838 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1840 struct cp_binding_level *b;
1841 tree function_decl = current_function_decl;
1843 timevar_push (TV_NAME_LOOKUP);
1844 current_function_decl = NULL_TREE;
1845 if (level->kind == sk_class)
1847 b = class_binding_level;
1848 class_binding_level = level;
1849 pushdecl_class_level (x);
1850 class_binding_level = b;
1854 b = current_binding_level;
1855 current_binding_level = level;
1856 x = pushdecl_maybe_friend (x, is_friend);
1857 current_binding_level = b;
1859 current_function_decl = function_decl;
1860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1863 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1864 other definitions already in place. We get around this by making
1865 the value of the identifier point to a list of all the things that
1866 want to be referenced by that name. It is then up to the users of
1867 that name to decide what to do with that list.
1869 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1870 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1872 FLAGS is a bitwise-or of the following values:
1873 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1875 PUSH_USING: DECL is being pushed as the result of a using
1878 IS_FRIEND is true if this is a friend declaration.
1880 The value returned may be a previous declaration if we guessed wrong
1881 about what language DECL should belong to (C or C++). Otherwise,
1882 it's always DECL (and never something that's not a _DECL). */
1885 push_overloaded_decl (tree decl, int flags, bool is_friend)
1887 tree name = DECL_NAME (decl);
1890 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1892 timevar_push (TV_NAME_LOOKUP);
1894 old = namespace_binding (name, DECL_CONTEXT (decl));
1896 old = lookup_name_innermost_nonclass_level (name);
1900 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1902 tree t = TREE_TYPE (old);
1903 if (IS_AGGR_TYPE (t) && warn_shadow
1904 && (! DECL_IN_SYSTEM_HEADER (decl)
1905 || ! DECL_IN_SYSTEM_HEADER (old)))
1906 warning (0, "%q#D hides constructor for %q#T", decl, t);
1909 else if (is_overloaded_fn (old))
1913 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1915 tree fn = OVL_CURRENT (tmp);
1918 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1919 && !(flags & PUSH_USING)
1920 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1921 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1922 && ! decls_match (fn, decl))
1923 error ("%q#D conflicts with previous using declaration %q#D",
1926 dup = duplicate_decls (decl, fn, is_friend);
1927 /* If DECL was a redeclaration of FN -- even an invalid
1928 one -- pass that information along to our caller. */
1929 if (dup == fn || dup == error_mark_node)
1930 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1933 /* We don't overload implicit built-ins. duplicate_decls()
1934 may fail to merge the decls if the new decl is e.g. a
1935 template function. */
1936 if (TREE_CODE (old) == FUNCTION_DECL
1937 && DECL_ANTICIPATED (old)
1938 && !DECL_HIDDEN_FRIEND_P (old))
1941 else if (old == error_mark_node)
1942 /* Ignore the undefined symbol marker. */
1946 error ("previous non-function declaration %q+#D", old);
1947 error ("conflicts with function declaration %q#D", decl);
1948 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1952 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1953 /* If it's a using declaration, we always need to build an OVERLOAD,
1954 because it's the only way to remember that the declaration comes
1955 from 'using', and have the lookup behave correctly. */
1956 || (flags & PUSH_USING))
1958 if (old && TREE_CODE (old) != OVERLOAD)
1959 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1961 new_binding = ovl_cons (decl, old);
1962 if (flags & PUSH_USING)
1963 OVL_USED (new_binding) = 1;
1966 /* NAME is not ambiguous. */
1970 set_namespace_binding (name, current_namespace, new_binding);
1973 /* We only create an OVERLOAD if there was a previous binding at
1974 this level, or if decl is a template. In the former case, we
1975 need to remove the old binding and replace it with the new
1976 binding. We must also run through the NAMES on the binding
1977 level where the name was bound to update the chain. */
1979 if (TREE_CODE (new_binding) == OVERLOAD && old)
1983 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1985 d = &TREE_CHAIN (*d))
1987 || (TREE_CODE (*d) == TREE_LIST
1988 && TREE_VALUE (*d) == old))
1990 if (TREE_CODE (*d) == TREE_LIST)
1991 /* Just replace the old binding with the new. */
1992 TREE_VALUE (*d) = new_binding;
1994 /* Build a TREE_LIST to wrap the OVERLOAD. */
1995 *d = tree_cons (NULL_TREE, new_binding,
1998 /* And update the cxx_binding node. */
1999 IDENTIFIER_BINDING (name)->value = new_binding;
2000 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2003 /* We should always find a previous binding in this case. */
2007 /* Install the new binding. */
2008 push_local_binding (name, new_binding, flags);
2011 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2014 /* Check a non-member using-declaration. Return the name and scope
2015 being used, and the USING_DECL, or NULL_TREE on failure. */
2018 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2020 /* [namespace.udecl]
2021 A using-declaration for a class member shall be a
2022 member-declaration. */
2025 error ("%qT is not a namespace", scope);
2028 else if (scope == error_mark_node)
2031 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2034 A using-declaration shall not name a template-id. */
2035 error ("a using-declaration cannot specify a template-id. "
2036 "Try %<using %D%>", name);
2040 if (TREE_CODE (decl) == NAMESPACE_DECL)
2042 error ("namespace %qD not allowed in using-declaration", decl);
2046 if (TREE_CODE (decl) == SCOPE_REF)
2048 /* It's a nested name with template parameter dependent scope.
2049 This can only be using-declaration for class member. */
2050 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2054 if (is_overloaded_fn (decl))
2055 decl = get_first_fn (decl);
2057 gcc_assert (DECL_P (decl));
2059 /* Make a USING_DECL. */
2060 return push_using_decl (scope, name);
2063 /* Process local and global using-declarations. */
2066 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2067 tree *newval, tree *newtype)
2069 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2071 *newval = *newtype = NULL_TREE;
2072 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2076 if (!decls.value && !decls.type)
2078 error ("%qD not declared", name);
2082 /* It is impossible to overload a built-in function; any explicit
2083 declaration eliminates the built-in declaration. So, if OLDVAL
2084 is a built-in, then we can just pretend it isn't there. */
2086 && TREE_CODE (oldval) == FUNCTION_DECL
2087 && DECL_ANTICIPATED (oldval)
2088 && !DECL_HIDDEN_FRIEND_P (oldval))
2091 /* Check for using functions. */
2092 if (decls.value && is_overloaded_fn (decls.value))
2096 if (oldval && !is_overloaded_fn (oldval))
2098 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2099 error ("%qD is already declared in this scope", name);
2104 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2106 tree new_fn = OVL_CURRENT (tmp);
2108 /* [namespace.udecl]
2110 If a function declaration in namespace scope or block
2111 scope has the same name and the same parameter types as a
2112 function introduced by a using declaration the program is
2114 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2116 tree old_fn = OVL_CURRENT (tmp1);
2118 if (new_fn == old_fn)
2119 /* The function already exists in the current namespace. */
2121 else if (OVL_USED (tmp1))
2122 continue; /* this is a using decl */
2123 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2124 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2126 gcc_assert (!DECL_ANTICIPATED (old_fn)
2127 || DECL_HIDDEN_FRIEND_P (old_fn));
2129 /* There was already a non-using declaration in
2130 this scope with the same parameter types. If both
2131 are the same extern "C" functions, that's ok. */
2132 if (decls_match (new_fn, old_fn))
2136 error ("%qD is already declared in this scope", name);
2142 /* If we broke out of the loop, there's no reason to add
2143 this function to the using declarations for this
2148 /* If we are adding to an existing OVERLOAD, then we no
2149 longer know the type of the set of functions. */
2150 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2151 TREE_TYPE (*newval) = unknown_type_node;
2152 /* Add this new function to the set. */
2153 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2154 /* If there is only one function, then we use its type. (A
2155 using-declaration naming a single function can be used in
2156 contexts where overload resolution cannot be
2158 if (TREE_CODE (*newval) != OVERLOAD)
2160 *newval = ovl_cons (*newval, NULL_TREE);
2161 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2163 OVL_USED (*newval) = 1;
2168 *newval = decls.value;
2169 if (oldval && !decls_match (*newval, oldval))
2170 error ("%qD is already declared in this scope", name);
2173 *newtype = decls.type;
2174 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2176 error ("using declaration %qD introduced ambiguous type %qT",
2182 /* Process a using-declaration at function scope. */
2185 do_local_using_decl (tree decl, tree scope, tree name)
2187 tree oldval, oldtype, newval, newtype;
2188 tree orig_decl = decl;
2190 decl = validate_nonmember_using_decl (decl, scope, name);
2191 if (decl == NULL_TREE)
2194 if (building_stmt_tree ()
2195 && at_function_scope_p ())
2196 add_decl_expr (decl);
2198 oldval = lookup_name_innermost_nonclass_level (name);
2199 oldtype = lookup_type_current_level (name);
2201 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2205 if (is_overloaded_fn (newval))
2209 /* We only need to push declarations for those functions
2210 that were not already bound in the current level.
2211 The old value might be NULL_TREE, it might be a single
2212 function, or an OVERLOAD. */
2213 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2214 term = OVL_FUNCTION (oldval);
2217 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2219 push_overloaded_decl (OVL_CURRENT (fn),
2220 PUSH_LOCAL | PUSH_USING,
2224 push_local_binding (name, newval, PUSH_USING);
2228 push_local_binding (name, newtype, PUSH_USING);
2229 set_identifier_type_value (name, newtype);
2232 /* Emit debug info. */
2233 if (!processing_template_decl)
2234 cp_emit_debug_info_for_using (orig_decl, current_scope());
2237 /* Returns true if ROOT (a namespace, class, or function) encloses
2238 CHILD. CHILD may be either a class type or a namespace. */
2241 is_ancestor (tree root, tree child)
2243 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2244 || TREE_CODE (root) == FUNCTION_DECL
2245 || CLASS_TYPE_P (root)));
2246 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2247 || CLASS_TYPE_P (child)));
2249 /* The global namespace encloses everything. */
2250 if (root == global_namespace)
2255 /* If we've run out of scopes, stop. */
2258 /* If we've reached the ROOT, it encloses CHILD. */
2261 /* Go out one level. */
2263 child = TYPE_NAME (child);
2264 child = DECL_CONTEXT (child);
2268 /* Enter the class or namespace scope indicated by T suitable for name
2269 lookup. T can be arbitrary scope, not necessary nested inside the
2270 current scope. Returns a non-null scope to pop iff pop_scope
2271 should be called later to exit this scope. */
2276 if (TREE_CODE (t) == NAMESPACE_DECL)
2277 push_decl_namespace (t);
2278 else if (CLASS_TYPE_P (t))
2280 if (!at_class_scope_p ()
2281 || !same_type_p (current_class_type, t))
2282 push_nested_class (t);
2284 /* T is the same as the current scope. There is therefore no
2285 need to re-enter the scope. Since we are not actually
2286 pushing a new scope, our caller should not call
2294 /* Leave scope pushed by push_scope. */
2299 if (TREE_CODE (t) == NAMESPACE_DECL)
2300 pop_decl_namespace ();
2301 else if CLASS_TYPE_P (t)
2302 pop_nested_class ();
2305 /* Subroutine of push_inner_scope. */
2308 push_inner_scope_r (tree outer, tree inner)
2313 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2316 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2318 push_inner_scope_r (outer, prev);
2319 if (TREE_CODE (inner) == NAMESPACE_DECL)
2321 struct cp_binding_level *save_template_parm = 0;
2322 /* Temporary take out template parameter scopes. They are saved
2323 in reversed order in save_template_parm. */
2324 while (current_binding_level->kind == sk_template_parms)
2326 struct cp_binding_level *b = current_binding_level;
2327 current_binding_level = b->level_chain;
2328 b->level_chain = save_template_parm;
2329 save_template_parm = b;
2332 resume_scope (NAMESPACE_LEVEL (inner));
2333 current_namespace = inner;
2335 /* Restore template parameter scopes. */
2336 while (save_template_parm)
2338 struct cp_binding_level *b = save_template_parm;
2339 save_template_parm = b->level_chain;
2340 b->level_chain = current_binding_level;
2341 current_binding_level = b;
2348 /* Enter the scope INNER from current scope. INNER must be a scope
2349 nested inside current scope. This works with both name lookup and
2350 pushing name into scope. In case a template parameter scope is present,
2351 namespace is pushed under the template parameter scope according to
2352 name lookup rule in 14.6.1/6.
2354 Return the former current scope suitable for pop_inner_scope. */
2357 push_inner_scope (tree inner)
2359 tree outer = current_scope ();
2361 outer = current_namespace;
2363 push_inner_scope_r (outer, inner);
2367 /* Exit the current scope INNER back to scope OUTER. */
2370 pop_inner_scope (tree outer, tree inner)
2373 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2376 while (outer != inner)
2378 if (TREE_CODE (inner) == NAMESPACE_DECL)
2380 struct cp_binding_level *save_template_parm = 0;
2381 /* Temporary take out template parameter scopes. They are saved
2382 in reversed order in save_template_parm. */
2383 while (current_binding_level->kind == sk_template_parms)
2385 struct cp_binding_level *b = current_binding_level;
2386 current_binding_level = b->level_chain;
2387 b->level_chain = save_template_parm;
2388 save_template_parm = b;
2393 /* Restore template parameter scopes. */
2394 while (save_template_parm)
2396 struct cp_binding_level *b = save_template_parm;
2397 save_template_parm = b->level_chain;
2398 b->level_chain = current_binding_level;
2399 current_binding_level = b;
2405 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2409 /* Do a pushlevel for class declarations. */
2412 pushlevel_class (void)
2414 if (ENABLE_SCOPE_CHECKING)
2417 class_binding_level = begin_scope (sk_class, current_class_type);
2420 /* ...and a poplevel for class declarations. */
2423 poplevel_class (void)
2425 struct cp_binding_level *level = class_binding_level;
2426 cp_class_binding *cb;
2430 timevar_push (TV_NAME_LOOKUP);
2431 gcc_assert (level != 0);
2433 /* If we're leaving a toplevel class, cache its binding level. */
2434 if (current_class_depth == 1)
2435 previous_class_level = level;
2436 for (shadowed = level->type_shadowed;
2438 shadowed = TREE_CHAIN (shadowed))
2439 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2441 /* Remove the bindings for all of the class-level declarations. */
2442 if (level->class_shadowed)
2445 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2447 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2448 ggc_free (level->class_shadowed);
2449 level->class_shadowed = NULL;
2452 /* Now, pop out of the binding level which we created up in the
2453 `pushlevel_class' routine. */
2454 if (ENABLE_SCOPE_CHECKING)
2458 timevar_pop (TV_NAME_LOOKUP);
2461 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2462 appropriate. DECL is the value to which a name has just been
2463 bound. CLASS_TYPE is the class in which the lookup occurred. */
2466 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2469 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2473 if (TREE_CODE (decl) == OVERLOAD)
2474 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2477 gcc_assert (DECL_P (decl));
2478 context = context_for_name_lookup (decl);
2481 if (is_properly_derived_from (class_type, context))
2482 INHERITED_VALUE_BINDING_P (binding) = 1;
2484 INHERITED_VALUE_BINDING_P (binding) = 0;
2486 else if (binding->value == decl)
2487 /* We only encounter a TREE_LIST when there is an ambiguity in the
2488 base classes. Such an ambiguity can be overridden by a
2489 definition in this class. */
2490 INHERITED_VALUE_BINDING_P (binding) = 1;
2492 INHERITED_VALUE_BINDING_P (binding) = 0;
2495 /* Make the declaration of X appear in CLASS scope. */
2498 pushdecl_class_level (tree x)
2501 bool is_valid = true;
2503 timevar_push (TV_NAME_LOOKUP);
2504 /* Get the name of X. */
2505 if (TREE_CODE (x) == OVERLOAD)
2506 name = DECL_NAME (get_first_fn (x));
2508 name = DECL_NAME (x);
2512 is_valid = push_class_level_binding (name, x);
2513 if (TREE_CODE (x) == TYPE_DECL)
2514 set_identifier_type_value (name, x);
2516 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2518 /* If X is an anonymous aggregate, all of its members are
2519 treated as if they were members of the class containing the
2520 aggregate, for naming purposes. */
2523 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2525 location_t save_location = input_location;
2526 input_location = DECL_SOURCE_LOCATION (f);
2527 if (!pushdecl_class_level (f))
2529 input_location = save_location;
2532 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2535 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2536 scope. If the value returned is non-NULL, and the PREVIOUS field
2537 is not set, callers must set the PREVIOUS field explicitly. */
2539 static cxx_binding *
2540 get_class_binding (tree name, cxx_scope *scope)
2545 cxx_binding *binding;
2547 class_type = scope->this_entity;
2549 /* Get the type binding. */
2550 type_binding = lookup_member (class_type, name,
2551 /*protect=*/2, /*want_type=*/true);
2552 /* Get the value binding. */
2553 value_binding = lookup_member (class_type, name,
2554 /*protect=*/2, /*want_type=*/false);
2557 && (TREE_CODE (value_binding) == TYPE_DECL
2558 || DECL_CLASS_TEMPLATE_P (value_binding)
2559 || (TREE_CODE (value_binding) == TREE_LIST
2560 && TREE_TYPE (value_binding) == error_mark_node
2561 && (TREE_CODE (TREE_VALUE (value_binding))
2563 /* We found a type binding, even when looking for a non-type
2564 binding. This means that we already processed this binding
2567 else if (value_binding)
2569 if (TREE_CODE (value_binding) == TREE_LIST
2570 && TREE_TYPE (value_binding) == error_mark_node)
2571 /* NAME is ambiguous. */
2573 else if (BASELINK_P (value_binding))
2574 /* NAME is some overloaded functions. */
2575 value_binding = BASELINK_FUNCTIONS (value_binding);
2578 /* If we found either a type binding or a value binding, create a
2579 new binding object. */
2580 if (type_binding || value_binding)
2582 binding = new_class_binding (name,
2586 /* This is a class-scope binding, not a block-scope binding. */
2587 LOCAL_BINDING_P (binding) = 0;
2588 set_inherited_value_binding_p (binding, value_binding, class_type);
2596 /* Make the declaration(s) of X appear in CLASS scope under the name
2597 NAME. Returns true if the binding is valid. */
2600 push_class_level_binding (tree name, tree x)
2602 cxx_binding *binding;
2606 timevar_push (TV_NAME_LOOKUP);
2607 /* The class_binding_level will be NULL if x is a template
2608 parameter name in a member template. */
2609 if (!class_binding_level)
2610 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2612 if (name == error_mark_node)
2613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2615 /* Check for invalid member names. */
2616 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2617 /* We could have been passed a tree list if this is an ambiguous
2618 declaration. If so, pull the declaration out because
2619 check_template_shadow will not handle a TREE_LIST. */
2620 if (TREE_CODE (decl) == TREE_LIST
2621 && TREE_TYPE (decl) == error_mark_node)
2622 decl = TREE_VALUE (decl);
2624 check_template_shadow (decl);
2628 If T is the name of a class, then each of the following shall
2629 have a name different from T:
2631 -- every static data member of class T;
2633 -- every member of class T that is itself a type;
2635 -- every enumerator of every member of class T that is an
2638 -- every member of every anonymous union that is a member of
2641 (Non-static data members were also forbidden to have the same
2642 name as T until TC1.) */
2643 if ((TREE_CODE (x) == VAR_DECL
2644 || TREE_CODE (x) == CONST_DECL
2645 || (TREE_CODE (x) == TYPE_DECL
2646 && !DECL_SELF_REFERENCE_P (x))
2647 /* A data member of an anonymous union. */
2648 || (TREE_CODE (x) == FIELD_DECL
2649 && DECL_CONTEXT (x) != current_class_type))
2650 && DECL_NAME (x) == constructor_name (current_class_type))
2652 tree scope = context_for_name_lookup (x);
2653 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2655 error ("%qD has the same name as the class in which it is "
2658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2662 /* Get the current binding for NAME in this class, if any. */
2663 binding = IDENTIFIER_BINDING (name);
2664 if (!binding || binding->scope != class_binding_level)
2666 binding = get_class_binding (name, class_binding_level);
2667 /* If a new binding was created, put it at the front of the
2668 IDENTIFIER_BINDING list. */
2671 binding->previous = IDENTIFIER_BINDING (name);
2672 IDENTIFIER_BINDING (name) = binding;
2676 /* If there is already a binding, then we may need to update the
2678 if (binding && binding->value)
2680 tree bval = binding->value;
2681 tree old_decl = NULL_TREE;
2683 if (INHERITED_VALUE_BINDING_P (binding))
2685 /* If the old binding was from a base class, and was for a
2686 tag name, slide it over to make room for the new binding.
2687 The old binding is still visible if explicitly qualified
2688 with a class-key. */
2689 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2690 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2692 old_decl = binding->type;
2693 binding->type = bval;
2694 binding->value = NULL_TREE;
2695 INHERITED_VALUE_BINDING_P (binding) = 0;
2700 /* Any inherited type declaration is hidden by the type
2701 declaration in the derived class. */
2702 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2703 binding->type = NULL_TREE;
2706 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2708 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2709 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2710 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2712 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2713 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2715 if (old_decl && binding->scope == class_binding_level)
2718 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2719 here. This function is only used to register bindings
2720 from with the class definition itself. */
2721 INHERITED_VALUE_BINDING_P (binding) = 0;
2722 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2726 /* Note that we declared this value so that we can issue an error if
2727 this is an invalid redeclaration of a name already used for some
2729 note_name_declared_in_class (name, decl);
2731 /* If we didn't replace an existing binding, put the binding on the
2732 stack of bindings for the identifier, and update the shadowed
2734 if (binding && binding->scope == class_binding_level)
2735 /* Supplement the existing binding. */
2736 ok = supplement_binding (binding, decl);
2739 /* Create a new binding. */
2740 push_binding (name, decl, class_binding_level);
2744 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2747 /* Process "using SCOPE::NAME" in a class scope. Return the
2748 USING_DECL created. */
2751 do_class_using_decl (tree scope, tree name)
2753 /* The USING_DECL returned by this function. */
2755 /* The declaration (or declarations) name by this using
2756 declaration. NULL if we are in a template and cannot figure out
2757 what has been named. */
2759 /* True if SCOPE is a dependent type. */
2760 bool scope_dependent_p;
2761 /* True if SCOPE::NAME is dependent. */
2762 bool name_dependent_p;
2763 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2764 bool bases_dependent_p;
2769 if (name == error_mark_node)
2772 if (!scope || !TYPE_P (scope))
2774 error ("using-declaration for non-member at class scope");
2778 /* Make sure the name is not invalid */
2779 if (TREE_CODE (name) == BIT_NOT_EXPR)
2781 error ("%<%T::%D%> names destructor", scope, name);
2784 if (constructor_name_p (name, scope))
2786 error ("%<%T::%D%> names constructor", scope, name);
2789 if (constructor_name_p (name, current_class_type))
2791 error ("%<%T::%D%> names constructor in %qT",
2792 scope, name, current_class_type);
2796 scope_dependent_p = dependent_type_p (scope);
2797 name_dependent_p = (scope_dependent_p
2798 || (IDENTIFIER_TYPENAME_P (name)
2799 && dependent_type_p (TREE_TYPE (name))));
2801 bases_dependent_p = false;
2802 if (processing_template_decl)
2803 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2804 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2806 if (dependent_type_p (TREE_TYPE (base_binfo)))
2808 bases_dependent_p = true;
2814 /* From [namespace.udecl]:
2816 A using-declaration used as a member-declaration shall refer to a
2817 member of a base class of the class being defined.
2819 In general, we cannot check this constraint in a template because
2820 we do not know the entire set of base classes of the current
2821 class type. However, if all of the base classes are
2822 non-dependent, then we can avoid delaying the check until
2824 if (!scope_dependent_p && !bases_dependent_p)
2828 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2829 if (b_kind < bk_proper_base)
2831 error_not_base_type (scope, current_class_type);
2835 if (!name_dependent_p)
2837 decl = lookup_member (binfo, name, 0, false);
2840 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2844 /* The binfo from which the functions came does not matter. */
2845 if (BASELINK_P (decl))
2846 decl = BASELINK_FUNCTIONS (decl);
2850 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2851 USING_DECL_DECLS (value) = decl;
2852 USING_DECL_SCOPE (value) = scope;
2853 DECL_DEPENDENT_P (value) = !decl;
2859 /* Return the binding value for name in scope. */
2862 namespace_binding (tree name, tree scope)
2864 cxx_binding *binding;
2867 scope = global_namespace;
2869 /* Unnecessary for the global namespace because it can't be an alias. */
2870 scope = ORIGINAL_NAMESPACE (scope);
2872 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2874 return binding ? binding->value : NULL_TREE;
2877 /* Set the binding value for name in scope. */
2880 set_namespace_binding (tree name, tree scope, tree val)
2884 timevar_push (TV_NAME_LOOKUP);
2885 if (scope == NULL_TREE)
2886 scope = global_namespace;
2887 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2888 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2891 supplement_binding (b, val);
2892 timevar_pop (TV_NAME_LOOKUP);
2895 /* Set the context of a declaration to scope. Complain if we are not
2899 set_decl_namespace (tree decl, tree scope, bool friendp)
2903 /* Get rid of namespace aliases. */
2904 scope = ORIGINAL_NAMESPACE (scope);
2906 /* It is ok for friends to be qualified in parallel space. */
2907 if (!friendp && !is_ancestor (current_namespace, scope))
2908 error ("declaration of %qD not in a namespace surrounding %qD",
2910 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2912 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2913 if (scope == current_namespace)
2915 if (at_namespace_scope_p ())
2916 error ("explicit qualification in declaration of %qD",
2921 /* See whether this has been declared in the namespace. */
2922 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2924 /* No old declaration at all. */
2926 if (!is_overloaded_fn (decl))
2927 /* Don't compare non-function decls with decls_match here, since
2928 it can't check for the correct constness at this
2929 point. pushdecl will find those errors later. */
2931 /* Since decl is a function, old should contain a function decl. */
2932 if (!is_overloaded_fn (old))
2934 fn = OVL_CURRENT (old);
2935 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2937 /* A template can be explicitly specialized in any namespace. */
2938 if (processing_explicit_instantiation)
2940 if (processing_template_decl || processing_specialization)
2941 /* We have not yet called push_template_decl to turn a
2942 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2943 match. But, we'll check later, when we construct the
2946 /* Instantiations or specializations of templates may be declared as
2947 friends in any namespace. */
2948 if (friendp && DECL_USE_TEMPLATE (decl))
2950 if (is_overloaded_fn (old))
2952 for (; old; old = OVL_NEXT (old))
2953 if (decls_match (decl, OVL_CURRENT (old)))
2956 else if (decls_match (decl, old))
2959 error ("%qD should have been declared inside %qD", decl, scope);
2962 /* Return the namespace where the current declaration is declared. */
2965 current_decl_namespace (void)
2968 /* If we have been pushed into a different namespace, use it. */
2969 if (decl_namespace_list)
2970 return TREE_PURPOSE (decl_namespace_list);
2972 if (current_class_type)
2973 result = decl_namespace_context (current_class_type);
2974 else if (current_function_decl)
2975 result = decl_namespace_context (current_function_decl);
2977 result = current_namespace;
2981 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2982 select a name that is unique to this compilation unit. */
2985 push_namespace (tree name)
2987 push_namespace_with_attribs (name, NULL_TREE);
2990 /* Same, but specify attributes to apply to the namespace. The attributes
2991 only apply to the current namespace-body, not to any later extensions. */
2994 push_namespace_with_attribs (tree name, tree attributes)
2998 int implicit_use = 0;
3001 timevar_push (TV_NAME_LOOKUP);
3003 /* We should not get here if the global_namespace is not yet constructed
3004 nor if NAME designates the global namespace: The global scope is
3005 constructed elsewhere. */
3006 gcc_assert (global_namespace != NULL && name != global_scope_name);
3010 /* The name of anonymous namespace is unique for the translation
3012 if (!anonymous_namespace_name)
3013 anonymous_namespace_name = get_file_function_name ('N');
3014 name = anonymous_namespace_name;
3015 d = IDENTIFIER_NAMESPACE_VALUE (name);
3017 /* Reopening anonymous namespace. */
3023 /* Check whether this is an extended namespace definition. */
3024 d = IDENTIFIER_NAMESPACE_VALUE (name);
3025 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3028 if (DECL_NAMESPACE_ALIAS (d))
3030 error ("namespace alias %qD not allowed here, assuming %qD",
3031 d, DECL_NAMESPACE_ALIAS (d));
3032 d = DECL_NAMESPACE_ALIAS (d);
3039 /* Make a new namespace, binding the name to it. */
3040 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3041 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3042 TREE_PUBLIC (d) = 1;
3046 /* Clear DECL_NAME for the benefit of debugging back ends. */
3047 SET_DECL_ASSEMBLER_NAME (d, name);
3048 DECL_NAME (d) = NULL_TREE;
3050 begin_scope (sk_namespace, d);
3053 resume_scope (NAMESPACE_LEVEL (d));
3056 do_using_directive (d);
3057 /* Enter the name space. */
3058 current_namespace = d;
3060 #ifdef HANDLE_PRAGMA_VISIBILITY
3061 /* Clear has_visibility in case a previous namespace-definition had a
3062 visibility attribute and this one doesn't. */
3063 current_binding_level->has_visibility = 0;
3064 for (d = attributes; d; d = TREE_CHAIN (d))
3066 tree name = TREE_PURPOSE (d);
3067 tree args = TREE_VALUE (d);
3070 if (! is_attribute_p ("visibility", name))
3072 warning (OPT_Wattributes, "%qs attribute directive ignored",
3073 IDENTIFIER_POINTER (name));
3077 x = args ? TREE_VALUE (args) : NULL_TREE;
3078 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3080 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3081 IDENTIFIER_POINTER (name));
3085 current_binding_level->has_visibility = 1;
3086 push_visibility (TREE_STRING_POINTER (x));
3092 /* Anonymous namespaces default to hidden visibility. This might
3093 change once we implement export. */
3094 current_binding_level->has_visibility = 1;
3095 push_visibility ("hidden");
3101 timevar_pop (TV_NAME_LOOKUP);
3104 /* Pop from the scope of the current namespace. */
3107 pop_namespace (void)
3109 gcc_assert (current_namespace != global_namespace);
3110 current_namespace = CP_DECL_CONTEXT (current_namespace);
3111 /* The binding level is not popped, as it might be re-opened later. */
3115 /* Push into the scope of the namespace NS, even if it is deeply
3116 nested within another namespace. */
3119 push_nested_namespace (tree ns)
3121 if (ns == global_namespace)
3122 push_to_top_level ();
3125 push_nested_namespace (CP_DECL_CONTEXT (ns));
3126 push_namespace (DECL_NAME (ns));
3130 /* Pop back from the scope of the namespace NS, which was previously
3131 entered with push_nested_namespace. */
3134 pop_nested_namespace (tree ns)
3136 timevar_push (TV_NAME_LOOKUP);
3137 while (ns != global_namespace)
3140 ns = CP_DECL_CONTEXT (ns);
3143 pop_from_top_level ();
3144 timevar_pop (TV_NAME_LOOKUP);
3147 /* Temporarily set the namespace for the current declaration. */
3150 push_decl_namespace (tree decl)
3152 if (TREE_CODE (decl) != NAMESPACE_DECL)
3153 decl = decl_namespace_context (decl);
3154 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3155 NULL_TREE, decl_namespace_list);
3158 /* [namespace.memdef]/2 */
3161 pop_decl_namespace (void)
3163 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3166 /* Return the namespace that is the common ancestor
3167 of two given namespaces. */
3170 namespace_ancestor (tree ns1, tree ns2)
3172 timevar_push (TV_NAME_LOOKUP);
3173 if (is_ancestor (ns1, ns2))
3174 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3175 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3176 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3179 /* Process a namespace-alias declaration. */
3182 do_namespace_alias (tree alias, tree namespace)
3184 if (namespace == error_mark_node)
3187 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3189 namespace = ORIGINAL_NAMESPACE (namespace);
3191 /* Build the alias. */
3192 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3193 DECL_NAMESPACE_ALIAS (alias) = namespace;
3194 DECL_EXTERNAL (alias) = 1;
3195 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3198 /* Emit debug info for namespace alias. */
3199 (*debug_hooks->global_decl) (alias);
3202 /* Like pushdecl, only it places X in the current namespace,
3206 pushdecl_namespace_level (tree x, bool is_friend)
3208 struct cp_binding_level *b = current_binding_level;
3211 timevar_push (TV_NAME_LOOKUP);
3212 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3214 /* Now, the type_shadowed stack may screw us. Munge it so it does
3216 if (TREE_CODE (t) == TYPE_DECL)
3218 tree name = DECL_NAME (t);
3220 tree *ptr = (tree *)0;
3221 for (; !global_scope_p (b); b = b->level_chain)
3223 tree shadowed = b->type_shadowed;
3224 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3225 if (TREE_PURPOSE (shadowed) == name)
3227 ptr = &TREE_VALUE (shadowed);
3228 /* Can't break out of the loop here because sometimes
3229 a binding level will have duplicate bindings for
3230 PT names. It's gross, but I haven't time to fix it. */
3233 newval = TREE_TYPE (t);
3234 if (ptr == (tree *)0)
3236 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3237 up here if this is changed to an assertion. --KR */
3238 SET_IDENTIFIER_TYPE_VALUE (name, t);
3245 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3248 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3249 directive is not directly from the source. Also find the common
3250 ancestor and let our users know about the new namespace */
3252 add_using_namespace (tree user, tree used, bool indirect)
3255 timevar_push (TV_NAME_LOOKUP);
3256 /* Using oneself is a no-op. */
3259 timevar_pop (TV_NAME_LOOKUP);
3262 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3263 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3264 /* Check if we already have this. */
3265 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3269 /* Promote to direct usage. */
3270 TREE_INDIRECT_USING (t) = 0;
3271 timevar_pop (TV_NAME_LOOKUP);
3275 /* Add used to the user's using list. */
3276 DECL_NAMESPACE_USING (user)
3277 = tree_cons (used, namespace_ancestor (user, used),
3278 DECL_NAMESPACE_USING (user));
3280 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3282 /* Add user to the used's users list. */
3283 DECL_NAMESPACE_USERS (used)
3284 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3286 /* Recursively add all namespaces used. */
3287 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3288 /* indirect usage */
3289 add_using_namespace (user, TREE_PURPOSE (t), 1);
3291 /* Tell everyone using us about the new used namespaces. */
3292 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3293 add_using_namespace (TREE_PURPOSE (t), used, 1);
3294 timevar_pop (TV_NAME_LOOKUP);
3297 /* Process a using-declaration not appearing in class or local scope. */
3300 do_toplevel_using_decl (tree decl, tree scope, tree name)
3302 tree oldval, oldtype, newval, newtype;
3303 tree orig_decl = decl;
3304 cxx_binding *binding;
3306 decl = validate_nonmember_using_decl (decl, scope, name);
3307 if (decl == NULL_TREE)
3310 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3312 oldval = binding->value;
3313 oldtype = binding->type;
3315 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3317 /* Emit debug info. */
3318 if (!processing_template_decl)
3319 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3321 /* Copy declarations found. */
3323 binding->value = newval;
3325 binding->type = newtype;
3328 /* Process a using-directive. */
3331 do_using_directive (tree namespace)
3333 tree context = NULL_TREE;
3335 if (namespace == error_mark_node)
3338 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3340 if (building_stmt_tree ())
3341 add_stmt (build_stmt (USING_STMT, namespace));
3342 namespace = ORIGINAL_NAMESPACE (namespace);
3344 if (!toplevel_bindings_p ())
3346 push_using_directive (namespace);
3347 context = current_scope ();
3352 add_using_namespace (current_namespace, namespace, 0);
3353 if (current_namespace != global_namespace)
3354 context = current_namespace;
3357 /* Emit debugging info. */
3358 if (!processing_template_decl)
3359 (*debug_hooks->imported_module_or_decl) (namespace, context);
3362 /* Deal with a using-directive seen by the parser. Currently we only
3363 handle attributes here, since they cannot appear inside a template. */
3366 parse_using_directive (tree namespace, tree attribs)
3370 do_using_directive (namespace);
3372 for (a = attribs; a; a = TREE_CHAIN (a))
3374 tree name = TREE_PURPOSE (a);
3375 if (is_attribute_p ("strong", name))
3377 if (!toplevel_bindings_p ())
3378 error ("strong using only meaningful at namespace scope");
3379 else if (namespace != error_mark_node)
3381 if (!is_ancestor (current_namespace, namespace))
3382 error ("current namespace %qD does not enclose strongly used namespace %qD",
3383 current_namespace, namespace);
3384 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3385 = tree_cons (current_namespace, 0,
3386 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3390 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3394 /* Like pushdecl, only it places X in the global scope if appropriate.
3395 Calls cp_finish_decl to register the variable, initializing it with
3396 *INIT, if INIT is non-NULL. */
3399 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3401 timevar_push (TV_NAME_LOOKUP);
3402 push_to_top_level ();
3403 x = pushdecl_namespace_level (x, is_friend);
3405 finish_decl (x, *init, NULL_TREE);
3406 pop_from_top_level ();
3407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3410 /* Like pushdecl, only it places X in the global scope if appropriate. */
3413 pushdecl_top_level (tree x)
3415 return pushdecl_top_level_1 (x, NULL, false);
3418 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3421 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3423 return pushdecl_top_level_1 (x, NULL, is_friend);
3426 /* Like pushdecl, only it places X in the global scope if
3427 appropriate. Calls cp_finish_decl to register the variable,
3428 initializing it with INIT. */
3431 pushdecl_top_level_and_finish (tree x, tree init)
3433 return pushdecl_top_level_1 (x, &init, false);
3436 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3437 duplicates. The first list becomes the tail of the result.
3439 The algorithm is O(n^2). We could get this down to O(n log n) by
3440 doing a sort on the addresses of the functions, if that becomes
3444 merge_functions (tree s1, tree s2)
3446 for (; s2; s2 = OVL_NEXT (s2))
3448 tree fn2 = OVL_CURRENT (s2);
3451 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3453 tree fn1 = OVL_CURRENT (fns1);
3455 /* If the function from S2 is already in S1, there is no
3456 need to add it again. For `extern "C"' functions, we
3457 might have two FUNCTION_DECLs for the same function, in
3458 different namespaces; again, we only need one of them. */
3460 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3461 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3465 /* If we exhausted all of the functions in S1, FN2 is new. */
3467 s1 = build_overload (fn2, s1);
3472 /* This should return an error not all definitions define functions.
3473 It is not an error if we find two functions with exactly the
3474 same signature, only if these are selected in overload resolution.
3475 old is the current set of bindings, new the freshly-found binding.
3476 XXX Do we want to give *all* candidates in case of ambiguity?
3477 XXX In what way should I treat extern declarations?
3478 XXX I don't want to repeat the entire duplicate_decls here */
3481 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3485 gcc_assert (old != NULL);
3486 /* Copy the value. */
3489 switch (TREE_CODE (val))
3492 /* If we expect types or namespaces, and not templates,
3493 or this is not a template class. */
3494 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3495 && !DECL_CLASS_TEMPLATE_P (val))
3496 || hidden_name_p (val))
3500 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3503 case NAMESPACE_DECL:
3504 if (LOOKUP_TYPES_ONLY (flags))
3508 /* Ignore built-in functions that are still anticipated. */
3509 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3513 if (LOOKUP_QUALIFIERS_ONLY (flags))
3519 else if (val && val != old->value)
3521 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3522 old->value = merge_functions (old->value, val);
3525 old->value = tree_cons (NULL_TREE, old->value,
3526 build_tree_list (NULL_TREE, new->value));
3527 TREE_TYPE (old->value) = error_mark_node;
3530 /* ... and copy the type. */
3532 if (LOOKUP_NAMESPACES_ONLY (flags))
3536 else if (type && old->type != type)
3538 if (flags & LOOKUP_COMPLAIN)
3540 error ("%qD denotes an ambiguous type",name);
3541 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3542 error ("%J other type here", TYPE_MAIN_DECL (type));
3547 /* Return the declarations that are members of the namespace NS. */
3550 cp_namespace_decls (tree ns)
3552 return NAMESPACE_LEVEL (ns)->names;
3555 /* Combine prefer_type and namespaces_only into flags. */
3558 lookup_flags (int prefer_type, int namespaces_only)
3560 if (namespaces_only)
3561 return LOOKUP_PREFER_NAMESPACES;
3562 if (prefer_type > 1)
3563 return LOOKUP_PREFER_TYPES;
3564 if (prefer_type > 0)
3565 return LOOKUP_PREFER_BOTH;
3569 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3570 ignore it or not. Subroutine of lookup_name_real and
3571 lookup_type_scope. */
3574 qualify_lookup (tree val, int flags)
3576 if (val == NULL_TREE)
3578 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3580 if ((flags & LOOKUP_PREFER_TYPES)
3581 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3583 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3588 /* Given a lookup that returned VAL, decide if we want to ignore it or
3589 not based on DECL_ANTICIPATED. */
3592 hidden_name_p (tree val)
3595 && DECL_LANG_SPECIFIC (val)
3596 && DECL_ANTICIPATED (val))
3601 /* Remove any hidden friend functions from a possibly overloaded set
3605 remove_hidden_names (tree fns)
3610 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3612 else if (TREE_CODE (fns) == OVERLOAD)
3616 for (o = fns; o; o = OVL_NEXT (o))
3617 if (hidden_name_p (OVL_CURRENT (o)))
3623 for (o = fns; o; o = OVL_NEXT (o))
3624 if (!hidden_name_p (OVL_CURRENT (o)))
3625 n = build_overload (OVL_CURRENT (o), n);
3633 /* Select the right _DECL from multiple choices. */
3636 select_decl (const struct scope_binding *binding, int flags)
3639 val = binding->value;
3641 timevar_push (TV_NAME_LOOKUP);
3642 if (LOOKUP_NAMESPACES_ONLY (flags))
3644 /* We are not interested in types. */
3645 if (val && (TREE_CODE (val) == NAMESPACE_DECL
3646 || TREE_CODE (val) == TREE_LIST))
3647 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3648 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3651 /* If looking for a type, or if there is no non-type binding, select
3652 the value binding. */
3653 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3654 val = binding->type;
3655 /* Don't return non-types if we really prefer types. */
3656 else if (val && LOOKUP_TYPES_ONLY (flags)
3657 && ! DECL_DECLARES_TYPE_P (val))
3660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3663 /* Unscoped lookup of a global: iterate over current namespaces,
3664 considering using-directives. */
3667 unqualified_namespace_lookup (tree name, int flags)
3669 tree initial = current_decl_namespace ();
3670 tree scope = initial;
3672 struct cp_binding_level *level;
3673 tree val = NULL_TREE;
3674 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3676 timevar_push (TV_NAME_LOOKUP);
3678 for (; !val; scope = CP_DECL_CONTEXT (scope))
3681 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3685 if (b->value && hidden_name_p (b->value))
3686 /* Ignore anticipated built-in functions and friends. */
3689 binding.value = b->value;
3690 binding.type = b->type;
3693 /* Add all _DECLs seen through local using-directives. */
3694 for (level = current_binding_level;
3695 level->kind != sk_namespace;
3696 level = level->level_chain)
3697 if (!lookup_using_namespace (name, &binding, level->using_directives,
3699 /* Give up because of error. */
3700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3702 /* Add all _DECLs seen through global using-directives. */
3703 /* XXX local and global using lists should work equally. */
3707 if (!lookup_using_namespace (name, &binding,
3708 DECL_NAMESPACE_USING (siter),
3710 /* Give up because of error. */
3711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3712 if (siter == scope) break;
3713 siter = CP_DECL_CONTEXT (siter);
3716 val = select_decl (&binding, flags);
3717 if (scope == global_namespace)
3720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3723 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3724 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3727 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3728 declaration found. If no suitable declaration can be found,
3729 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3730 neither a class-type nor a namespace a diagnostic is issued. */
3733 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3738 if (TREE_CODE (scope) == NAMESPACE_DECL)
3740 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3742 flags |= LOOKUP_COMPLAIN;
3744 flags |= LOOKUP_PREFER_TYPES;
3745 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3746 t = select_decl (&binding, flags);
3748 else if (is_aggr_type (scope, complain))
3749 t = lookup_member (scope, name, 2, is_type_p);
3752 return error_mark_node;
3756 /* Subroutine of unqualified_namespace_lookup:
3757 Add the bindings of NAME in used namespaces to VAL.
3758 We are currently looking for names in namespace SCOPE, so we
3759 look through USINGS for using-directives of namespaces
3760 which have SCOPE as a common ancestor with the current scope.
3761 Returns false on errors. */
3764 lookup_using_namespace (tree name, struct scope_binding *val,
3765 tree usings, tree scope, int flags)
3768 timevar_push (TV_NAME_LOOKUP);
3769 /* Iterate over all used namespaces in current, searching for using
3770 directives of scope. */
3771 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3772 if (TREE_VALUE (iter) == scope)
3774 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3776 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3777 /* Resolve ambiguities. */
3779 ambiguous_decl (name, val, val1, flags);
3781 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3785 Accepts the NAME to lookup and its qualifying SCOPE.
3786 Returns the name/type pair found into the cxx_binding *RESULT,
3787 or false on error. */
3790 qualified_lookup_using_namespace (tree name, tree scope,
3791 struct scope_binding *result, int flags)
3793 /* Maintain a list of namespaces visited... */
3794 tree seen = NULL_TREE;
3795 /* ... and a list of namespace yet to see. */
3796 tree todo = NULL_TREE;
3797 tree todo_maybe = NULL_TREE;
3799 timevar_push (TV_NAME_LOOKUP);
3800 /* Look through namespace aliases. */
3801 scope = ORIGINAL_NAMESPACE (scope);
3802 while (scope && result->value != error_mark_node)
3804 cxx_binding *binding =
3805 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3806 seen = tree_cons (scope, NULL_TREE, seen);
3808 ambiguous_decl (name, result, binding, flags);
3810 /* Consider strong using directives always, and non-strong ones
3811 if we haven't found a binding yet. ??? Shouldn't we consider
3812 non-strong ones if the initial RESULT is non-NULL, but the
3813 binding in the given namespace is? */
3814 for (usings = DECL_NAMESPACE_USING (scope); usings;
3815 usings = TREE_CHAIN (usings))
3816 /* If this was a real directive, and we have not seen it. */
3817 if (!TREE_INDIRECT_USING (usings))
3819 /* Try to avoid queuing the same namespace more than once,
3820 the exception being when a namespace was already
3821 enqueued for todo_maybe and then a strong using is
3822 found for it. We could try to remove it from
3823 todo_maybe, but it's probably not worth the effort. */
3824 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3825 && !purpose_member (TREE_PURPOSE (usings), seen)
3826 && !purpose_member (TREE_PURPOSE (usings), todo))
3827 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3828 else if ((!result->value && !result->type)
3829 && !purpose_member (TREE_PURPOSE (usings), seen)
3830 && !purpose_member (TREE_PURPOSE (usings), todo)
3831 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3832 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3837 scope = TREE_PURPOSE (todo);
3838 todo = TREE_CHAIN (todo);
3841 && (!result->value && !result->type))
3843 scope = TREE_PURPOSE (todo_maybe);
3844 todo = TREE_CHAIN (todo_maybe);
3845 todo_maybe = NULL_TREE;
3848 scope = NULL_TREE; /* If there never was a todo list. */
3850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3853 /* Return the innermost non-namespace binding for NAME from a scope
3854 containing BINDING, or, if BINDING is NULL, the current scope. If
3855 CLASS_P is false, then class bindings are ignored. */
3858 outer_binding (tree name,
3859 cxx_binding *binding,
3864 cxx_scope *outer_scope;
3868 scope = binding->scope->level_chain;
3869 outer = binding->previous;
3873 scope = current_binding_level;
3874 outer = IDENTIFIER_BINDING (name);
3876 outer_scope = outer ? outer->scope : NULL;
3878 /* Because we create class bindings lazily, we might be missing a
3879 class binding for NAME. If there are any class binding levels
3880 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3881 declared, we must lookup NAME in those class scopes. */
3883 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3885 if (scope->kind == sk_class)
3887 cxx_binding *class_binding;
3889 class_binding = get_class_binding (name, scope);
3892 /* Thread this new class-scope binding onto the
3893 IDENTIFIER_BINDING list so that future lookups
3895 class_binding->previous = outer;
3897 binding->previous = class_binding;
3899 IDENTIFIER_BINDING (name) = class_binding;
3900 return class_binding;
3903 scope = scope->level_chain;
3909 /* Return the innermost block-scope or class-scope value binding for
3910 NAME, or NULL_TREE if there is no such binding. */
3913 innermost_non_namespace_value (tree name)
3915 cxx_binding *binding;
3916 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3917 return binding ? binding->value : NULL_TREE;
3920 /* Look up NAME in the current binding level and its superiors in the
3921 namespace of variables, functions and typedefs. Return a ..._DECL
3922 node of some kind representing its definition if there is only one
3923 such declaration, or return a TREE_LIST with all the overloaded
3924 definitions if there are many, or return 0 if it is undefined.
3925 Hidden name, either friend declaration or built-in function, are
3928 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3929 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3930 Otherwise we prefer non-TYPE_DECLs.
3932 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3933 BLOCK_P is false, bindings in block scopes are ignored. */
3936 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3937 int namespaces_only, int flags)
3940 tree val = NULL_TREE;
3942 timevar_push (TV_NAME_LOOKUP);
3943 /* Conversion operators are handled specially because ordinary
3944 unqualified name lookup will not find template conversion
3946 if (IDENTIFIER_TYPENAME_P (name))
3948 struct cp_binding_level *level;
3950 for (level = current_binding_level;
3951 level && level->kind != sk_namespace;
3952 level = level->level_chain)
3957 /* A conversion operator can only be declared in a class
3959 if (level->kind != sk_class)
3962 /* Lookup the conversion operator in the class. */
3963 class_type = level->this_entity;
3964 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3966 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3969 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3972 flags |= lookup_flags (prefer_type, namespaces_only);
3974 /* First, look in non-namespace scopes. */
3976 if (current_class_type == NULL_TREE)
3979 if (block_p || !nonclass)
3980 for (iter = outer_binding (name, NULL, !nonclass);
3982 iter = outer_binding (name, iter, !nonclass))
3986 /* Skip entities we don't want. */
3987 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3990 /* If this is the kind of thing we're looking for, we're done. */
3991 if (qualify_lookup (iter->value, flags)
3992 && !hidden_name_p (iter->value))
3993 binding = iter->value;
3994 else if ((flags & LOOKUP_PREFER_TYPES)
3995 && qualify_lookup (iter->type, flags)
3996 && !hidden_name_p (iter->type))
3997 binding = iter->type;
3999 binding = NULL_TREE;
4008 /* Now lookup in namespace scopes. */
4010 val = unqualified_namespace_lookup (name, flags);
4012 /* If we have a single function from a using decl, pull it out. */
4013 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4014 val = OVL_FUNCTION (val);
4016 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4020 lookup_name_nonclass (tree name)
4022 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4026 lookup_function_nonclass (tree name, tree args, bool block_p)
4029 lookup_arg_dependent (name,
4030 lookup_name_real (name, 0, 1, block_p, 0,
4036 lookup_name (tree name)
4038 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4042 lookup_name_prefer_type (tree name, int prefer_type)
4044 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4045 0, LOOKUP_COMPLAIN);
4048 /* Look up NAME for type used in elaborated name specifier in
4049 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4050 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4051 name, more scopes are checked if cleanup or template parameter
4052 scope is encountered.
4054 Unlike lookup_name_real, we make sure that NAME is actually
4055 declared in the desired scope, not from inheritance, nor using
4056 directive. For using declaration, there is DR138 still waiting
4057 to be resolved. Hidden name coming from an earlier friend
4058 declaration is also returned.
4060 A TYPE_DECL best matching the NAME is returned. Catching error
4061 and issuing diagnostics are caller's responsibility. */
4064 lookup_type_scope (tree name, tag_scope scope)
4066 cxx_binding *iter = NULL;
4067 tree val = NULL_TREE;
4069 timevar_push (TV_NAME_LOOKUP);
4071 /* Look in non-namespace scope first. */
4072 if (current_binding_level->kind != sk_namespace)
4073 iter = outer_binding (name, NULL, /*class_p=*/ true);
4074 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4076 /* Check if this is the kind of thing we're looking for.
4077 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4078 base class. For ITER->VALUE, we can simply use
4079 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4082 We check ITER->TYPE before ITER->VALUE in order to handle
4083 typedef struct C {} C;
4086 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4087 && (scope != ts_current
4088 || LOCAL_BINDING_P (iter)
4089 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4091 else if ((scope != ts_current
4092 || !INHERITED_VALUE_BINDING_P (iter))
4093 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4100 /* Look in namespace scope. */
4103 iter = cxx_scope_find_binding_for_name
4104 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4108 /* If this is the kind of thing we're looking for, we're done. */
4109 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4111 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4117 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4118 and template parameter scopes. */
4121 struct cp_binding_level *b = current_binding_level;
4124 if (iter->scope == b)
4125 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4127 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4129 else if (b->kind == sk_class
4130 && scope == ts_within_enclosing_non_class)
4137 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4140 /* Similar to `lookup_name' but look only in the innermost non-class
4144 lookup_name_innermost_nonclass_level (tree name)
4146 struct cp_binding_level *b;
4149 timevar_push (TV_NAME_LOOKUP);
4150 b = innermost_nonclass_level ();
4152 if (b->kind == sk_namespace)
4154 t = IDENTIFIER_NAMESPACE_VALUE (name);
4156 /* extern "C" function() */
4157 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4160 else if (IDENTIFIER_BINDING (name)
4161 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4163 cxx_binding *binding;
4164 binding = IDENTIFIER_BINDING (name);
4167 if (binding->scope == b
4168 && !(TREE_CODE (binding->value) == VAR_DECL
4169 && DECL_DEAD_FOR_LOCAL (binding->value)))
4170 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4172 if (b->kind == sk_cleanup)
4179 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4182 /* Like lookup_name_innermost_nonclass_level, but for types. */
4185 lookup_type_current_level (tree name)
4189 timevar_push (TV_NAME_LOOKUP);
4190 gcc_assert (current_binding_level->kind != sk_namespace);
4192 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4193 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4195 struct cp_binding_level *b = current_binding_level;
4198 if (purpose_member (name, b->type_shadowed))
4199 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4200 REAL_IDENTIFIER_TYPE_VALUE (name));
4201 if (b->kind == sk_cleanup)
4208 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4211 /* [basic.lookup.koenig] */
4212 /* A nonzero return value in the functions below indicates an error. */
4223 static bool arg_assoc (struct arg_lookup*, tree);
4224 static bool arg_assoc_args (struct arg_lookup*, tree);
4225 static bool arg_assoc_type (struct arg_lookup*, tree);
4226 static bool add_function (struct arg_lookup *, tree);
4227 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4228 static bool arg_assoc_class (struct arg_lookup *, tree);
4229 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4231 /* Add a function to the lookup structure.
4232 Returns true on error. */
4235 add_function (struct arg_lookup *k, tree fn)
4237 /* We used to check here to see if the function was already in the list,
4238 but that's O(n^2), which is just too expensive for function lookup.
4239 Now we deal with the occasional duplicate in joust. In doing this, we
4240 assume that the number of duplicates will be small compared to the
4241 total number of functions being compared, which should usually be the
4244 /* We must find only functions, or exactly one non-function. */
4247 else if (fn == k->functions)
4249 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4250 k->functions = build_overload (fn, k->functions);
4253 tree f1 = OVL_CURRENT (k->functions);
4255 if (is_overloaded_fn (f1))
4257 fn = f1; f1 = f2; f2 = fn;
4259 error ("%q+D is not a function,", f1);
4260 error (" conflict with %q+D", f2);
4261 error (" in call to %qD", k->name);
4268 /* Returns true iff CURRENT has declared itself to be an associated
4269 namespace of SCOPE via a strong using-directive (or transitive chain
4270 thereof). Both are namespaces. */
4273 is_associated_namespace (tree current, tree scope)
4275 tree seen = NULL_TREE;
4276 tree todo = NULL_TREE;
4280 if (scope == current)
4282 seen = tree_cons (scope, NULL_TREE, seen);
4283 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4284 if (!purpose_member (TREE_PURPOSE (t), seen))
4285 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4288 scope = TREE_PURPOSE (todo);
4289 todo = TREE_CHAIN (todo);
4296 /* Return whether FN is a friend of an associated class of ARG. */
4299 friend_of_associated_class_p (tree arg, tree fn)
4305 else if (type_unknown_p (arg))
4308 type = TREE_TYPE (arg);
4310 /* If TYPE is a class, the class itself and all base classes are
4311 associated classes. */
4312 if (CLASS_TYPE_P (type))
4314 if (is_friend (type, fn))
4317 if (TYPE_BINFO (type))
4319 tree binfo, base_binfo;
4322 for (binfo = TYPE_BINFO (type), i = 0;
4323 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4325 if (is_friend (BINFO_TYPE (base_binfo), fn))
4330 /* If TYPE is a class member, the class of which it is a member is
4331 an associated class. */
4332 if ((CLASS_TYPE_P (type)
4333 || TREE_CODE (type) == UNION_TYPE
4334 || TREE_CODE (type) == ENUMERAL_TYPE)
4335 && TYPE_CONTEXT (type)
4336 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4337 && is_friend (TYPE_CONTEXT (type), fn))
4343 /* Add functions of a namespace to the lookup structure.
4344 Returns true on error. */
4347 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4351 if (purpose_member (scope, k->namespaces))
4353 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4355 /* Check out our super-users. */
4356 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4357 value = TREE_CHAIN (value))
4358 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4361 value = namespace_binding (k->name, scope);
4365 for (; value; value = OVL_NEXT (value))
4367 /* We don't want to find arbitrary hidden functions via argument
4368 dependent lookup. We only want to find friends of associated
4370 if (hidden_name_p (OVL_CURRENT (value)))
4374 for (args = k->args; args; args = TREE_CHAIN (args))
4375 if (friend_of_associated_class_p (TREE_VALUE (args),
4376 OVL_CURRENT (value)))
4382 if (add_function (k, OVL_CURRENT (value)))
4389 /* Adds everything associated with a template argument to the lookup
4390 structure. Returns true on error. */
4393 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4395 /* [basic.lookup.koenig]
4397 If T is a template-id, its associated namespaces and classes are
4398 ... the namespaces and classes associated with the types of the
4399 template arguments provided for template type parameters
4400 (excluding template template parameters); the namespaces in which
4401 any template template arguments are defined; and the classes in
4402 which any member templates used as template template arguments
4403 are defined. [Note: non-type template arguments do not
4404 contribute to the set of associated namespaces. ] */
4406 /* Consider first template template arguments. */
4407 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4408 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4410 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4412 tree ctx = CP_DECL_CONTEXT (arg);
4414 /* It's not a member template. */
4415 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4416 return arg_assoc_namespace (k, ctx);
4417 /* Otherwise, it must be member template. */
4419 return arg_assoc_class (k, ctx);
4421 /* It's not a template template argument, but it is a type template
4423 else if (TYPE_P (arg))
4424 return arg_assoc_type (k, arg);
4425 /* It's a non-type template argument. */
4430 /* Adds everything associated with class to the lookup structure.
4431 Returns true on error. */
4434 arg_assoc_class (struct arg_lookup *k, tree type)
4436 tree list, friends, context;
4439 /* Backend build structures, such as __builtin_va_list, aren't
4440 affected by all this. */
4441 if (!CLASS_TYPE_P (type))
4444 if (purpose_member (type, k->classes))
4446 k->classes = tree_cons (type, NULL_TREE, k->classes);
4448 context = decl_namespace_context (type);
4449 if (arg_assoc_namespace (k, context))
4452 if (TYPE_BINFO (type))
4454 /* Process baseclasses. */
4455 tree binfo, base_binfo;
4457 for (binfo = TYPE_BINFO (type), i = 0;
4458 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4459 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4463 /* Process friends. */
4464 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4465 list = TREE_CHAIN (list))
4466 if (k->name == FRIEND_NAME (list))
4467 for (friends = FRIEND_DECLS (list); friends;
4468 friends = TREE_CHAIN (friends))
4470 tree fn = TREE_VALUE (friends);
4472 /* Only interested in global functions with potentially hidden
4473 (i.e. unqualified) declarations. */
4474 if (CP_DECL_CONTEXT (fn) != context)
4476 /* Template specializations are never found by name lookup.
4477 (Templates themselves can be found, but not template
4478 specializations.) */
4479 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4481 if (add_function (k, fn))
4485 /* Process template arguments. */
4486 if (CLASSTYPE_TEMPLATE_INFO (type)
4487 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4489 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4490 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4491 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4497 /* Adds everything associated with a given type.
4498 Returns 1 on error. */
4501 arg_assoc_type (struct arg_lookup *k, tree type)
4503 /* As we do not get the type of non-type dependent expressions
4504 right, we can end up with such things without a type. */
4508 if (TYPE_PTRMEM_P (type))
4510 /* Pointer to member: associate class type and value type. */
4511 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4513 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4515 else switch (TREE_CODE (type))
4527 if (TYPE_PTRMEMFUNC_P (type))
4528 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4529 return arg_assoc_class (k, type);
4531 case REFERENCE_TYPE:
4533 return arg_assoc_type (k, TREE_TYPE (type));
4536 return arg_assoc_namespace (k, decl_namespace_context (type));
4538 /* The basetype is referenced in the first arg type, so just
4541 /* Associate the parameter types. */
4542 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4544 /* Associate the return type. */
4545 return arg_assoc_type (k, TREE_TYPE (type));
4546 case TEMPLATE_TYPE_PARM:
4547 case BOUND_TEMPLATE_TEMPLATE_PARM:
4552 gcc_assert (type == unknown_type_node);
4560 /* Adds everything associated with arguments. Returns true on error. */
4563 arg_assoc_args (struct arg_lookup *k, tree args)
4565 for (; args; args = TREE_CHAIN (args))
4566 if (arg_assoc (k, TREE_VALUE (args)))
4571 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4574 arg_assoc (struct arg_lookup *k, tree n)
4576 if (n == error_mark_node)
4580 return arg_assoc_type (k, n);
4582 if (! type_unknown_p (n))
4583 return arg_assoc_type (k, TREE_TYPE (n));
4585 if (TREE_CODE (n) == ADDR_EXPR)
4586 n = TREE_OPERAND (n, 0);
4587 if (TREE_CODE (n) == COMPONENT_REF)
4588 n = TREE_OPERAND (n, 1);
4589 if (TREE_CODE (n) == OFFSET_REF)
4590 n = TREE_OPERAND (n, 1);
4591 while (TREE_CODE (n) == TREE_LIST)
4593 if (TREE_CODE (n) == BASELINK)
4594 n = BASELINK_FUNCTIONS (n);
4596 if (TREE_CODE (n) == FUNCTION_DECL)
4597 return arg_assoc_type (k, TREE_TYPE (n));
4598 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4600 /* [basic.lookup.koenig]
4602 If T is a template-id, its associated namespaces and classes
4603 are the namespace in which the template is defined; for
4604 member templates, the member template's class... */
4605 tree template = TREE_OPERAND (n, 0);
4606 tree args = TREE_OPERAND (n, 1);
4610 if (TREE_CODE (template) == COMPONENT_REF)
4611 template = TREE_OPERAND (template, 1);
4613 /* First, the template. There may actually be more than one if
4614 this is an overloaded function template. But, in that case,
4615 we only need the first; all the functions will be in the same
4617 template = OVL_CURRENT (template);
4619 ctx = CP_DECL_CONTEXT (template);
4621 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4623 if (arg_assoc_namespace (k, ctx) == 1)
4626 /* It must be a member template. */
4627 else if (arg_assoc_class (k, ctx) == 1)
4630 /* Now the arguments. */
4632 for (ix = TREE_VEC_LENGTH (args); ix--;)
4633 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4636 else if (TREE_CODE (n) == OVERLOAD)
4638 for (; n; n = OVL_CHAIN (n))
4639 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4646 /* Performs Koenig lookup depending on arguments, where fns
4647 are the functions found in normal lookup. */
4650 lookup_arg_dependent (tree name, tree fns, tree args)
4652 struct arg_lookup k;
4654 timevar_push (TV_NAME_LOOKUP);
4656 /* Remove any hidden friend functions from the list of functions
4657 found so far. They will be added back by arg_assoc_class as
4659 fns = remove_hidden_names (fns);
4664 k.classes = NULL_TREE;
4666 /* We previously performed an optimization here by setting
4667 NAMESPACES to the current namespace when it was safe. However, DR
4668 164 says that namespaces that were already searched in the first
4669 stage of template processing are searched again (potentially
4670 picking up later definitions) in the second stage. */
4671 k.namespaces = NULL_TREE;
4673 arg_assoc_args (&k, args);
4674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4677 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4678 changed (i.e. there was already a directive), or the fresh
4679 TREE_LIST otherwise. */
4682 push_using_directive (tree used)
4684 tree ud = current_binding_level->using_directives;
4685 tree iter, ancestor;
4687 timevar_push (TV_NAME_LOOKUP);
4688 /* Check if we already have this. */
4689 if (purpose_member (used, ud) != NULL_TREE)
4690 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4692 ancestor = namespace_ancestor (current_decl_namespace (), used);
4693 ud = current_binding_level->using_directives;
4694 ud = tree_cons (used, ancestor, ud);
4695 current_binding_level->using_directives = ud;
4697 /* Recursively add all namespaces used. */
4698 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4699 push_using_directive (TREE_PURPOSE (iter));
4701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4704 /* The type TYPE is being declared. If it is a class template, or a
4705 specialization of a class template, do any processing required and
4706 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4707 being declared a friend. B is the binding level at which this TYPE
4710 Returns the TYPE_DECL for TYPE, which may have been altered by this
4714 maybe_process_template_type_declaration (tree type, int is_friend,
4717 tree decl = TYPE_NAME (type);
4719 if (processing_template_parmlist)
4720 /* You can't declare a new template type in a template parameter
4721 list. But, you can declare a non-template type:
4723 template <class A*> struct S;
4725 is a forward-declaration of `A'. */
4727 else if (b->kind == sk_namespace
4728 && current_binding_level->kind != sk_namespace)
4729 /* If this new type is being injected into a containing scope,
4730 then it's not a template type. */
4734 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4736 if (processing_template_decl)
4738 /* This may change after the call to
4739 push_template_decl_real, but we want the original value. */
4740 tree name = DECL_NAME (decl);
4742 decl = push_template_decl_real (decl, is_friend);
4743 /* If the current binding level is the binding level for the
4744 template parameters (see the comment in
4745 begin_template_parm_list) and the enclosing level is a class
4746 scope, and we're not looking at a friend, push the
4747 declaration of the member class into the class scope. In the
4748 friend case, push_template_decl will already have put the
4749 friend into global scope, if appropriate. */
4750 if (TREE_CODE (type) != ENUMERAL_TYPE
4751 && !is_friend && b->kind == sk_template_parms
4752 && b->level_chain->kind == sk_class)
4754 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4756 if (!COMPLETE_TYPE_P (current_class_type))
4758 maybe_add_class_template_decl_list (current_class_type,
4759 type, /*friend_p=*/0);
4760 /* Put this UTD in the table of UTDs for the class. */
4761 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4762 CLASSTYPE_NESTED_UTDS (current_class_type) =
4763 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4765 binding_table_insert
4766 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4775 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4776 that the NAME is a class template, the tag is processed but not pushed.
4778 The pushed scope depend on the SCOPE parameter:
4779 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4781 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4782 non-template-parameter scope. This case is needed for forward
4784 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4785 TS_GLOBAL case except that names within template-parameter scopes
4786 are not pushed at all.
4788 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4791 pushtag (tree name, tree type, tag_scope scope)
4793 struct cp_binding_level *b;
4796 timevar_push (TV_NAME_LOOKUP);
4797 b = current_binding_level;
4798 while (/* Cleanup scopes are not scopes from the point of view of
4800 b->kind == sk_cleanup
4801 /* Neither are the scopes used to hold template parameters
4802 for an explicit specialization. For an ordinary template
4803 declaration, these scopes are not scopes from the point of
4804 view of the language. */
4805 || (b->kind == sk_template_parms
4806 && (b->explicit_spec_p || scope == ts_global))
4807 || (b->kind == sk_class
4808 && (scope != ts_current
4809 /* We may be defining a new type in the initializer
4810 of a static member variable. We allow this when
4811 not pedantic, and it is particularly useful for
4812 type punning via an anonymous union. */
4813 || COMPLETE_TYPE_P (b->this_entity))))
4816 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4818 /* Do C++ gratuitous typedefing. */
4819 if (IDENTIFIER_TYPE_VALUE (name) != type)
4823 tree context = TYPE_CONTEXT (type);
4827 tree cs = current_scope ();
4829 if (scope == ts_current)
4831 else if (cs != NULL_TREE && TYPE_P (cs))
4832 /* When declaring a friend class of a local class, we want
4833 to inject the newly named class into the scope
4834 containing the local class, not the namespace
4836 context = decl_function_context (get_type_decl (cs));
4839 context = current_namespace;
4841 if (b->kind == sk_class
4842 || (b->kind == sk_template_parms
4843 && b->level_chain->kind == sk_class))
4846 if (current_lang_name == lang_name_java)
4847 TYPE_FOR_JAVA (type) = 1;
4849 tdef = create_implicit_typedef (name, type);
4850 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4851 if (scope == ts_within_enclosing_non_class)
4853 /* This is a friend. Make this TYPE_DECL node hidden from
4854 ordinary name lookup. Its corresponding TEMPLATE_DECL
4855 will be marked in push_template_decl_real. */
4856 retrofit_lang_decl (tdef);
4857 DECL_ANTICIPATED (tdef) = 1;
4858 DECL_FRIEND_P (tdef) = 1;
4861 decl = maybe_process_template_type_declaration
4862 (type, scope == ts_within_enclosing_non_class, b);
4863 if (decl == error_mark_node)
4864 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4867 set_identifier_type_value_with_scope (name, tdef, b);
4869 if (b->kind == sk_class)
4871 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4872 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4873 class. But if it's a member template class, we want
4874 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4876 finish_member_declaration (decl);
4878 pushdecl_class_level (decl);
4880 else if (b->kind != sk_template_parms)
4882 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4883 if (decl == error_mark_node)
4884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4887 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4889 /* If this is a local class, keep track of it. We need this
4890 information for name-mangling, and so that it is possible to
4891 find all function definitions in a translation unit in a
4892 convenient way. (It's otherwise tricky to find a member
4893 function definition it's only pointed to from within a local
4895 if (TYPE_CONTEXT (type)
4896 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4897 VEC_safe_push (tree, gc, local_classes, type);
4899 if (b->kind == sk_class
4900 && !COMPLETE_TYPE_P (current_class_type))
4902 maybe_add_class_template_decl_list (current_class_type,
4903 type, /*friend_p=*/0);
4905 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4906 CLASSTYPE_NESTED_UTDS (current_class_type)
4907 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4909 binding_table_insert
4910 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4913 decl = TYPE_NAME (type);
4914 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4915 TYPE_STUB_DECL (type) = decl;
4917 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4920 /* Subroutines for reverting temporarily to top-level for instantiation
4921 of templates and such. We actually need to clear out the class- and
4922 local-value slots of all identifiers, so that only the global values
4923 are at all visible. Simply setting current_binding_level to the global
4924 scope isn't enough, because more binding levels may be pushed. */
4925 struct saved_scope *scope_chain;
4927 /* If ID has not already been marked, add an appropriate binding to
4931 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4933 cxx_saved_binding *saved;
4935 if (!id || !IDENTIFIER_BINDING (id))
4938 if (IDENTIFIER_MARKED (id))
4941 IDENTIFIER_MARKED (id) = 1;
4943 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4944 saved->identifier = id;
4945 saved->binding = IDENTIFIER_BINDING (id);
4946 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4947 IDENTIFIER_BINDING (id) = NULL;
4951 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4955 timevar_push (TV_NAME_LOOKUP);
4956 for (t = names; t; t = TREE_CHAIN (t))
4960 if (TREE_CODE (t) == TREE_LIST)
4961 id = TREE_PURPOSE (t);
4965 store_binding (id, old_bindings);
4967 timevar_pop (TV_NAME_LOOKUP);
4970 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4971 objects, rather than a TREE_LIST. */
4974 store_class_bindings (VEC(cp_class_binding,gc) *names,
4975 VEC(cxx_saved_binding,gc) **old_bindings)
4978 cp_class_binding *cb;
4980 timevar_push (TV_NAME_LOOKUP);
4981 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4982 store_binding (cb->identifier, old_bindings);
4983 timevar_pop (TV_NAME_LOOKUP);
4987 push_to_top_level (void)
4989 struct saved_scope *s;
4990 struct cp_binding_level *b;
4991 cxx_saved_binding *sb;
4995 timevar_push (TV_NAME_LOOKUP);
4996 s = GGC_CNEW (struct saved_scope);
4998 b = scope_chain ? current_binding_level : 0;
5000 /* If we're in the middle of some function, save our state. */
5004 push_function_context_to (NULL_TREE);
5009 if (scope_chain && previous_class_level)
5010 store_class_bindings (previous_class_level->class_shadowed,
5013 /* Have to include the global scope, because class-scope decls
5014 aren't listed anywhere useful. */
5015 for (; b; b = b->level_chain)
5019 /* Template IDs are inserted into the global level. If they were
5020 inserted into namespace level, finish_file wouldn't find them
5021 when doing pending instantiations. Therefore, don't stop at
5022 namespace level, but continue until :: . */
5023 if (global_scope_p (b))
5026 store_bindings (b->names, &s->old_bindings);
5027 /* We also need to check class_shadowed to save class-level type
5028 bindings, since pushclass doesn't fill in b->names. */
5029 if (b->kind == sk_class)
5030 store_class_bindings (b->class_shadowed, &s->old_bindings);
5032 /* Unwind type-value slots back to top level. */
5033 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5034 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5037 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5038 IDENTIFIER_MARKED (sb->identifier) = 0;
5040 s->prev = scope_chain;
5042 s->need_pop_function_context = need_pop;
5043 s->function_decl = current_function_decl;
5044 s->skip_evaluation = skip_evaluation;
5047 current_function_decl = NULL_TREE;
5048 current_lang_base = VEC_alloc (tree, gc, 10);
5049 current_lang_name = lang_name_cplusplus;
5050 current_namespace = global_namespace;
5051 push_class_stack ();
5052 skip_evaluation = 0;
5053 timevar_pop (TV_NAME_LOOKUP);
5057 pop_from_top_level (void)
5059 struct saved_scope *s = scope_chain;
5060 cxx_saved_binding *saved;
5063 timevar_push (TV_NAME_LOOKUP);
5064 /* Clear out class-level bindings cache. */
5065 if (previous_class_level)
5066 invalidate_class_lookup_cache ();
5069 current_lang_base = 0;
5071 scope_chain = s->prev;
5072 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5074 tree id = saved->identifier;
5076 IDENTIFIER_BINDING (id) = saved->binding;
5077 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5080 /* If we were in the middle of compiling a function, restore our
5082 if (s->need_pop_function_context)
5083 pop_function_context_from (NULL_TREE);
5084 current_function_decl = s->function_decl;
5085 skip_evaluation = s->skip_evaluation;
5086 timevar_pop (TV_NAME_LOOKUP);
5089 /* Pop off extraneous binding levels left over due to syntax errors.
5091 We don't pop past namespaces, as they might be valid. */
5094 pop_everything (void)
5096 if (ENABLE_SCOPE_CHECKING)
5097 verbatim ("XXX entering pop_everything ()\n");
5098 while (!toplevel_bindings_p ())
5100 if (current_binding_level->kind == sk_class)
5101 pop_nested_class ();
5105 if (ENABLE_SCOPE_CHECKING)
5106 verbatim ("XXX leaving pop_everything ()\n");
5109 /* Emit debugging information for using declarations and directives.
5110 If input tree is overloaded fn then emit debug info for all
5114 cp_emit_debug_info_for_using (tree t, tree context)
5116 /* Don't try to emit any debug information if we have errors. */
5117 if (sorrycount || errorcount)
5120 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5121 of a builtin function. */
5122 if (TREE_CODE (t) == FUNCTION_DECL
5123 && DECL_EXTERNAL (t)
5124 && DECL_BUILT_IN (t))
5127 /* Do not supply context to imported_module_or_decl, if
5128 it is a global namespace. */
5129 if (context == global_namespace)
5130 context = NULL_TREE;
5133 t = BASELINK_FUNCTIONS (t);
5135 /* FIXME: Handle TEMPLATE_DECLs. */
5136 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5137 if (TREE_CODE (t) != TEMPLATE_DECL)
5138 (*debug_hooks->imported_module_or_decl) (t, context);
5141 #include "gt-cp-name-lookup.h"