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 if (x == error_mark_node)
573 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
575 need_new_binding = 1;
577 if (DECL_TEMPLATE_PARM_P (x))
578 /* Template parameters have no context; they are not X::T even
579 when declared within a class or namespace. */
583 if (current_function_decl && x != current_function_decl
584 /* A local declaration for a function doesn't constitute
586 && TREE_CODE (x) != FUNCTION_DECL
587 /* A local declaration for an `extern' variable is in the
588 scope of the current namespace, not the current
590 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
591 && !DECL_CONTEXT (x))
592 DECL_CONTEXT (x) = current_function_decl;
594 /* If this is the declaration for a namespace-scope function,
595 but the declaration itself is in a local scope, mark the
597 if (TREE_CODE (x) == FUNCTION_DECL
598 && DECL_NAMESPACE_SCOPE_P (x)
599 && current_function_decl
600 && x != current_function_decl)
601 DECL_LOCAL_FUNCTION_P (x) = 1;
604 name = DECL_NAME (x);
607 int different_binding_level = 0;
609 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
610 check_default_args (x);
612 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
613 name = TREE_OPERAND (name, 0);
615 /* In case this decl was explicitly namespace-qualified, look it
616 up in its namespace context. */
617 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
618 t = namespace_binding (name, DECL_CONTEXT (x));
620 t = lookup_name_innermost_nonclass_level (name);
622 /* [basic.link] If there is a visible declaration of an entity
623 with linkage having the same name and type, ignoring entities
624 declared outside the innermost enclosing namespace scope, the
625 block scope declaration declares that same entity and
626 receives the linkage of the previous declaration. */
627 if (! t && current_function_decl && x != current_function_decl
628 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
629 && DECL_EXTERNAL (x))
631 /* Look in block scope. */
632 t = innermost_non_namespace_value (name);
633 /* Or in the innermost namespace. */
635 t = namespace_binding (name, DECL_CONTEXT (x));
636 /* Does it have linkage? Note that if this isn't a DECL, it's an
637 OVERLOAD, which is OK. */
638 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
641 different_binding_level = 1;
644 /* If we are declaring a function, and the result of name-lookup
645 was an OVERLOAD, look for an overloaded instance that is
646 actually the same as the function we are declaring. (If
647 there is one, we have to merge our declaration with the
648 previous declaration.) */
649 if (t && TREE_CODE (t) == OVERLOAD)
653 if (TREE_CODE (x) == FUNCTION_DECL)
654 for (match = t; match; match = OVL_NEXT (match))
656 if (decls_match (OVL_CURRENT (match), x))
660 /* Just choose one. */
664 t = OVL_CURRENT (match);
669 if (t && t != error_mark_node)
671 if (different_binding_level)
673 if (decls_match (x, t))
674 /* The standard only says that the local extern
675 inherits linkage from the previous decl; in
676 particular, default args are not shared. Add
677 the decl into a hash table to make sure only
678 the previous decl in this case is seen by the
681 struct cxx_int_tree_map *h;
684 TREE_PUBLIC (x) = TREE_PUBLIC (t);
686 if (cp_function_chain->extern_decl_map == NULL)
687 cp_function_chain->extern_decl_map
688 = htab_create_ggc (20, cxx_int_tree_map_hash,
689 cxx_int_tree_map_eq, NULL);
691 h = GGC_NEW (struct cxx_int_tree_map);
692 h->uid = DECL_UID (x);
694 loc = htab_find_slot_with_hash
695 (cp_function_chain->extern_decl_map, h,
697 *(struct cxx_int_tree_map **) loc = h;
700 else if (TREE_CODE (t) == PARM_DECL)
702 gcc_assert (DECL_CONTEXT (t));
704 /* Check for duplicate params. */
705 if (duplicate_decls (x, t, is_friend))
706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
708 else if ((DECL_EXTERN_C_FUNCTION_P (x)
709 || DECL_FUNCTION_TEMPLATE_P (x))
710 && is_overloaded_fn (t))
711 /* Don't do anything just yet. */;
712 else if (t == wchar_decl_node)
714 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
715 pedwarn ("redeclaration of %<wchar_t%> as %qT",
718 /* Throw away the redeclaration. */
719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
723 tree olddecl = duplicate_decls (x, t, is_friend);
725 /* If the redeclaration failed, we can stop at this
727 if (olddecl == error_mark_node)
728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
732 if (TREE_CODE (t) == TYPE_DECL)
733 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
737 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
739 /* A redeclaration of main, but not a duplicate of the
744 This function shall not be overloaded. */
745 error ("invalid redeclaration of %q+D", t);
747 /* We don't try to push this declaration since that
749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
754 check_template_shadow (x);
756 /* If this is a function conjured up by the backend, massage it
757 so it looks friendly. */
758 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
760 retrofit_lang_decl (x);
761 SET_DECL_LANGUAGE (x, lang_c);
764 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
766 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
769 if (!namespace_bindings_p ())
770 /* We do not need to create a binding for this name;
771 push_overloaded_decl will have already done so if
773 need_new_binding = 0;
775 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
777 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
779 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
780 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
783 /* If declaring a type as a typedef, copy the type (unless we're
784 at line 0), and install this TYPE_DECL as the new type's typedef
785 name. See the extensive comment in ../c-decl.c (pushdecl). */
786 if (TREE_CODE (x) == TYPE_DECL)
788 tree type = TREE_TYPE (x);
789 if (DECL_IS_BUILTIN (x))
791 if (TYPE_NAME (type) == 0)
792 TYPE_NAME (type) = x;
794 else if (type != error_mark_node && TYPE_NAME (type) != x
795 /* We don't want to copy the type when all we're
796 doing is making a TYPE_DECL for the purposes of
798 && (!TYPE_NAME (type)
799 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
801 DECL_ORIGINAL_TYPE (x) = type;
802 type = build_variant_type_copy (type);
803 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
804 TYPE_NAME (type) = x;
805 TREE_TYPE (x) = type;
808 if (type != error_mark_node
810 && TYPE_IDENTIFIER (type))
811 set_identifier_type_value (DECL_NAME (x), x);
814 /* Multiple external decls of the same identifier ought to match.
816 We get warnings about inline functions where they are defined.
817 We get warnings about other functions from push_overloaded_decl.
819 Avoid duplicate warnings where they are used. */
820 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
824 decl = IDENTIFIER_NAMESPACE_VALUE (name);
825 if (decl && TREE_CODE (decl) == OVERLOAD)
826 decl = OVL_FUNCTION (decl);
828 if (decl && decl != error_mark_node
829 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
830 /* If different sort of thing, we already gave an error. */
831 && TREE_CODE (decl) == TREE_CODE (x)
832 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
834 pedwarn ("type mismatch with previous external decl of %q#D", x);
835 pedwarn ("previous external decl of %q+#D", decl);
839 if (TREE_CODE (x) == FUNCTION_DECL
841 && !flag_friend_injection)
843 /* This is a new declaration of a friend function, so hide
844 it from ordinary function lookup. */
845 DECL_ANTICIPATED (x) = 1;
846 DECL_HIDDEN_FRIEND_P (x) = 1;
849 /* This name is new in its binding level.
850 Install the new declaration and return it. */
851 if (namespace_bindings_p ())
853 /* Install a global value. */
855 /* If the first global decl has external linkage,
856 warn if we later see static one. */
857 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
858 TREE_PUBLIC (name) = 1;
860 /* Bind the name for the entity. */
861 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
863 && (TREE_CODE (x) == TYPE_DECL
864 || TREE_CODE (x) == VAR_DECL
865 || TREE_CODE (x) == NAMESPACE_DECL
866 || TREE_CODE (x) == CONST_DECL
867 || TREE_CODE (x) == TEMPLATE_DECL))
868 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
870 /* If new decl is `static' and an `extern' was seen previously,
872 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
873 warn_extern_redeclared_static (x, t);
877 /* Here to install a non-global value. */
878 tree oldlocal = innermost_non_namespace_value (name);
879 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
881 if (need_new_binding)
883 push_local_binding (name, x, 0);
884 /* Because push_local_binding will hook X on to the
885 current_binding_level's name list, we don't want to
886 do that again below. */
887 need_new_binding = 0;
890 /* If this is a TYPE_DECL, push it into the type value slot. */
891 if (TREE_CODE (x) == TYPE_DECL)
892 set_identifier_type_value (name, x);
894 /* Clear out any TYPE_DECL shadowed by a namespace so that
895 we won't think this is a type. The C struct hack doesn't
896 go through namespaces. */
897 if (TREE_CODE (x) == NAMESPACE_DECL)
898 set_identifier_type_value (name, NULL_TREE);
905 && TREE_CODE (oldlocal) == VAR_DECL
906 && DECL_DEAD_FOR_LOCAL (oldlocal))
907 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
909 if (oldlocal == NULL_TREE)
910 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
913 /* If this is an extern function declaration, see if we
914 have a global definition or declaration for the function. */
915 if (oldlocal == NULL_TREE
917 && oldglobal != NULL_TREE
918 && TREE_CODE (x) == FUNCTION_DECL
919 && TREE_CODE (oldglobal) == FUNCTION_DECL)
921 /* We have one. Their types must agree. */
922 if (decls_match (x, oldglobal))
926 warning (0, "extern declaration of %q#D doesn't match", x);
927 warning (0, "global declaration %q+#D", oldglobal);
930 /* If we have a local external declaration,
931 and no file-scope declaration has yet been seen,
932 then if we later have a file-scope decl it must not be static. */
933 if (oldlocal == NULL_TREE
934 && oldglobal == NULL_TREE
937 TREE_PUBLIC (name) = 1;
939 /* Warn if shadowing an argument at the top level of the body. */
940 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
941 /* Inline decls shadow nothing. */
942 && !DECL_FROM_INLINE (x)
943 && TREE_CODE (oldlocal) == PARM_DECL
944 /* Don't check the `this' parameter. */
945 && !DECL_ARTIFICIAL (oldlocal))
949 /* Don't complain if it's from an enclosing function. */
950 if (DECL_CONTEXT (oldlocal) == current_function_decl
951 && TREE_CODE (x) != PARM_DECL)
953 /* Go to where the parms should be and see if we find
955 struct cp_binding_level *b = current_binding_level->level_chain;
957 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
958 /* Skip the ctor/dtor cleanup level. */
962 if (b->kind == sk_function_parms)
964 error ("declaration of %q#D shadows a parameter", x);
969 if (warn_shadow && !err)
971 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
972 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
976 /* Maybe warn if shadowing something else. */
977 else if (warn_shadow && !DECL_EXTERNAL (x)
978 /* No shadow warnings for internally generated vars. */
979 && ! DECL_ARTIFICIAL (x)
980 /* No shadow warnings for vars made for inlining. */
981 && ! DECL_FROM_INLINE (x))
985 if (current_class_ptr)
986 member = lookup_member (current_class_type,
989 /*want_type=*/false);
993 if (member && !TREE_STATIC (member))
995 /* Location of previous decl is not useful in this case. */
996 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
999 else if (oldlocal != NULL_TREE
1000 && TREE_CODE (oldlocal) == VAR_DECL)
1002 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1003 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1005 else if (oldglobal != NULL_TREE
1006 && TREE_CODE (oldglobal) == VAR_DECL)
1007 /* XXX shadow warnings in outer-more namespaces */
1009 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1011 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1016 if (TREE_CODE (x) == VAR_DECL)
1017 maybe_register_incomplete_var (x);
1020 if (need_new_binding)
1021 add_decl_to_level (x,
1022 DECL_NAMESPACE_SCOPE_P (x)
1023 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1024 : current_binding_level);
1026 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1029 /* Record a decl-node X as belonging to the current lexical scope. */
1034 return pushdecl_maybe_friend (x, false);
1037 /* Enter DECL into the symbol table, if that's appropriate. Returns
1038 DECL, or a modified version thereof. */
1041 maybe_push_decl (tree decl)
1043 tree type = TREE_TYPE (decl);
1045 /* Add this decl to the current binding level, but not if it comes
1046 from another scope, e.g. a static member variable. TEM may equal
1047 DECL or it may be a previous decl of the same name. */
1048 if (decl == error_mark_node
1049 || (TREE_CODE (decl) != PARM_DECL
1050 && DECL_CONTEXT (decl) != NULL_TREE
1051 /* Definitions of namespace members outside their namespace are
1053 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1054 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1055 || TREE_CODE (type) == UNKNOWN_TYPE
1056 /* The declaration of a template specialization does not affect
1057 the functions available for overload resolution, so we do not
1059 || (TREE_CODE (decl) == FUNCTION_DECL
1060 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1063 return pushdecl (decl);
1066 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1067 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1068 doesn't really belong to this binding level, that it got here
1069 through a using-declaration. */
1072 push_local_binding (tree id, tree decl, int flags)
1074 struct cp_binding_level *b;
1076 /* Skip over any local classes. This makes sense if we call
1077 push_local_binding with a friend decl of a local class. */
1078 b = innermost_nonclass_level ();
1080 if (lookup_name_innermost_nonclass_level (id))
1082 /* Supplement the existing binding. */
1083 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1084 /* It didn't work. Something else must be bound at this
1085 level. Do not add DECL to the list of things to pop
1090 /* Create a new binding. */
1091 push_binding (id, decl, b);
1093 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1094 /* We must put the OVERLOAD into a TREE_LIST since the
1095 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1096 decls that got here through a using-declaration. */
1097 decl = build_tree_list (NULL_TREE, decl);
1099 /* And put DECL on the list of things declared by the current
1101 add_decl_to_level (decl, b);
1104 /* Check to see whether or not DECL is a variable that would have been
1105 in scope under the ARM, but is not in scope under the ANSI/ISO
1106 standard. If so, issue an error message. If name lookup would
1107 work in both cases, but return a different result, this function
1108 returns the result of ANSI/ISO lookup. Otherwise, it returns
1112 check_for_out_of_scope_variable (tree decl)
1116 /* We only care about out of scope variables. */
1117 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1120 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1121 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1122 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1123 && DECL_DEAD_FOR_LOCAL (shadowed))
1124 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1125 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1127 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1130 if (!DECL_ERROR_REPORTED (decl))
1132 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1133 warning (0, " matches this %q+D under ISO standard rules",
1135 warning (0, " matches this %q+D under old rules", decl);
1136 DECL_ERROR_REPORTED (decl) = 1;
1141 /* If we have already complained about this declaration, there's no
1142 need to do it again. */
1143 if (DECL_ERROR_REPORTED (decl))
1146 DECL_ERROR_REPORTED (decl) = 1;
1148 if (TREE_TYPE (decl) == error_mark_node)
1151 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1153 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1155 error (" cannot use obsolete binding at %q+D because "
1156 "it has a destructor", decl);
1157 return error_mark_node;
1161 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1163 pedwarn (" using obsolete binding at %q+D", decl);
1169 /* true means unconditionally make a BLOCK for the next level pushed. */
1171 static bool keep_next_level_flag;
1173 static int binding_depth = 0;
1174 static int is_class_level = 0;
1181 for (i = 0; i < depth * 2; i++)
1185 /* Return a string describing the kind of SCOPE we have. */
1187 cxx_scope_descriptor (cxx_scope *scope)
1189 /* The order of this table must match the "scope_kind"
1191 static const char* scope_kind_names[] = {
1197 "function-parameter-scope",
1200 "template-parameter-scope",
1201 "template-explicit-spec-scope"
1203 const scope_kind kind = scope->explicit_spec_p
1204 ? sk_template_spec : scope->kind;
1206 return scope_kind_names[kind];
1209 /* Output a debugging information about SCOPE when performing
1212 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1214 const char *desc = cxx_scope_descriptor (scope);
1215 if (scope->this_entity)
1216 verbatim ("%s %s(%E) %p %d\n", action, desc,
1217 scope->this_entity, (void *) scope, line);
1219 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1222 /* Return the estimated initial size of the hashtable of a NAMESPACE
1225 static inline size_t
1226 namespace_scope_ht_size (tree ns)
1228 tree name = DECL_NAME (ns);
1230 return name == std_identifier
1231 ? NAMESPACE_STD_HT_SIZE
1232 : (name == global_scope_name
1233 ? GLOBAL_SCOPE_HT_SIZE
1234 : NAMESPACE_ORDINARY_HT_SIZE);
1237 /* A chain of binding_level structures awaiting reuse. */
1239 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1241 /* Insert SCOPE as the innermost binding level. */
1244 push_binding_level (struct cp_binding_level *scope)
1246 /* Add it to the front of currently active scopes stack. */
1247 scope->level_chain = current_binding_level;
1248 current_binding_level = scope;
1249 keep_next_level_flag = false;
1251 if (ENABLE_SCOPE_CHECKING)
1253 scope->binding_depth = binding_depth;
1254 indent (binding_depth);
1255 cxx_scope_debug (scope, input_line, "push");
1261 /* Create a new KIND scope and make it the top of the active scopes stack.
1262 ENTITY is the scope of the associated C++ entity (namespace, class,
1263 function); it is NULL otherwise. */
1266 begin_scope (scope_kind kind, tree entity)
1270 /* Reuse or create a struct for this binding level. */
1271 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1273 scope = free_binding_level;
1274 free_binding_level = scope->level_chain;
1277 scope = GGC_NEW (cxx_scope);
1278 memset (scope, 0, sizeof (cxx_scope));
1280 scope->this_entity = entity;
1281 scope->more_cleanups_ok = true;
1288 case sk_template_spec:
1289 scope->explicit_spec_p = true;
1290 kind = sk_template_parms;
1292 case sk_template_parms:
1298 case sk_function_parms:
1300 scope->keep = keep_next_level_flag;
1304 NAMESPACE_LEVEL (entity) = scope;
1305 scope->static_decls =
1306 VEC_alloc (tree, gc,
1307 DECL_NAME (entity) == std_identifier
1308 || DECL_NAME (entity) == global_scope_name
1313 /* Should not happen. */
1319 push_binding_level (scope);
1324 /* We're about to leave current scope. Pop the top of the stack of
1325 currently active scopes. Return the enclosing scope, now active. */
1330 cxx_scope *scope = current_binding_level;
1332 if (scope->kind == sk_namespace && class_binding_level)
1333 current_binding_level = class_binding_level;
1335 /* We cannot leave a scope, if there are none left. */
1336 if (NAMESPACE_LEVEL (global_namespace))
1337 gcc_assert (!global_scope_p (scope));
1339 if (ENABLE_SCOPE_CHECKING)
1341 indent (--binding_depth);
1342 cxx_scope_debug (scope, input_line, "leave");
1343 if (is_class_level != (scope == class_binding_level))
1345 indent (binding_depth);
1346 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1351 #ifdef HANDLE_PRAGMA_VISIBILITY
1352 if (scope->has_visibility)
1356 /* Move one nesting level up. */
1357 current_binding_level = scope->level_chain;
1359 /* Namespace-scopes are left most probably temporarily, not
1360 completely; they can be reopened later, e.g. in namespace-extension
1361 or any name binding activity that requires us to resume a
1362 namespace. For classes, we cache some binding levels. For other
1363 scopes, we just make the structure available for reuse. */
1364 if (scope->kind != sk_namespace
1365 && scope->kind != sk_class)
1367 scope->level_chain = free_binding_level;
1368 gcc_assert (!ENABLE_SCOPE_CHECKING
1369 || scope->binding_depth == binding_depth);
1370 free_binding_level = scope;
1373 /* Find the innermost enclosing class scope, and reset
1374 CLASS_BINDING_LEVEL appropriately. */
1375 if (scope->kind == sk_class)
1377 class_binding_level = NULL;
1378 for (scope = current_binding_level; scope; scope = scope->level_chain)
1379 if (scope->kind == sk_class)
1381 class_binding_level = scope;
1386 return current_binding_level;
1390 resume_scope (struct cp_binding_level* b)
1392 /* Resuming binding levels is meant only for namespaces,
1393 and those cannot nest into classes. */
1394 gcc_assert (!class_binding_level);
1395 /* Also, resuming a non-directly nested namespace is a no-no. */
1396 gcc_assert (b->level_chain == current_binding_level);
1397 current_binding_level = b;
1398 if (ENABLE_SCOPE_CHECKING)
1400 b->binding_depth = binding_depth;
1401 indent (binding_depth);
1402 cxx_scope_debug (b, input_line, "resume");
1408 /* Return the innermost binding level that is not for a class scope. */
1411 innermost_nonclass_level (void)
1415 b = current_binding_level;
1416 while (b->kind == sk_class)
1422 /* We're defining an object of type TYPE. If it needs a cleanup, but
1423 we're not allowed to add any more objects with cleanups to the current
1424 scope, create a new binding level. */
1427 maybe_push_cleanup_level (tree type)
1429 if (type != error_mark_node
1430 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1431 && current_binding_level->more_cleanups_ok == 0)
1433 begin_scope (sk_cleanup, NULL);
1434 current_binding_level->statement_list = push_stmt_list ();
1438 /* Nonzero if we are currently in the global binding level. */
1441 global_bindings_p (void)
1443 return global_scope_p (current_binding_level);
1446 /* True if we are currently in a toplevel binding level. This
1447 means either the global binding level or a namespace in a toplevel
1448 binding level. Since there are no non-toplevel namespace levels,
1449 this really means any namespace or template parameter level. We
1450 also include a class whose context is toplevel. */
1453 toplevel_bindings_p (void)
1455 struct cp_binding_level *b = innermost_nonclass_level ();
1457 return b->kind == sk_namespace || b->kind == sk_template_parms;
1460 /* True if this is a namespace scope, or if we are defining a class
1461 which is itself at namespace scope, or whose enclosing class is
1462 such a class, etc. */
1465 namespace_bindings_p (void)
1467 struct cp_binding_level *b = innermost_nonclass_level ();
1469 return b->kind == sk_namespace;
1472 /* True if the current level needs to have a BLOCK made. */
1477 return (current_binding_level->blocks != NULL_TREE
1478 || current_binding_level->keep
1479 || current_binding_level->kind == sk_cleanup
1480 || current_binding_level->names != NULL_TREE);
1483 /* Returns the kind of the innermost scope. */
1486 innermost_scope_kind (void)
1488 return current_binding_level->kind;
1491 /* Returns true if this scope was created to store template parameters. */
1494 template_parm_scope_p (void)
1496 return innermost_scope_kind () == sk_template_parms;
1499 /* If KEEP is true, make a BLOCK node for the next binding level,
1500 unconditionally. Otherwise, use the normal logic to decide whether
1501 or not to create a BLOCK. */
1504 keep_next_level (bool keep)
1506 keep_next_level_flag = keep;
1509 /* Return the list of declarations of the current level.
1510 Note that this list is in reverse order unless/until
1511 you nreverse it; and when you do nreverse it, you must
1512 store the result back using `storedecls' or you will lose. */
1517 return current_binding_level->names;
1520 /* For debugging. */
1521 static int no_print_functions = 0;
1522 static int no_print_builtins = 0;
1525 print_binding_level (struct cp_binding_level* lvl)
1529 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1530 if (lvl->more_cleanups_ok)
1531 fprintf (stderr, " more-cleanups-ok");
1532 if (lvl->have_cleanups)
1533 fprintf (stderr, " have-cleanups");
1534 fprintf (stderr, "\n");
1537 fprintf (stderr, " names:\t");
1538 /* We can probably fit 3 names to a line? */
1539 for (t = lvl->names; t; t = TREE_CHAIN (t))
1541 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1543 if (no_print_builtins
1544 && (TREE_CODE (t) == TYPE_DECL)
1545 && DECL_IS_BUILTIN (t))
1548 /* Function decls tend to have longer names. */
1549 if (TREE_CODE (t) == FUNCTION_DECL)
1556 fprintf (stderr, "\n\t");
1559 print_node_brief (stderr, "", t, 0);
1560 if (t == error_mark_node)
1564 fprintf (stderr, "\n");
1566 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1569 cp_class_binding *b;
1570 fprintf (stderr, " class-shadowed:");
1572 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1574 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1575 fprintf (stderr, "\n");
1577 if (lvl->type_shadowed)
1579 fprintf (stderr, " type-shadowed:");
1580 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1582 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1584 fprintf (stderr, "\n");
1589 print_other_binding_stack (struct cp_binding_level *stack)
1591 struct cp_binding_level *level;
1592 for (level = stack; !global_scope_p (level); level = level->level_chain)
1594 fprintf (stderr, "binding level %p\n", (void *) level);
1595 print_binding_level (level);
1600 print_binding_stack (void)
1602 struct cp_binding_level *b;
1603 fprintf (stderr, "current_binding_level=%p\n"
1604 "class_binding_level=%p\n"
1605 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1606 (void *) current_binding_level, (void *) class_binding_level,
1607 (void *) NAMESPACE_LEVEL (global_namespace));
1608 if (class_binding_level)
1610 for (b = class_binding_level; b; b = b->level_chain)
1611 if (b == current_binding_level)
1614 b = class_binding_level;
1616 b = current_binding_level;
1619 b = current_binding_level;
1620 print_other_binding_stack (b);
1621 fprintf (stderr, "global:\n");
1622 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1625 /* Return the type associated with id. */
1628 identifier_type_value (tree id)
1630 timevar_push (TV_NAME_LOOKUP);
1631 /* There is no type with that name, anywhere. */
1632 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1633 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1634 /* This is not the type marker, but the real thing. */
1635 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1636 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1637 /* Have to search for it. It must be on the global level, now.
1638 Ask lookup_name not to return non-types. */
1639 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1641 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1642 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1645 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1646 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1649 identifier_global_value (tree t)
1651 return IDENTIFIER_GLOBAL_VALUE (t);
1654 /* Push a definition of struct, union or enum tag named ID. into
1655 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1656 the tag ID is not already defined. */
1659 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1663 if (b->kind != sk_namespace)
1665 /* Shadow the marker, not the real thing, so that the marker
1666 gets restored later. */
1667 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1669 = tree_cons (id, old_type_value, b->type_shadowed);
1670 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1671 TREE_TYPE (b->type_shadowed) = type;
1675 cxx_binding *binding =
1676 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1679 supplement_binding (binding, decl);
1681 binding->value = decl;
1683 /* Store marker instead of real type. */
1684 type = global_type_node;
1686 SET_IDENTIFIER_TYPE_VALUE (id, type);
1689 /* As set_identifier_type_value_with_scope, but using
1690 current_binding_level. */
1693 set_identifier_type_value (tree id, tree decl)
1695 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1698 /* Return the name for the constructor (or destructor) for the
1699 specified class TYPE. When given a template, this routine doesn't
1700 lose the specialization. */
1703 constructor_name_full (tree type)
1705 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1708 /* Return the name for the constructor (or destructor) for the
1709 specified class. When given a template, return the plain
1710 unspecialized name. */
1713 constructor_name (tree type)
1716 name = constructor_name_full (type);
1717 if (IDENTIFIER_TEMPLATE (name))
1718 name = IDENTIFIER_TEMPLATE (name);
1722 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1725 constructor_name_p (tree name, tree type)
1732 if (TREE_CODE (name) != IDENTIFIER_NODE)
1735 ctor_name = constructor_name_full (type);
1736 if (name == ctor_name)
1738 if (IDENTIFIER_TEMPLATE (ctor_name)
1739 && name == IDENTIFIER_TEMPLATE (ctor_name))
1744 /* Counter used to create anonymous type names. */
1746 static GTY(()) int anon_cnt;
1748 /* Return an IDENTIFIER which can be used as a name for
1749 anonymous structs and unions. */
1752 make_anon_name (void)
1756 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1757 return get_identifier (buf);
1760 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1762 static inline cxx_binding *
1763 find_binding (cxx_scope *scope, cxx_binding *binding)
1765 timevar_push (TV_NAME_LOOKUP);
1767 for (; binding != NULL; binding = binding->previous)
1768 if (binding->scope == scope)
1769 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1771 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1774 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1776 static inline cxx_binding *
1777 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1779 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1782 /* Fold-in case where NAME is used only once. */
1783 if (scope == b->scope && b->previous == NULL)
1785 return find_binding (scope, b);
1790 /* Always returns a binding for name in scope. If no binding is
1791 found, make a new one. */
1793 static cxx_binding *
1794 binding_for_name (cxx_scope *scope, tree name)
1796 cxx_binding *result;
1798 result = cxx_scope_find_binding_for_name (scope, name);
1801 /* Not found, make a new one. */
1802 result = cxx_binding_make (NULL, NULL);
1803 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1804 result->scope = scope;
1805 result->is_local = false;
1806 result->value_is_inherited = false;
1807 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1811 /* Insert another USING_DECL into the current binding level, returning
1812 this declaration. If this is a redeclaration, do nothing, and
1813 return NULL_TREE if this not in namespace scope (in namespace
1814 scope, a using decl might extend any previous bindings). */
1817 push_using_decl (tree scope, tree name)
1821 timevar_push (TV_NAME_LOOKUP);
1822 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1823 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1824 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1825 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1828 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1829 namespace_bindings_p () ? decl : NULL_TREE);
1830 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1831 USING_DECL_SCOPE (decl) = scope;
1832 TREE_CHAIN (decl) = current_binding_level->usings;
1833 current_binding_level->usings = decl;
1834 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1837 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1838 caller to set DECL_CONTEXT properly. */
1841 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1843 struct cp_binding_level *b;
1844 tree function_decl = current_function_decl;
1846 timevar_push (TV_NAME_LOOKUP);
1847 current_function_decl = NULL_TREE;
1848 if (level->kind == sk_class)
1850 b = class_binding_level;
1851 class_binding_level = level;
1852 pushdecl_class_level (x);
1853 class_binding_level = b;
1857 b = current_binding_level;
1858 current_binding_level = level;
1859 x = pushdecl_maybe_friend (x, is_friend);
1860 current_binding_level = b;
1862 current_function_decl = function_decl;
1863 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1866 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1867 other definitions already in place. We get around this by making
1868 the value of the identifier point to a list of all the things that
1869 want to be referenced by that name. It is then up to the users of
1870 that name to decide what to do with that list.
1872 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1873 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1875 FLAGS is a bitwise-or of the following values:
1876 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1878 PUSH_USING: DECL is being pushed as the result of a using
1881 IS_FRIEND is true if this is a friend declaration.
1883 The value returned may be a previous declaration if we guessed wrong
1884 about what language DECL should belong to (C or C++). Otherwise,
1885 it's always DECL (and never something that's not a _DECL). */
1888 push_overloaded_decl (tree decl, int flags, bool is_friend)
1890 tree name = DECL_NAME (decl);
1893 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1895 timevar_push (TV_NAME_LOOKUP);
1897 old = namespace_binding (name, DECL_CONTEXT (decl));
1899 old = lookup_name_innermost_nonclass_level (name);
1903 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1905 tree t = TREE_TYPE (old);
1906 if (IS_AGGR_TYPE (t) && warn_shadow
1907 && (! DECL_IN_SYSTEM_HEADER (decl)
1908 || ! DECL_IN_SYSTEM_HEADER (old)))
1909 warning (0, "%q#D hides constructor for %q#T", decl, t);
1912 else if (is_overloaded_fn (old))
1916 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1918 tree fn = OVL_CURRENT (tmp);
1921 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1922 && !(flags & PUSH_USING)
1923 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1924 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1925 && ! decls_match (fn, decl))
1926 error ("%q#D conflicts with previous using declaration %q#D",
1929 dup = duplicate_decls (decl, fn, is_friend);
1930 /* If DECL was a redeclaration of FN -- even an invalid
1931 one -- pass that information along to our caller. */
1932 if (dup == fn || dup == error_mark_node)
1933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1936 /* We don't overload implicit built-ins. duplicate_decls()
1937 may fail to merge the decls if the new decl is e.g. a
1938 template function. */
1939 if (TREE_CODE (old) == FUNCTION_DECL
1940 && DECL_ANTICIPATED (old)
1941 && !DECL_HIDDEN_FRIEND_P (old))
1944 else if (old == error_mark_node)
1945 /* Ignore the undefined symbol marker. */
1949 error ("previous non-function declaration %q+#D", old);
1950 error ("conflicts with function declaration %q#D", decl);
1951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1955 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1956 /* If it's a using declaration, we always need to build an OVERLOAD,
1957 because it's the only way to remember that the declaration comes
1958 from 'using', and have the lookup behave correctly. */
1959 || (flags & PUSH_USING))
1961 if (old && TREE_CODE (old) != OVERLOAD)
1962 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1964 new_binding = ovl_cons (decl, old);
1965 if (flags & PUSH_USING)
1966 OVL_USED (new_binding) = 1;
1969 /* NAME is not ambiguous. */
1973 set_namespace_binding (name, current_namespace, new_binding);
1976 /* We only create an OVERLOAD if there was a previous binding at
1977 this level, or if decl is a template. In the former case, we
1978 need to remove the old binding and replace it with the new
1979 binding. We must also run through the NAMES on the binding
1980 level where the name was bound to update the chain. */
1982 if (TREE_CODE (new_binding) == OVERLOAD && old)
1986 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1988 d = &TREE_CHAIN (*d))
1990 || (TREE_CODE (*d) == TREE_LIST
1991 && TREE_VALUE (*d) == old))
1993 if (TREE_CODE (*d) == TREE_LIST)
1994 /* Just replace the old binding with the new. */
1995 TREE_VALUE (*d) = new_binding;
1997 /* Build a TREE_LIST to wrap the OVERLOAD. */
1998 *d = tree_cons (NULL_TREE, new_binding,
2001 /* And update the cxx_binding node. */
2002 IDENTIFIER_BINDING (name)->value = new_binding;
2003 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2006 /* We should always find a previous binding in this case. */
2010 /* Install the new binding. */
2011 push_local_binding (name, new_binding, flags);
2014 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2017 /* Check a non-member using-declaration. Return the name and scope
2018 being used, and the USING_DECL, or NULL_TREE on failure. */
2021 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2023 /* [namespace.udecl]
2024 A using-declaration for a class member shall be a
2025 member-declaration. */
2028 error ("%qT is not a namespace", scope);
2031 else if (scope == error_mark_node)
2034 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2037 A using-declaration shall not name a template-id. */
2038 error ("a using-declaration cannot specify a template-id. "
2039 "Try %<using %D%>", name);
2043 if (TREE_CODE (decl) == NAMESPACE_DECL)
2045 error ("namespace %qD not allowed in using-declaration", decl);
2049 if (TREE_CODE (decl) == SCOPE_REF)
2051 /* It's a nested name with template parameter dependent scope.
2052 This can only be using-declaration for class member. */
2053 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2057 if (is_overloaded_fn (decl))
2058 decl = get_first_fn (decl);
2060 gcc_assert (DECL_P (decl));
2062 /* Make a USING_DECL. */
2063 return push_using_decl (scope, name);
2066 /* Process local and global using-declarations. */
2069 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2070 tree *newval, tree *newtype)
2072 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2074 *newval = *newtype = NULL_TREE;
2075 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2079 if (!decls.value && !decls.type)
2081 error ("%qD not declared", name);
2085 /* It is impossible to overload a built-in function; any explicit
2086 declaration eliminates the built-in declaration. So, if OLDVAL
2087 is a built-in, then we can just pretend it isn't there. */
2089 && TREE_CODE (oldval) == FUNCTION_DECL
2090 && DECL_ANTICIPATED (oldval)
2091 && !DECL_HIDDEN_FRIEND_P (oldval))
2094 /* Check for using functions. */
2095 if (decls.value && is_overloaded_fn (decls.value))
2099 if (oldval && !is_overloaded_fn (oldval))
2101 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2102 error ("%qD is already declared in this scope", name);
2107 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2109 tree new_fn = OVL_CURRENT (tmp);
2111 /* [namespace.udecl]
2113 If a function declaration in namespace scope or block
2114 scope has the same name and the same parameter types as a
2115 function introduced by a using declaration the program is
2117 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2119 tree old_fn = OVL_CURRENT (tmp1);
2121 if (new_fn == old_fn)
2122 /* The function already exists in the current namespace. */
2124 else if (OVL_USED (tmp1))
2125 continue; /* this is a using decl */
2126 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2127 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2129 gcc_assert (!DECL_ANTICIPATED (old_fn)
2130 || DECL_HIDDEN_FRIEND_P (old_fn));
2132 /* There was already a non-using declaration in
2133 this scope with the same parameter types. If both
2134 are the same extern "C" functions, that's ok. */
2135 if (decls_match (new_fn, old_fn))
2139 error ("%qD is already declared in this scope", name);
2145 /* If we broke out of the loop, there's no reason to add
2146 this function to the using declarations for this
2151 /* If we are adding to an existing OVERLOAD, then we no
2152 longer know the type of the set of functions. */
2153 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2154 TREE_TYPE (*newval) = unknown_type_node;
2155 /* Add this new function to the set. */
2156 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2157 /* If there is only one function, then we use its type. (A
2158 using-declaration naming a single function can be used in
2159 contexts where overload resolution cannot be
2161 if (TREE_CODE (*newval) != OVERLOAD)
2163 *newval = ovl_cons (*newval, NULL_TREE);
2164 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2166 OVL_USED (*newval) = 1;
2171 *newval = decls.value;
2172 if (oldval && !decls_match (*newval, oldval))
2173 error ("%qD is already declared in this scope", name);
2176 *newtype = decls.type;
2177 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2179 error ("using declaration %qD introduced ambiguous type %qT",
2185 /* Process a using-declaration at function scope. */
2188 do_local_using_decl (tree decl, tree scope, tree name)
2190 tree oldval, oldtype, newval, newtype;
2191 tree orig_decl = decl;
2193 decl = validate_nonmember_using_decl (decl, scope, name);
2194 if (decl == NULL_TREE)
2197 if (building_stmt_tree ()
2198 && at_function_scope_p ())
2199 add_decl_expr (decl);
2201 oldval = lookup_name_innermost_nonclass_level (name);
2202 oldtype = lookup_type_current_level (name);
2204 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2208 if (is_overloaded_fn (newval))
2212 /* We only need to push declarations for those functions
2213 that were not already bound in the current level.
2214 The old value might be NULL_TREE, it might be a single
2215 function, or an OVERLOAD. */
2216 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2217 term = OVL_FUNCTION (oldval);
2220 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2222 push_overloaded_decl (OVL_CURRENT (fn),
2223 PUSH_LOCAL | PUSH_USING,
2227 push_local_binding (name, newval, PUSH_USING);
2231 push_local_binding (name, newtype, PUSH_USING);
2232 set_identifier_type_value (name, newtype);
2235 /* Emit debug info. */
2236 if (!processing_template_decl)
2237 cp_emit_debug_info_for_using (orig_decl, current_scope());
2240 /* Returns true if ROOT (a namespace, class, or function) encloses
2241 CHILD. CHILD may be either a class type or a namespace. */
2244 is_ancestor (tree root, tree child)
2246 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2247 || TREE_CODE (root) == FUNCTION_DECL
2248 || CLASS_TYPE_P (root)));
2249 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2250 || CLASS_TYPE_P (child)));
2252 /* The global namespace encloses everything. */
2253 if (root == global_namespace)
2258 /* If we've run out of scopes, stop. */
2261 /* If we've reached the ROOT, it encloses CHILD. */
2264 /* Go out one level. */
2266 child = TYPE_NAME (child);
2267 child = DECL_CONTEXT (child);
2271 /* Enter the class or namespace scope indicated by T suitable for name
2272 lookup. T can be arbitrary scope, not necessary nested inside the
2273 current scope. Returns a non-null scope to pop iff pop_scope
2274 should be called later to exit this scope. */
2279 if (TREE_CODE (t) == NAMESPACE_DECL)
2280 push_decl_namespace (t);
2281 else if (CLASS_TYPE_P (t))
2283 if (!at_class_scope_p ()
2284 || !same_type_p (current_class_type, t))
2285 push_nested_class (t);
2287 /* T is the same as the current scope. There is therefore no
2288 need to re-enter the scope. Since we are not actually
2289 pushing a new scope, our caller should not call
2297 /* Leave scope pushed by push_scope. */
2302 if (TREE_CODE (t) == NAMESPACE_DECL)
2303 pop_decl_namespace ();
2304 else if CLASS_TYPE_P (t)
2305 pop_nested_class ();
2308 /* Subroutine of push_inner_scope. */
2311 push_inner_scope_r (tree outer, tree inner)
2316 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2319 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2321 push_inner_scope_r (outer, prev);
2322 if (TREE_CODE (inner) == NAMESPACE_DECL)
2324 struct cp_binding_level *save_template_parm = 0;
2325 /* Temporary take out template parameter scopes. They are saved
2326 in reversed order in save_template_parm. */
2327 while (current_binding_level->kind == sk_template_parms)
2329 struct cp_binding_level *b = current_binding_level;
2330 current_binding_level = b->level_chain;
2331 b->level_chain = save_template_parm;
2332 save_template_parm = b;
2335 resume_scope (NAMESPACE_LEVEL (inner));
2336 current_namespace = inner;
2338 /* Restore template parameter scopes. */
2339 while (save_template_parm)
2341 struct cp_binding_level *b = save_template_parm;
2342 save_template_parm = b->level_chain;
2343 b->level_chain = current_binding_level;
2344 current_binding_level = b;
2351 /* Enter the scope INNER from current scope. INNER must be a scope
2352 nested inside current scope. This works with both name lookup and
2353 pushing name into scope. In case a template parameter scope is present,
2354 namespace is pushed under the template parameter scope according to
2355 name lookup rule in 14.6.1/6.
2357 Return the former current scope suitable for pop_inner_scope. */
2360 push_inner_scope (tree inner)
2362 tree outer = current_scope ();
2364 outer = current_namespace;
2366 push_inner_scope_r (outer, inner);
2370 /* Exit the current scope INNER back to scope OUTER. */
2373 pop_inner_scope (tree outer, tree inner)
2376 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2379 while (outer != inner)
2381 if (TREE_CODE (inner) == NAMESPACE_DECL)
2383 struct cp_binding_level *save_template_parm = 0;
2384 /* Temporary take out template parameter scopes. They are saved
2385 in reversed order in save_template_parm. */
2386 while (current_binding_level->kind == sk_template_parms)
2388 struct cp_binding_level *b = current_binding_level;
2389 current_binding_level = b->level_chain;
2390 b->level_chain = save_template_parm;
2391 save_template_parm = b;
2396 /* Restore template parameter scopes. */
2397 while (save_template_parm)
2399 struct cp_binding_level *b = save_template_parm;
2400 save_template_parm = b->level_chain;
2401 b->level_chain = current_binding_level;
2402 current_binding_level = b;
2408 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2412 /* Do a pushlevel for class declarations. */
2415 pushlevel_class (void)
2417 if (ENABLE_SCOPE_CHECKING)
2420 class_binding_level = begin_scope (sk_class, current_class_type);
2423 /* ...and a poplevel for class declarations. */
2426 poplevel_class (void)
2428 struct cp_binding_level *level = class_binding_level;
2429 cp_class_binding *cb;
2433 timevar_push (TV_NAME_LOOKUP);
2434 gcc_assert (level != 0);
2436 /* If we're leaving a toplevel class, cache its binding level. */
2437 if (current_class_depth == 1)
2438 previous_class_level = level;
2439 for (shadowed = level->type_shadowed;
2441 shadowed = TREE_CHAIN (shadowed))
2442 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2444 /* Remove the bindings for all of the class-level declarations. */
2445 if (level->class_shadowed)
2448 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2450 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2451 ggc_free (level->class_shadowed);
2452 level->class_shadowed = NULL;
2455 /* Now, pop out of the binding level which we created up in the
2456 `pushlevel_class' routine. */
2457 if (ENABLE_SCOPE_CHECKING)
2461 timevar_pop (TV_NAME_LOOKUP);
2464 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2465 appropriate. DECL is the value to which a name has just been
2466 bound. CLASS_TYPE is the class in which the lookup occurred. */
2469 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2472 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2476 if (TREE_CODE (decl) == OVERLOAD)
2477 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2480 gcc_assert (DECL_P (decl));
2481 context = context_for_name_lookup (decl);
2484 if (is_properly_derived_from (class_type, context))
2485 INHERITED_VALUE_BINDING_P (binding) = 1;
2487 INHERITED_VALUE_BINDING_P (binding) = 0;
2489 else if (binding->value == decl)
2490 /* We only encounter a TREE_LIST when there is an ambiguity in the
2491 base classes. Such an ambiguity can be overridden by a
2492 definition in this class. */
2493 INHERITED_VALUE_BINDING_P (binding) = 1;
2495 INHERITED_VALUE_BINDING_P (binding) = 0;
2498 /* Make the declaration of X appear in CLASS scope. */
2501 pushdecl_class_level (tree x)
2504 bool is_valid = true;
2506 timevar_push (TV_NAME_LOOKUP);
2507 /* Get the name of X. */
2508 if (TREE_CODE (x) == OVERLOAD)
2509 name = DECL_NAME (get_first_fn (x));
2511 name = DECL_NAME (x);
2515 is_valid = push_class_level_binding (name, x);
2516 if (TREE_CODE (x) == TYPE_DECL)
2517 set_identifier_type_value (name, x);
2519 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2521 /* If X is an anonymous aggregate, all of its members are
2522 treated as if they were members of the class containing the
2523 aggregate, for naming purposes. */
2526 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2528 location_t save_location = input_location;
2529 input_location = DECL_SOURCE_LOCATION (f);
2530 if (!pushdecl_class_level (f))
2532 input_location = save_location;
2535 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2538 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2539 scope. If the value returned is non-NULL, and the PREVIOUS field
2540 is not set, callers must set the PREVIOUS field explicitly. */
2542 static cxx_binding *
2543 get_class_binding (tree name, cxx_scope *scope)
2548 cxx_binding *binding;
2550 class_type = scope->this_entity;
2552 /* Get the type binding. */
2553 type_binding = lookup_member (class_type, name,
2554 /*protect=*/2, /*want_type=*/true);
2555 /* Get the value binding. */
2556 value_binding = lookup_member (class_type, name,
2557 /*protect=*/2, /*want_type=*/false);
2560 && (TREE_CODE (value_binding) == TYPE_DECL
2561 || DECL_CLASS_TEMPLATE_P (value_binding)
2562 || (TREE_CODE (value_binding) == TREE_LIST
2563 && TREE_TYPE (value_binding) == error_mark_node
2564 && (TREE_CODE (TREE_VALUE (value_binding))
2566 /* We found a type binding, even when looking for a non-type
2567 binding. This means that we already processed this binding
2570 else if (value_binding)
2572 if (TREE_CODE (value_binding) == TREE_LIST
2573 && TREE_TYPE (value_binding) == error_mark_node)
2574 /* NAME is ambiguous. */
2576 else if (BASELINK_P (value_binding))
2577 /* NAME is some overloaded functions. */
2578 value_binding = BASELINK_FUNCTIONS (value_binding);
2581 /* If we found either a type binding or a value binding, create a
2582 new binding object. */
2583 if (type_binding || value_binding)
2585 binding = new_class_binding (name,
2589 /* This is a class-scope binding, not a block-scope binding. */
2590 LOCAL_BINDING_P (binding) = 0;
2591 set_inherited_value_binding_p (binding, value_binding, class_type);
2599 /* Make the declaration(s) of X appear in CLASS scope under the name
2600 NAME. Returns true if the binding is valid. */
2603 push_class_level_binding (tree name, tree x)
2605 cxx_binding *binding;
2609 timevar_push (TV_NAME_LOOKUP);
2610 /* The class_binding_level will be NULL if x is a template
2611 parameter name in a member template. */
2612 if (!class_binding_level)
2613 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2615 if (name == error_mark_node)
2616 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2618 /* Check for invalid member names. */
2619 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2620 /* We could have been passed a tree list if this is an ambiguous
2621 declaration. If so, pull the declaration out because
2622 check_template_shadow will not handle a TREE_LIST. */
2623 if (TREE_CODE (decl) == TREE_LIST
2624 && TREE_TYPE (decl) == error_mark_node)
2625 decl = TREE_VALUE (decl);
2627 check_template_shadow (decl);
2631 If T is the name of a class, then each of the following shall
2632 have a name different from T:
2634 -- every static data member of class T;
2636 -- every member of class T that is itself a type;
2638 -- every enumerator of every member of class T that is an
2641 -- every member of every anonymous union that is a member of
2644 (Non-static data members were also forbidden to have the same
2645 name as T until TC1.) */
2646 if ((TREE_CODE (x) == VAR_DECL
2647 || TREE_CODE (x) == CONST_DECL
2648 || (TREE_CODE (x) == TYPE_DECL
2649 && !DECL_SELF_REFERENCE_P (x))
2650 /* A data member of an anonymous union. */
2651 || (TREE_CODE (x) == FIELD_DECL
2652 && DECL_CONTEXT (x) != current_class_type))
2653 && DECL_NAME (x) == constructor_name (current_class_type))
2655 tree scope = context_for_name_lookup (x);
2656 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2658 error ("%qD has the same name as the class in which it is "
2661 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2665 /* Get the current binding for NAME in this class, if any. */
2666 binding = IDENTIFIER_BINDING (name);
2667 if (!binding || binding->scope != class_binding_level)
2669 binding = get_class_binding (name, class_binding_level);
2670 /* If a new binding was created, put it at the front of the
2671 IDENTIFIER_BINDING list. */
2674 binding->previous = IDENTIFIER_BINDING (name);
2675 IDENTIFIER_BINDING (name) = binding;
2679 /* If there is already a binding, then we may need to update the
2681 if (binding && binding->value)
2683 tree bval = binding->value;
2684 tree old_decl = NULL_TREE;
2686 if (INHERITED_VALUE_BINDING_P (binding))
2688 /* If the old binding was from a base class, and was for a
2689 tag name, slide it over to make room for the new binding.
2690 The old binding is still visible if explicitly qualified
2691 with a class-key. */
2692 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2693 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2695 old_decl = binding->type;
2696 binding->type = bval;
2697 binding->value = NULL_TREE;
2698 INHERITED_VALUE_BINDING_P (binding) = 0;
2703 /* Any inherited type declaration is hidden by the type
2704 declaration in the derived class. */
2705 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2706 binding->type = NULL_TREE;
2709 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2711 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2712 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2713 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2715 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2718 if (old_decl && binding->scope == class_binding_level)
2721 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2722 here. This function is only used to register bindings
2723 from with the class definition itself. */
2724 INHERITED_VALUE_BINDING_P (binding) = 0;
2725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2729 /* Note that we declared this value so that we can issue an error if
2730 this is an invalid redeclaration of a name already used for some
2732 note_name_declared_in_class (name, decl);
2734 /* If we didn't replace an existing binding, put the binding on the
2735 stack of bindings for the identifier, and update the shadowed
2737 if (binding && binding->scope == class_binding_level)
2738 /* Supplement the existing binding. */
2739 ok = supplement_binding (binding, decl);
2742 /* Create a new binding. */
2743 push_binding (name, decl, class_binding_level);
2747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2750 /* Process "using SCOPE::NAME" in a class scope. Return the
2751 USING_DECL created. */
2754 do_class_using_decl (tree scope, tree name)
2756 /* The USING_DECL returned by this function. */
2758 /* The declaration (or declarations) name by this using
2759 declaration. NULL if we are in a template and cannot figure out
2760 what has been named. */
2762 /* True if SCOPE is a dependent type. */
2763 bool scope_dependent_p;
2764 /* True if SCOPE::NAME is dependent. */
2765 bool name_dependent_p;
2766 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2767 bool bases_dependent_p;
2772 if (name == error_mark_node)
2775 if (!scope || !TYPE_P (scope))
2777 error ("using-declaration for non-member at class scope");
2781 /* Make sure the name is not invalid */
2782 if (TREE_CODE (name) == BIT_NOT_EXPR)
2784 error ("%<%T::%D%> names destructor", scope, name);
2787 if (constructor_name_p (name, scope))
2789 error ("%<%T::%D%> names constructor", scope, name);
2792 if (constructor_name_p (name, current_class_type))
2794 error ("%<%T::%D%> names constructor in %qT",
2795 scope, name, current_class_type);
2799 scope_dependent_p = dependent_type_p (scope);
2800 name_dependent_p = (scope_dependent_p
2801 || (IDENTIFIER_TYPENAME_P (name)
2802 && dependent_type_p (TREE_TYPE (name))));
2804 bases_dependent_p = false;
2805 if (processing_template_decl)
2806 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2807 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2809 if (dependent_type_p (TREE_TYPE (base_binfo)))
2811 bases_dependent_p = true;
2817 /* From [namespace.udecl]:
2819 A using-declaration used as a member-declaration shall refer to a
2820 member of a base class of the class being defined.
2822 In general, we cannot check this constraint in a template because
2823 we do not know the entire set of base classes of the current
2824 class type. However, if all of the base classes are
2825 non-dependent, then we can avoid delaying the check until
2827 if (!scope_dependent_p && !bases_dependent_p)
2831 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2832 if (b_kind < bk_proper_base)
2834 error_not_base_type (scope, current_class_type);
2838 if (!name_dependent_p)
2840 decl = lookup_member (binfo, name, 0, false);
2843 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2847 /* The binfo from which the functions came does not matter. */
2848 if (BASELINK_P (decl))
2849 decl = BASELINK_FUNCTIONS (decl);
2853 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2854 USING_DECL_DECLS (value) = decl;
2855 USING_DECL_SCOPE (value) = scope;
2856 DECL_DEPENDENT_P (value) = !decl;
2862 /* Return the binding value for name in scope. */
2865 namespace_binding (tree name, tree scope)
2867 cxx_binding *binding;
2870 scope = global_namespace;
2872 /* Unnecessary for the global namespace because it can't be an alias. */
2873 scope = ORIGINAL_NAMESPACE (scope);
2875 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2877 return binding ? binding->value : NULL_TREE;
2880 /* Set the binding value for name in scope. */
2883 set_namespace_binding (tree name, tree scope, tree val)
2887 timevar_push (TV_NAME_LOOKUP);
2888 if (scope == NULL_TREE)
2889 scope = global_namespace;
2890 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2891 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2894 supplement_binding (b, val);
2895 timevar_pop (TV_NAME_LOOKUP);
2898 /* Set the context of a declaration to scope. Complain if we are not
2902 set_decl_namespace (tree decl, tree scope, bool friendp)
2906 /* Get rid of namespace aliases. */
2907 scope = ORIGINAL_NAMESPACE (scope);
2909 /* It is ok for friends to be qualified in parallel space. */
2910 if (!friendp && !is_ancestor (current_namespace, scope))
2911 error ("declaration of %qD not in a namespace surrounding %qD",
2913 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2915 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2916 if (scope == current_namespace)
2918 if (at_namespace_scope_p ())
2919 error ("explicit qualification in declaration of %qD",
2924 /* See whether this has been declared in the namespace. */
2925 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2927 /* No old declaration at all. */
2929 if (!is_overloaded_fn (decl))
2930 /* Don't compare non-function decls with decls_match here, since
2931 it can't check for the correct constness at this
2932 point. pushdecl will find those errors later. */
2934 /* Since decl is a function, old should contain a function decl. */
2935 if (!is_overloaded_fn (old))
2937 fn = OVL_CURRENT (old);
2938 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2940 /* A template can be explicitly specialized in any namespace. */
2941 if (processing_explicit_instantiation)
2943 if (processing_template_decl || processing_specialization)
2944 /* We have not yet called push_template_decl to turn a
2945 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2946 match. But, we'll check later, when we construct the
2949 /* Instantiations or specializations of templates may be declared as
2950 friends in any namespace. */
2951 if (friendp && DECL_USE_TEMPLATE (decl))
2953 if (is_overloaded_fn (old))
2955 for (; old; old = OVL_NEXT (old))
2956 if (decls_match (decl, OVL_CURRENT (old)))
2959 else if (decls_match (decl, old))
2962 error ("%qD should have been declared inside %qD", decl, scope);
2965 /* Return the namespace where the current declaration is declared. */
2968 current_decl_namespace (void)
2971 /* If we have been pushed into a different namespace, use it. */
2972 if (decl_namespace_list)
2973 return TREE_PURPOSE (decl_namespace_list);
2975 if (current_class_type)
2976 result = decl_namespace_context (current_class_type);
2977 else if (current_function_decl)
2978 result = decl_namespace_context (current_function_decl);
2980 result = current_namespace;
2984 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2985 select a name that is unique to this compilation unit. */
2988 push_namespace (tree name)
2990 push_namespace_with_attribs (name, NULL_TREE);
2993 /* Same, but specify attributes to apply to the namespace. The attributes
2994 only apply to the current namespace-body, not to any later extensions. */
2997 push_namespace_with_attribs (tree name, tree attributes)
3001 int implicit_use = 0;
3004 timevar_push (TV_NAME_LOOKUP);
3006 /* We should not get here if the global_namespace is not yet constructed
3007 nor if NAME designates the global namespace: The global scope is
3008 constructed elsewhere. */
3009 gcc_assert (global_namespace != NULL && name != global_scope_name);
3013 /* The name of anonymous namespace is unique for the translation
3015 if (!anonymous_namespace_name)
3016 anonymous_namespace_name = get_file_function_name ('N');
3017 name = anonymous_namespace_name;
3018 d = IDENTIFIER_NAMESPACE_VALUE (name);
3020 /* Reopening anonymous namespace. */
3026 /* Check whether this is an extended namespace definition. */
3027 d = IDENTIFIER_NAMESPACE_VALUE (name);
3028 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3031 if (DECL_NAMESPACE_ALIAS (d))
3033 error ("namespace alias %qD not allowed here, assuming %qD",
3034 d, DECL_NAMESPACE_ALIAS (d));
3035 d = DECL_NAMESPACE_ALIAS (d);
3042 /* Make a new namespace, binding the name to it. */
3043 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3044 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3045 /* The name of this namespace is not visible to other translation
3046 units if it is an anonymous namespace or member thereof. */
3047 if (anon || decl_anon_ns_mem_p (current_namespace))
3048 TREE_PUBLIC (d) = 0;
3050 TREE_PUBLIC (d) = 1;
3054 /* Clear DECL_NAME for the benefit of debugging back ends. */
3055 SET_DECL_ASSEMBLER_NAME (d, name);
3056 DECL_NAME (d) = NULL_TREE;
3058 begin_scope (sk_namespace, d);
3061 resume_scope (NAMESPACE_LEVEL (d));
3064 do_using_directive (d);
3065 /* Enter the name space. */
3066 current_namespace = d;
3068 #ifdef HANDLE_PRAGMA_VISIBILITY
3069 /* Clear has_visibility in case a previous namespace-definition had a
3070 visibility attribute and this one doesn't. */
3071 current_binding_level->has_visibility = 0;
3072 for (d = attributes; d; d = TREE_CHAIN (d))
3074 tree name = TREE_PURPOSE (d);
3075 tree args = TREE_VALUE (d);
3078 if (! is_attribute_p ("visibility", name))
3080 warning (OPT_Wattributes, "%qs attribute directive ignored",
3081 IDENTIFIER_POINTER (name));
3085 x = args ? TREE_VALUE (args) : NULL_TREE;
3086 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3088 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3089 IDENTIFIER_POINTER (name));
3093 current_binding_level->has_visibility = 1;
3094 push_visibility (TREE_STRING_POINTER (x));
3100 timevar_pop (TV_NAME_LOOKUP);
3103 /* Pop from the scope of the current namespace. */
3106 pop_namespace (void)
3108 gcc_assert (current_namespace != global_namespace);
3109 current_namespace = CP_DECL_CONTEXT (current_namespace);
3110 /* The binding level is not popped, as it might be re-opened later. */
3114 /* Push into the scope of the namespace NS, even if it is deeply
3115 nested within another namespace. */
3118 push_nested_namespace (tree ns)
3120 if (ns == global_namespace)
3121 push_to_top_level ();
3124 push_nested_namespace (CP_DECL_CONTEXT (ns));
3125 push_namespace (DECL_NAME (ns));
3129 /* Pop back from the scope of the namespace NS, which was previously
3130 entered with push_nested_namespace. */
3133 pop_nested_namespace (tree ns)
3135 timevar_push (TV_NAME_LOOKUP);
3136 while (ns != global_namespace)
3139 ns = CP_DECL_CONTEXT (ns);
3142 pop_from_top_level ();
3143 timevar_pop (TV_NAME_LOOKUP);
3146 /* Temporarily set the namespace for the current declaration. */
3149 push_decl_namespace (tree decl)
3151 if (TREE_CODE (decl) != NAMESPACE_DECL)
3152 decl = decl_namespace_context (decl);
3153 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3154 NULL_TREE, decl_namespace_list);
3157 /* [namespace.memdef]/2 */
3160 pop_decl_namespace (void)
3162 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3165 /* Return the namespace that is the common ancestor
3166 of two given namespaces. */
3169 namespace_ancestor (tree ns1, tree ns2)
3171 timevar_push (TV_NAME_LOOKUP);
3172 if (is_ancestor (ns1, ns2))
3173 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3174 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3175 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3178 /* Process a namespace-alias declaration. */
3181 do_namespace_alias (tree alias, tree namespace)
3183 if (namespace == error_mark_node)
3186 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3188 namespace = ORIGINAL_NAMESPACE (namespace);
3190 /* Build the alias. */
3191 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3192 DECL_NAMESPACE_ALIAS (alias) = namespace;
3193 DECL_EXTERNAL (alias) = 1;
3194 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3197 /* Emit debug info for namespace alias. */
3198 (*debug_hooks->global_decl) (alias);
3201 /* Like pushdecl, only it places X in the current namespace,
3205 pushdecl_namespace_level (tree x, bool is_friend)
3207 struct cp_binding_level *b = current_binding_level;
3210 timevar_push (TV_NAME_LOOKUP);
3211 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3213 /* Now, the type_shadowed stack may screw us. Munge it so it does
3215 if (TREE_CODE (t) == TYPE_DECL)
3217 tree name = DECL_NAME (t);
3219 tree *ptr = (tree *)0;
3220 for (; !global_scope_p (b); b = b->level_chain)
3222 tree shadowed = b->type_shadowed;
3223 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3224 if (TREE_PURPOSE (shadowed) == name)
3226 ptr = &TREE_VALUE (shadowed);
3227 /* Can't break out of the loop here because sometimes
3228 a binding level will have duplicate bindings for
3229 PT names. It's gross, but I haven't time to fix it. */
3232 newval = TREE_TYPE (t);
3233 if (ptr == (tree *)0)
3235 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3236 up here if this is changed to an assertion. --KR */
3237 SET_IDENTIFIER_TYPE_VALUE (name, t);
3244 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3247 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3248 directive is not directly from the source. Also find the common
3249 ancestor and let our users know about the new namespace */
3251 add_using_namespace (tree user, tree used, bool indirect)
3254 timevar_push (TV_NAME_LOOKUP);
3255 /* Using oneself is a no-op. */
3258 timevar_pop (TV_NAME_LOOKUP);
3261 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3262 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3263 /* Check if we already have this. */
3264 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3268 /* Promote to direct usage. */
3269 TREE_INDIRECT_USING (t) = 0;
3270 timevar_pop (TV_NAME_LOOKUP);
3274 /* Add used to the user's using list. */
3275 DECL_NAMESPACE_USING (user)
3276 = tree_cons (used, namespace_ancestor (user, used),
3277 DECL_NAMESPACE_USING (user));
3279 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3281 /* Add user to the used's users list. */
3282 DECL_NAMESPACE_USERS (used)
3283 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3285 /* Recursively add all namespaces used. */
3286 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3287 /* indirect usage */
3288 add_using_namespace (user, TREE_PURPOSE (t), 1);
3290 /* Tell everyone using us about the new used namespaces. */
3291 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3292 add_using_namespace (TREE_PURPOSE (t), used, 1);
3293 timevar_pop (TV_NAME_LOOKUP);
3296 /* Process a using-declaration not appearing in class or local scope. */
3299 do_toplevel_using_decl (tree decl, tree scope, tree name)
3301 tree oldval, oldtype, newval, newtype;
3302 tree orig_decl = decl;
3303 cxx_binding *binding;
3305 decl = validate_nonmember_using_decl (decl, scope, name);
3306 if (decl == NULL_TREE)
3309 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3311 oldval = binding->value;
3312 oldtype = binding->type;
3314 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3316 /* Emit debug info. */
3317 if (!processing_template_decl)
3318 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3320 /* Copy declarations found. */
3322 binding->value = newval;
3324 binding->type = newtype;
3327 /* Process a using-directive. */
3330 do_using_directive (tree namespace)
3332 tree context = NULL_TREE;
3334 if (namespace == error_mark_node)
3337 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3339 if (building_stmt_tree ())
3340 add_stmt (build_stmt (USING_STMT, namespace));
3341 namespace = ORIGINAL_NAMESPACE (namespace);
3343 if (!toplevel_bindings_p ())
3345 push_using_directive (namespace);
3346 context = current_scope ();
3351 add_using_namespace (current_namespace, namespace, 0);
3352 if (current_namespace != global_namespace)
3353 context = current_namespace;
3356 /* Emit debugging info. */
3357 if (!processing_template_decl)
3358 (*debug_hooks->imported_module_or_decl) (namespace, context);
3361 /* Deal with a using-directive seen by the parser. Currently we only
3362 handle attributes here, since they cannot appear inside a template. */
3365 parse_using_directive (tree namespace, tree attribs)
3369 do_using_directive (namespace);
3371 for (a = attribs; a; a = TREE_CHAIN (a))
3373 tree name = TREE_PURPOSE (a);
3374 if (is_attribute_p ("strong", name))
3376 if (!toplevel_bindings_p ())
3377 error ("strong using only meaningful at namespace scope");
3378 else if (namespace != error_mark_node)
3380 if (!is_ancestor (current_namespace, namespace))
3381 error ("current namespace %qD does not enclose strongly used namespace %qD",
3382 current_namespace, namespace);
3383 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3384 = tree_cons (current_namespace, 0,
3385 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3389 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3393 /* Like pushdecl, only it places X in the global scope if appropriate.
3394 Calls cp_finish_decl to register the variable, initializing it with
3395 *INIT, if INIT is non-NULL. */
3398 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3400 timevar_push (TV_NAME_LOOKUP);
3401 push_to_top_level ();
3402 x = pushdecl_namespace_level (x, is_friend);
3404 finish_decl (x, *init, NULL_TREE);
3405 pop_from_top_level ();
3406 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3409 /* Like pushdecl, only it places X in the global scope if appropriate. */
3412 pushdecl_top_level (tree x)
3414 return pushdecl_top_level_1 (x, NULL, false);
3417 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3420 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3422 return pushdecl_top_level_1 (x, NULL, is_friend);
3425 /* Like pushdecl, only it places X in the global scope if
3426 appropriate. Calls cp_finish_decl to register the variable,
3427 initializing it with INIT. */
3430 pushdecl_top_level_and_finish (tree x, tree init)
3432 return pushdecl_top_level_1 (x, &init, false);
3435 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3436 duplicates. The first list becomes the tail of the result.
3438 The algorithm is O(n^2). We could get this down to O(n log n) by
3439 doing a sort on the addresses of the functions, if that becomes
3443 merge_functions (tree s1, tree s2)
3445 for (; s2; s2 = OVL_NEXT (s2))
3447 tree fn2 = OVL_CURRENT (s2);
3450 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3452 tree fn1 = OVL_CURRENT (fns1);
3454 /* If the function from S2 is already in S1, there is no
3455 need to add it again. For `extern "C"' functions, we
3456 might have two FUNCTION_DECLs for the same function, in
3457 different namespaces; again, we only need one of them. */
3459 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3460 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3464 /* If we exhausted all of the functions in S1, FN2 is new. */
3466 s1 = build_overload (fn2, s1);
3471 /* This should return an error not all definitions define functions.
3472 It is not an error if we find two functions with exactly the
3473 same signature, only if these are selected in overload resolution.
3474 old is the current set of bindings, new the freshly-found binding.
3475 XXX Do we want to give *all* candidates in case of ambiguity?
3476 XXX In what way should I treat extern declarations?
3477 XXX I don't want to repeat the entire duplicate_decls here */
3480 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3484 gcc_assert (old != NULL);
3485 /* Copy the value. */
3488 switch (TREE_CODE (val))
3491 /* If we expect types or namespaces, and not templates,
3492 or this is not a template class. */
3493 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3494 && !DECL_CLASS_TEMPLATE_P (val))
3495 || hidden_name_p (val))
3499 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3502 case NAMESPACE_DECL:
3503 if (LOOKUP_TYPES_ONLY (flags))
3507 /* Ignore built-in functions that are still anticipated. */
3508 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3512 if (LOOKUP_QUALIFIERS_ONLY (flags))
3518 else if (val && val != old->value)
3520 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3521 old->value = merge_functions (old->value, val);
3524 old->value = tree_cons (NULL_TREE, old->value,
3525 build_tree_list (NULL_TREE, new->value));
3526 TREE_TYPE (old->value) = error_mark_node;
3529 /* ... and copy the type. */
3531 if (LOOKUP_NAMESPACES_ONLY (flags))
3535 else if (type && old->type != type)
3537 if (flags & LOOKUP_COMPLAIN)
3539 error ("%qD denotes an ambiguous type",name);
3540 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3541 error ("%J other type here", TYPE_MAIN_DECL (type));
3546 /* Return the declarations that are members of the namespace NS. */
3549 cp_namespace_decls (tree ns)
3551 return NAMESPACE_LEVEL (ns)->names;
3554 /* Combine prefer_type and namespaces_only into flags. */
3557 lookup_flags (int prefer_type, int namespaces_only)
3559 if (namespaces_only)
3560 return LOOKUP_PREFER_NAMESPACES;
3561 if (prefer_type > 1)
3562 return LOOKUP_PREFER_TYPES;
3563 if (prefer_type > 0)
3564 return LOOKUP_PREFER_BOTH;
3568 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3569 ignore it or not. Subroutine of lookup_name_real and
3570 lookup_type_scope. */
3573 qualify_lookup (tree val, int flags)
3575 if (val == NULL_TREE)
3577 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3579 if ((flags & LOOKUP_PREFER_TYPES)
3580 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3582 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3587 /* Given a lookup that returned VAL, decide if we want to ignore it or
3588 not based on DECL_ANTICIPATED. */
3591 hidden_name_p (tree val)
3594 && DECL_LANG_SPECIFIC (val)
3595 && DECL_ANTICIPATED (val))
3600 /* Remove any hidden friend functions from a possibly overloaded set
3604 remove_hidden_names (tree fns)
3609 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3611 else if (TREE_CODE (fns) == OVERLOAD)
3615 for (o = fns; o; o = OVL_NEXT (o))
3616 if (hidden_name_p (OVL_CURRENT (o)))
3622 for (o = fns; o; o = OVL_NEXT (o))
3623 if (!hidden_name_p (OVL_CURRENT (o)))
3624 n = build_overload (OVL_CURRENT (o), n);
3632 /* Select the right _DECL from multiple choices. */
3635 select_decl (const struct scope_binding *binding, int flags)
3638 val = binding->value;
3640 timevar_push (TV_NAME_LOOKUP);
3641 if (LOOKUP_NAMESPACES_ONLY (flags))
3643 /* We are not interested in types. */
3644 if (val && (TREE_CODE (val) == NAMESPACE_DECL
3645 || TREE_CODE (val) == TREE_LIST))
3646 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3647 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3650 /* If looking for a type, or if there is no non-type binding, select
3651 the value binding. */
3652 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3653 val = binding->type;
3654 /* Don't return non-types if we really prefer types. */
3655 else if (val && LOOKUP_TYPES_ONLY (flags)
3656 && ! DECL_DECLARES_TYPE_P (val))
3659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3662 /* Unscoped lookup of a global: iterate over current namespaces,
3663 considering using-directives. */
3666 unqualified_namespace_lookup (tree name, int flags)
3668 tree initial = current_decl_namespace ();
3669 tree scope = initial;
3671 struct cp_binding_level *level;
3672 tree val = NULL_TREE;
3673 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3675 timevar_push (TV_NAME_LOOKUP);
3677 for (; !val; scope = CP_DECL_CONTEXT (scope))
3680 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3684 if (b->value && hidden_name_p (b->value))
3685 /* Ignore anticipated built-in functions and friends. */
3688 binding.value = b->value;
3689 binding.type = b->type;
3692 /* Add all _DECLs seen through local using-directives. */
3693 for (level = current_binding_level;
3694 level->kind != sk_namespace;
3695 level = level->level_chain)
3696 if (!lookup_using_namespace (name, &binding, level->using_directives,
3698 /* Give up because of error. */
3699 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3701 /* Add all _DECLs seen through global using-directives. */
3702 /* XXX local and global using lists should work equally. */
3706 if (!lookup_using_namespace (name, &binding,
3707 DECL_NAMESPACE_USING (siter),
3709 /* Give up because of error. */
3710 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3711 if (siter == scope) break;
3712 siter = CP_DECL_CONTEXT (siter);
3715 val = select_decl (&binding, flags);
3716 if (scope == global_namespace)
3719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3722 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3723 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3726 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3727 declaration found. If no suitable declaration can be found,
3728 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3729 neither a class-type nor a namespace a diagnostic is issued. */
3732 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3737 if (TREE_CODE (scope) == NAMESPACE_DECL)
3739 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3741 flags |= LOOKUP_COMPLAIN;
3743 flags |= LOOKUP_PREFER_TYPES;
3744 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3745 t = select_decl (&binding, flags);
3747 else if (is_aggr_type (scope, complain))
3748 t = lookup_member (scope, name, 2, is_type_p);
3751 return error_mark_node;
3755 /* Subroutine of unqualified_namespace_lookup:
3756 Add the bindings of NAME in used namespaces to VAL.
3757 We are currently looking for names in namespace SCOPE, so we
3758 look through USINGS for using-directives of namespaces
3759 which have SCOPE as a common ancestor with the current scope.
3760 Returns false on errors. */
3763 lookup_using_namespace (tree name, struct scope_binding *val,
3764 tree usings, tree scope, int flags)
3767 timevar_push (TV_NAME_LOOKUP);
3768 /* Iterate over all used namespaces in current, searching for using
3769 directives of scope. */
3770 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3771 if (TREE_VALUE (iter) == scope)
3773 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3775 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3776 /* Resolve ambiguities. */
3778 ambiguous_decl (name, val, val1, flags);
3780 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3784 Accepts the NAME to lookup and its qualifying SCOPE.
3785 Returns the name/type pair found into the cxx_binding *RESULT,
3786 or false on error. */
3789 qualified_lookup_using_namespace (tree name, tree scope,
3790 struct scope_binding *result, int flags)
3792 /* Maintain a list of namespaces visited... */
3793 tree seen = NULL_TREE;
3794 /* ... and a list of namespace yet to see. */
3795 tree todo = NULL_TREE;
3796 tree todo_maybe = NULL_TREE;
3798 timevar_push (TV_NAME_LOOKUP);
3799 /* Look through namespace aliases. */
3800 scope = ORIGINAL_NAMESPACE (scope);
3801 while (scope && result->value != error_mark_node)
3803 cxx_binding *binding =
3804 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3805 seen = tree_cons (scope, NULL_TREE, seen);
3807 ambiguous_decl (name, result, binding, flags);
3809 /* Consider strong using directives always, and non-strong ones
3810 if we haven't found a binding yet. ??? Shouldn't we consider
3811 non-strong ones if the initial RESULT is non-NULL, but the
3812 binding in the given namespace is? */
3813 for (usings = DECL_NAMESPACE_USING (scope); usings;
3814 usings = TREE_CHAIN (usings))
3815 /* If this was a real directive, and we have not seen it. */
3816 if (!TREE_INDIRECT_USING (usings))
3818 /* Try to avoid queuing the same namespace more than once,
3819 the exception being when a namespace was already
3820 enqueued for todo_maybe and then a strong using is
3821 found for it. We could try to remove it from
3822 todo_maybe, but it's probably not worth the effort. */
3823 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3824 && !purpose_member (TREE_PURPOSE (usings), seen)
3825 && !purpose_member (TREE_PURPOSE (usings), todo))
3826 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3827 else if ((!result->value && !result->type)
3828 && !purpose_member (TREE_PURPOSE (usings), seen)
3829 && !purpose_member (TREE_PURPOSE (usings), todo)
3830 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3831 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3836 scope = TREE_PURPOSE (todo);
3837 todo = TREE_CHAIN (todo);
3840 && (!result->value && !result->type))
3842 scope = TREE_PURPOSE (todo_maybe);
3843 todo = TREE_CHAIN (todo_maybe);
3844 todo_maybe = NULL_TREE;
3847 scope = NULL_TREE; /* If there never was a todo list. */
3849 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3852 /* Return the innermost non-namespace binding for NAME from a scope
3853 containing BINDING, or, if BINDING is NULL, the current scope. If
3854 CLASS_P is false, then class bindings are ignored. */
3857 outer_binding (tree name,
3858 cxx_binding *binding,
3863 cxx_scope *outer_scope;
3867 scope = binding->scope->level_chain;
3868 outer = binding->previous;
3872 scope = current_binding_level;
3873 outer = IDENTIFIER_BINDING (name);
3875 outer_scope = outer ? outer->scope : NULL;
3877 /* Because we create class bindings lazily, we might be missing a
3878 class binding for NAME. If there are any class binding levels
3879 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3880 declared, we must lookup NAME in those class scopes. */
3882 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3884 if (scope->kind == sk_class)
3886 cxx_binding *class_binding;
3888 class_binding = get_class_binding (name, scope);
3891 /* Thread this new class-scope binding onto the
3892 IDENTIFIER_BINDING list so that future lookups
3894 class_binding->previous = outer;
3896 binding->previous = class_binding;
3898 IDENTIFIER_BINDING (name) = class_binding;
3899 return class_binding;
3902 scope = scope->level_chain;
3908 /* Return the innermost block-scope or class-scope value binding for
3909 NAME, or NULL_TREE if there is no such binding. */
3912 innermost_non_namespace_value (tree name)
3914 cxx_binding *binding;
3915 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3916 return binding ? binding->value : NULL_TREE;
3919 /* Look up NAME in the current binding level and its superiors in the
3920 namespace of variables, functions and typedefs. Return a ..._DECL
3921 node of some kind representing its definition if there is only one
3922 such declaration, or return a TREE_LIST with all the overloaded
3923 definitions if there are many, or return 0 if it is undefined.
3924 Hidden name, either friend declaration or built-in function, are
3927 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3928 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3929 Otherwise we prefer non-TYPE_DECLs.
3931 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3932 BLOCK_P is false, bindings in block scopes are ignored. */
3935 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3936 int namespaces_only, int flags)
3939 tree val = NULL_TREE;
3941 timevar_push (TV_NAME_LOOKUP);
3942 /* Conversion operators are handled specially because ordinary
3943 unqualified name lookup will not find template conversion
3945 if (IDENTIFIER_TYPENAME_P (name))
3947 struct cp_binding_level *level;
3949 for (level = current_binding_level;
3950 level && level->kind != sk_namespace;
3951 level = level->level_chain)
3956 /* A conversion operator can only be declared in a class
3958 if (level->kind != sk_class)
3961 /* Lookup the conversion operator in the class. */
3962 class_type = level->this_entity;
3963 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3965 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3968 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3971 flags |= lookup_flags (prefer_type, namespaces_only);
3973 /* First, look in non-namespace scopes. */
3975 if (current_class_type == NULL_TREE)
3978 if (block_p || !nonclass)
3979 for (iter = outer_binding (name, NULL, !nonclass);
3981 iter = outer_binding (name, iter, !nonclass))
3985 /* Skip entities we don't want. */
3986 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3989 /* If this is the kind of thing we're looking for, we're done. */
3990 if (qualify_lookup (iter->value, flags)
3991 && !hidden_name_p (iter->value))
3992 binding = iter->value;
3993 else if ((flags & LOOKUP_PREFER_TYPES)
3994 && qualify_lookup (iter->type, flags)
3995 && !hidden_name_p (iter->type))
3996 binding = iter->type;
3998 binding = NULL_TREE;
4007 /* Now lookup in namespace scopes. */
4009 val = unqualified_namespace_lookup (name, flags);
4011 /* If we have a single function from a using decl, pull it out. */
4012 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4013 val = OVL_FUNCTION (val);
4015 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4019 lookup_name_nonclass (tree name)
4021 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4025 lookup_function_nonclass (tree name, tree args, bool block_p)
4028 lookup_arg_dependent (name,
4029 lookup_name_real (name, 0, 1, block_p, 0,
4035 lookup_name (tree name)
4037 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4041 lookup_name_prefer_type (tree name, int prefer_type)
4043 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4044 0, LOOKUP_COMPLAIN);
4047 /* Look up NAME for type used in elaborated name specifier in
4048 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4049 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4050 name, more scopes are checked if cleanup or template parameter
4051 scope is encountered.
4053 Unlike lookup_name_real, we make sure that NAME is actually
4054 declared in the desired scope, not from inheritance, nor using
4055 directive. For using declaration, there is DR138 still waiting
4056 to be resolved. Hidden name coming from an earlier friend
4057 declaration is also returned.
4059 A TYPE_DECL best matching the NAME is returned. Catching error
4060 and issuing diagnostics are caller's responsibility. */
4063 lookup_type_scope (tree name, tag_scope scope)
4065 cxx_binding *iter = NULL;
4066 tree val = NULL_TREE;
4068 timevar_push (TV_NAME_LOOKUP);
4070 /* Look in non-namespace scope first. */
4071 if (current_binding_level->kind != sk_namespace)
4072 iter = outer_binding (name, NULL, /*class_p=*/ true);
4073 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4075 /* Check if this is the kind of thing we're looking for.
4076 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4077 base class. For ITER->VALUE, we can simply use
4078 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4081 We check ITER->TYPE before ITER->VALUE in order to handle
4082 typedef struct C {} C;
4085 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4086 && (scope != ts_current
4087 || LOCAL_BINDING_P (iter)
4088 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4090 else if ((scope != ts_current
4091 || !INHERITED_VALUE_BINDING_P (iter))
4092 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4099 /* Look in namespace scope. */
4102 iter = cxx_scope_find_binding_for_name
4103 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4107 /* If this is the kind of thing we're looking for, we're done. */
4108 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4110 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4116 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4117 and template parameter scopes. */
4120 struct cp_binding_level *b = current_binding_level;
4123 if (iter->scope == b)
4124 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4126 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4128 else if (b->kind == sk_class
4129 && scope == ts_within_enclosing_non_class)
4136 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4139 /* Similar to `lookup_name' but look only in the innermost non-class
4143 lookup_name_innermost_nonclass_level (tree name)
4145 struct cp_binding_level *b;
4148 timevar_push (TV_NAME_LOOKUP);
4149 b = innermost_nonclass_level ();
4151 if (b->kind == sk_namespace)
4153 t = IDENTIFIER_NAMESPACE_VALUE (name);
4155 /* extern "C" function() */
4156 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4159 else if (IDENTIFIER_BINDING (name)
4160 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4162 cxx_binding *binding;
4163 binding = IDENTIFIER_BINDING (name);
4166 if (binding->scope == b
4167 && !(TREE_CODE (binding->value) == VAR_DECL
4168 && DECL_DEAD_FOR_LOCAL (binding->value)))
4169 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4171 if (b->kind == sk_cleanup)
4178 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4181 /* Like lookup_name_innermost_nonclass_level, but for types. */
4184 lookup_type_current_level (tree name)
4188 timevar_push (TV_NAME_LOOKUP);
4189 gcc_assert (current_binding_level->kind != sk_namespace);
4191 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4192 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4194 struct cp_binding_level *b = current_binding_level;
4197 if (purpose_member (name, b->type_shadowed))
4198 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4199 REAL_IDENTIFIER_TYPE_VALUE (name));
4200 if (b->kind == sk_cleanup)
4207 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4210 /* [basic.lookup.koenig] */
4211 /* A nonzero return value in the functions below indicates an error. */
4222 static bool arg_assoc (struct arg_lookup*, tree);
4223 static bool arg_assoc_args (struct arg_lookup*, tree);
4224 static bool arg_assoc_type (struct arg_lookup*, tree);
4225 static bool add_function (struct arg_lookup *, tree);
4226 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4227 static bool arg_assoc_class (struct arg_lookup *, tree);
4228 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4230 /* Add a function to the lookup structure.
4231 Returns true on error. */
4234 add_function (struct arg_lookup *k, tree fn)
4236 /* We used to check here to see if the function was already in the list,
4237 but that's O(n^2), which is just too expensive for function lookup.
4238 Now we deal with the occasional duplicate in joust. In doing this, we
4239 assume that the number of duplicates will be small compared to the
4240 total number of functions being compared, which should usually be the
4243 /* We must find only functions, or exactly one non-function. */
4246 else if (fn == k->functions)
4248 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4249 k->functions = build_overload (fn, k->functions);
4252 tree f1 = OVL_CURRENT (k->functions);
4254 if (is_overloaded_fn (f1))
4256 fn = f1; f1 = f2; f2 = fn;
4258 error ("%q+D is not a function,", f1);
4259 error (" conflict with %q+D", f2);
4260 error (" in call to %qD", k->name);
4267 /* Returns true iff CURRENT has declared itself to be an associated
4268 namespace of SCOPE via a strong using-directive (or transitive chain
4269 thereof). Both are namespaces. */
4272 is_associated_namespace (tree current, tree scope)
4274 tree seen = NULL_TREE;
4275 tree todo = NULL_TREE;
4279 if (scope == current)
4281 seen = tree_cons (scope, NULL_TREE, seen);
4282 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4283 if (!purpose_member (TREE_PURPOSE (t), seen))
4284 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4287 scope = TREE_PURPOSE (todo);
4288 todo = TREE_CHAIN (todo);
4295 /* Return whether FN is a friend of an associated class of ARG. */
4298 friend_of_associated_class_p (tree arg, tree fn)
4304 else if (type_unknown_p (arg))
4307 type = TREE_TYPE (arg);
4309 /* If TYPE is a class, the class itself and all base classes are
4310 associated classes. */
4311 if (CLASS_TYPE_P (type))
4313 if (is_friend (type, fn))
4316 if (TYPE_BINFO (type))
4318 tree binfo, base_binfo;
4321 for (binfo = TYPE_BINFO (type), i = 0;
4322 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4324 if (is_friend (BINFO_TYPE (base_binfo), fn))
4329 /* If TYPE is a class member, the class of which it is a member is
4330 an associated class. */
4331 if ((CLASS_TYPE_P (type)
4332 || TREE_CODE (type) == UNION_TYPE
4333 || TREE_CODE (type) == ENUMERAL_TYPE)
4334 && TYPE_CONTEXT (type)
4335 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4336 && is_friend (TYPE_CONTEXT (type), fn))
4342 /* Add functions of a namespace to the lookup structure.
4343 Returns true on error. */
4346 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4350 if (purpose_member (scope, k->namespaces))
4352 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4354 /* Check out our super-users. */
4355 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4356 value = TREE_CHAIN (value))
4357 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4360 value = namespace_binding (k->name, scope);
4364 for (; value; value = OVL_NEXT (value))
4366 /* We don't want to find arbitrary hidden functions via argument
4367 dependent lookup. We only want to find friends of associated
4369 if (hidden_name_p (OVL_CURRENT (value)))
4373 for (args = k->args; args; args = TREE_CHAIN (args))
4374 if (friend_of_associated_class_p (TREE_VALUE (args),
4375 OVL_CURRENT (value)))
4381 if (add_function (k, OVL_CURRENT (value)))
4388 /* Adds everything associated with a template argument to the lookup
4389 structure. Returns true on error. */
4392 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4394 /* [basic.lookup.koenig]
4396 If T is a template-id, its associated namespaces and classes are
4397 ... the namespaces and classes associated with the types of the
4398 template arguments provided for template type parameters
4399 (excluding template template parameters); the namespaces in which
4400 any template template arguments are defined; and the classes in
4401 which any member templates used as template template arguments
4402 are defined. [Note: non-type template arguments do not
4403 contribute to the set of associated namespaces. ] */
4405 /* Consider first template template arguments. */
4406 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4407 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4409 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4411 tree ctx = CP_DECL_CONTEXT (arg);
4413 /* It's not a member template. */
4414 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4415 return arg_assoc_namespace (k, ctx);
4416 /* Otherwise, it must be member template. */
4418 return arg_assoc_class (k, ctx);
4420 /* It's not a template template argument, but it is a type template
4422 else if (TYPE_P (arg))
4423 return arg_assoc_type (k, arg);
4424 /* It's a non-type template argument. */
4429 /* Adds everything associated with class to the lookup structure.
4430 Returns true on error. */
4433 arg_assoc_class (struct arg_lookup *k, tree type)
4435 tree list, friends, context;
4438 /* Backend build structures, such as __builtin_va_list, aren't
4439 affected by all this. */
4440 if (!CLASS_TYPE_P (type))
4443 if (purpose_member (type, k->classes))
4445 k->classes = tree_cons (type, NULL_TREE, k->classes);
4447 context = decl_namespace_context (type);
4448 if (arg_assoc_namespace (k, context))
4451 if (TYPE_BINFO (type))
4453 /* Process baseclasses. */
4454 tree binfo, base_binfo;
4456 for (binfo = TYPE_BINFO (type), i = 0;
4457 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4458 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4462 /* Process friends. */
4463 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4464 list = TREE_CHAIN (list))
4465 if (k->name == FRIEND_NAME (list))
4466 for (friends = FRIEND_DECLS (list); friends;
4467 friends = TREE_CHAIN (friends))
4469 tree fn = TREE_VALUE (friends);
4471 /* Only interested in global functions with potentially hidden
4472 (i.e. unqualified) declarations. */
4473 if (CP_DECL_CONTEXT (fn) != context)
4475 /* Template specializations are never found by name lookup.
4476 (Templates themselves can be found, but not template
4477 specializations.) */
4478 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4480 if (add_function (k, fn))
4484 /* Process template arguments. */
4485 if (CLASSTYPE_TEMPLATE_INFO (type)
4486 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4488 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4489 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4490 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4496 /* Adds everything associated with a given type.
4497 Returns 1 on error. */
4500 arg_assoc_type (struct arg_lookup *k, tree type)
4502 /* As we do not get the type of non-type dependent expressions
4503 right, we can end up with such things without a type. */
4507 if (TYPE_PTRMEM_P (type))
4509 /* Pointer to member: associate class type and value type. */
4510 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4512 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4514 else switch (TREE_CODE (type))
4526 if (TYPE_PTRMEMFUNC_P (type))
4527 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4528 return arg_assoc_class (k, type);
4530 case REFERENCE_TYPE:
4532 return arg_assoc_type (k, TREE_TYPE (type));
4535 return arg_assoc_namespace (k, decl_namespace_context (type));
4537 /* The basetype is referenced in the first arg type, so just
4540 /* Associate the parameter types. */
4541 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4543 /* Associate the return type. */
4544 return arg_assoc_type (k, TREE_TYPE (type));
4545 case TEMPLATE_TYPE_PARM:
4546 case BOUND_TEMPLATE_TEMPLATE_PARM:
4551 gcc_assert (type == unknown_type_node);
4559 /* Adds everything associated with arguments. Returns true on error. */
4562 arg_assoc_args (struct arg_lookup *k, tree args)
4564 for (; args; args = TREE_CHAIN (args))
4565 if (arg_assoc (k, TREE_VALUE (args)))
4570 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4573 arg_assoc (struct arg_lookup *k, tree n)
4575 if (n == error_mark_node)
4579 return arg_assoc_type (k, n);
4581 if (! type_unknown_p (n))
4582 return arg_assoc_type (k, TREE_TYPE (n));
4584 if (TREE_CODE (n) == ADDR_EXPR)
4585 n = TREE_OPERAND (n, 0);
4586 if (TREE_CODE (n) == COMPONENT_REF)
4587 n = TREE_OPERAND (n, 1);
4588 if (TREE_CODE (n) == OFFSET_REF)
4589 n = TREE_OPERAND (n, 1);
4590 while (TREE_CODE (n) == TREE_LIST)
4592 if (TREE_CODE (n) == BASELINK)
4593 n = BASELINK_FUNCTIONS (n);
4595 if (TREE_CODE (n) == FUNCTION_DECL)
4596 return arg_assoc_type (k, TREE_TYPE (n));
4597 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4599 /* [basic.lookup.koenig]
4601 If T is a template-id, its associated namespaces and classes
4602 are the namespace in which the template is defined; for
4603 member templates, the member template's class... */
4604 tree template = TREE_OPERAND (n, 0);
4605 tree args = TREE_OPERAND (n, 1);
4609 if (TREE_CODE (template) == COMPONENT_REF)
4610 template = TREE_OPERAND (template, 1);
4612 /* First, the template. There may actually be more than one if
4613 this is an overloaded function template. But, in that case,
4614 we only need the first; all the functions will be in the same
4616 template = OVL_CURRENT (template);
4618 ctx = CP_DECL_CONTEXT (template);
4620 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4622 if (arg_assoc_namespace (k, ctx) == 1)
4625 /* It must be a member template. */
4626 else if (arg_assoc_class (k, ctx) == 1)
4629 /* Now the arguments. */
4631 for (ix = TREE_VEC_LENGTH (args); ix--;)
4632 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4635 else if (TREE_CODE (n) == OVERLOAD)
4637 for (; n; n = OVL_CHAIN (n))
4638 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4645 /* Performs Koenig lookup depending on arguments, where fns
4646 are the functions found in normal lookup. */
4649 lookup_arg_dependent (tree name, tree fns, tree args)
4651 struct arg_lookup k;
4653 timevar_push (TV_NAME_LOOKUP);
4655 /* Remove any hidden friend functions from the list of functions
4656 found so far. They will be added back by arg_assoc_class as
4658 fns = remove_hidden_names (fns);
4663 k.classes = NULL_TREE;
4665 /* We previously performed an optimization here by setting
4666 NAMESPACES to the current namespace when it was safe. However, DR
4667 164 says that namespaces that were already searched in the first
4668 stage of template processing are searched again (potentially
4669 picking up later definitions) in the second stage. */
4670 k.namespaces = NULL_TREE;
4672 arg_assoc_args (&k, args);
4673 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4676 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4677 changed (i.e. there was already a directive), or the fresh
4678 TREE_LIST otherwise. */
4681 push_using_directive (tree used)
4683 tree ud = current_binding_level->using_directives;
4684 tree iter, ancestor;
4686 timevar_push (TV_NAME_LOOKUP);
4687 /* Check if we already have this. */
4688 if (purpose_member (used, ud) != NULL_TREE)
4689 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4691 ancestor = namespace_ancestor (current_decl_namespace (), used);
4692 ud = current_binding_level->using_directives;
4693 ud = tree_cons (used, ancestor, ud);
4694 current_binding_level->using_directives = ud;
4696 /* Recursively add all namespaces used. */
4697 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4698 push_using_directive (TREE_PURPOSE (iter));
4700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4703 /* The type TYPE is being declared. If it is a class template, or a
4704 specialization of a class template, do any processing required and
4705 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4706 being declared a friend. B is the binding level at which this TYPE
4709 Returns the TYPE_DECL for TYPE, which may have been altered by this
4713 maybe_process_template_type_declaration (tree type, int is_friend,
4716 tree decl = TYPE_NAME (type);
4718 if (processing_template_parmlist)
4719 /* You can't declare a new template type in a template parameter
4720 list. But, you can declare a non-template type:
4722 template <class A*> struct S;
4724 is a forward-declaration of `A'. */
4726 else if (b->kind == sk_namespace
4727 && current_binding_level->kind != sk_namespace)
4728 /* If this new type is being injected into a containing scope,
4729 then it's not a template type. */
4733 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4735 if (processing_template_decl)
4737 /* This may change after the call to
4738 push_template_decl_real, but we want the original value. */
4739 tree name = DECL_NAME (decl);
4741 decl = push_template_decl_real (decl, is_friend);
4742 /* If the current binding level is the binding level for the
4743 template parameters (see the comment in
4744 begin_template_parm_list) and the enclosing level is a class
4745 scope, and we're not looking at a friend, push the
4746 declaration of the member class into the class scope. In the
4747 friend case, push_template_decl will already have put the
4748 friend into global scope, if appropriate. */
4749 if (TREE_CODE (type) != ENUMERAL_TYPE
4750 && !is_friend && b->kind == sk_template_parms
4751 && b->level_chain->kind == sk_class)
4753 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4755 if (!COMPLETE_TYPE_P (current_class_type))
4757 maybe_add_class_template_decl_list (current_class_type,
4758 type, /*friend_p=*/0);
4759 /* Put this UTD in the table of UTDs for the class. */
4760 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4761 CLASSTYPE_NESTED_UTDS (current_class_type) =
4762 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4764 binding_table_insert
4765 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4774 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4775 that the NAME is a class template, the tag is processed but not pushed.
4777 The pushed scope depend on the SCOPE parameter:
4778 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4780 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4781 non-template-parameter scope. This case is needed for forward
4783 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4784 TS_GLOBAL case except that names within template-parameter scopes
4785 are not pushed at all.
4787 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4790 pushtag (tree name, tree type, tag_scope scope)
4792 struct cp_binding_level *b;
4795 timevar_push (TV_NAME_LOOKUP);
4796 b = current_binding_level;
4797 while (/* Cleanup scopes are not scopes from the point of view of
4799 b->kind == sk_cleanup
4800 /* Neither are the scopes used to hold template parameters
4801 for an explicit specialization. For an ordinary template
4802 declaration, these scopes are not scopes from the point of
4803 view of the language. */
4804 || (b->kind == sk_template_parms
4805 && (b->explicit_spec_p || scope == ts_global))
4806 || (b->kind == sk_class
4807 && (scope != ts_current
4808 /* We may be defining a new type in the initializer
4809 of a static member variable. We allow this when
4810 not pedantic, and it is particularly useful for
4811 type punning via an anonymous union. */
4812 || COMPLETE_TYPE_P (b->this_entity))))
4815 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4817 /* Do C++ gratuitous typedefing. */
4818 if (IDENTIFIER_TYPE_VALUE (name) != type)
4822 tree context = TYPE_CONTEXT (type);
4826 tree cs = current_scope ();
4828 if (scope == ts_current)
4830 else if (cs != NULL_TREE && TYPE_P (cs))
4831 /* When declaring a friend class of a local class, we want
4832 to inject the newly named class into the scope
4833 containing the local class, not the namespace
4835 context = decl_function_context (get_type_decl (cs));
4838 context = current_namespace;
4840 if (b->kind == sk_class
4841 || (b->kind == sk_template_parms
4842 && b->level_chain->kind == sk_class))
4845 if (current_lang_name == lang_name_java)
4846 TYPE_FOR_JAVA (type) = 1;
4848 tdef = create_implicit_typedef (name, type);
4849 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4850 if (scope == ts_within_enclosing_non_class)
4852 /* This is a friend. Make this TYPE_DECL node hidden from
4853 ordinary name lookup. Its corresponding TEMPLATE_DECL
4854 will be marked in push_template_decl_real. */
4855 retrofit_lang_decl (tdef);
4856 DECL_ANTICIPATED (tdef) = 1;
4857 DECL_FRIEND_P (tdef) = 1;
4860 decl = maybe_process_template_type_declaration
4861 (type, scope == ts_within_enclosing_non_class, b);
4862 if (decl == error_mark_node)
4863 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4866 set_identifier_type_value_with_scope (name, tdef, b);
4868 if (b->kind == sk_class)
4870 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4871 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4872 class. But if it's a member template class, we want
4873 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4875 finish_member_declaration (decl);
4877 pushdecl_class_level (decl);
4879 else if (b->kind != sk_template_parms)
4881 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4882 if (decl == error_mark_node)
4883 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4886 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4888 /* If this is a local class, keep track of it. We need this
4889 information for name-mangling, and so that it is possible to
4890 find all function definitions in a translation unit in a
4891 convenient way. (It's otherwise tricky to find a member
4892 function definition it's only pointed to from within a local
4894 if (TYPE_CONTEXT (type)
4895 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4896 VEC_safe_push (tree, gc, local_classes, type);
4898 if (b->kind == sk_class
4899 && !COMPLETE_TYPE_P (current_class_type))
4901 maybe_add_class_template_decl_list (current_class_type,
4902 type, /*friend_p=*/0);
4904 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4905 CLASSTYPE_NESTED_UTDS (current_class_type)
4906 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4908 binding_table_insert
4909 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4912 decl = TYPE_NAME (type);
4913 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4914 TYPE_STUB_DECL (type) = decl;
4916 /* Set type visibility now if this is a forward declaration. */
4917 TREE_PUBLIC (decl) = 1;
4918 determine_visibility (decl);
4920 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4923 /* Subroutines for reverting temporarily to top-level for instantiation
4924 of templates and such. We actually need to clear out the class- and
4925 local-value slots of all identifiers, so that only the global values
4926 are at all visible. Simply setting current_binding_level to the global
4927 scope isn't enough, because more binding levels may be pushed. */
4928 struct saved_scope *scope_chain;
4930 /* If ID has not already been marked, add an appropriate binding to
4934 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4936 cxx_saved_binding *saved;
4938 if (!id || !IDENTIFIER_BINDING (id))
4941 if (IDENTIFIER_MARKED (id))
4944 IDENTIFIER_MARKED (id) = 1;
4946 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4947 saved->identifier = id;
4948 saved->binding = IDENTIFIER_BINDING (id);
4949 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4950 IDENTIFIER_BINDING (id) = NULL;
4954 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4958 timevar_push (TV_NAME_LOOKUP);
4959 for (t = names; t; t = TREE_CHAIN (t))
4963 if (TREE_CODE (t) == TREE_LIST)
4964 id = TREE_PURPOSE (t);
4968 store_binding (id, old_bindings);
4970 timevar_pop (TV_NAME_LOOKUP);
4973 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4974 objects, rather than a TREE_LIST. */
4977 store_class_bindings (VEC(cp_class_binding,gc) *names,
4978 VEC(cxx_saved_binding,gc) **old_bindings)
4981 cp_class_binding *cb;
4983 timevar_push (TV_NAME_LOOKUP);
4984 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4985 store_binding (cb->identifier, old_bindings);
4986 timevar_pop (TV_NAME_LOOKUP);
4990 push_to_top_level (void)
4992 struct saved_scope *s;
4993 struct cp_binding_level *b;
4994 cxx_saved_binding *sb;
4998 timevar_push (TV_NAME_LOOKUP);
4999 s = GGC_CNEW (struct saved_scope);
5001 b = scope_chain ? current_binding_level : 0;
5003 /* If we're in the middle of some function, save our state. */
5007 push_function_context_to (NULL_TREE);
5012 if (scope_chain && previous_class_level)
5013 store_class_bindings (previous_class_level->class_shadowed,
5016 /* Have to include the global scope, because class-scope decls
5017 aren't listed anywhere useful. */
5018 for (; b; b = b->level_chain)
5022 /* Template IDs are inserted into the global level. If they were
5023 inserted into namespace level, finish_file wouldn't find them
5024 when doing pending instantiations. Therefore, don't stop at
5025 namespace level, but continue until :: . */
5026 if (global_scope_p (b))
5029 store_bindings (b->names, &s->old_bindings);
5030 /* We also need to check class_shadowed to save class-level type
5031 bindings, since pushclass doesn't fill in b->names. */
5032 if (b->kind == sk_class)
5033 store_class_bindings (b->class_shadowed, &s->old_bindings);
5035 /* Unwind type-value slots back to top level. */
5036 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5037 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5040 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5041 IDENTIFIER_MARKED (sb->identifier) = 0;
5043 s->prev = scope_chain;
5045 s->need_pop_function_context = need_pop;
5046 s->function_decl = current_function_decl;
5047 s->skip_evaluation = skip_evaluation;
5050 current_function_decl = NULL_TREE;
5051 current_lang_base = VEC_alloc (tree, gc, 10);
5052 current_lang_name = lang_name_cplusplus;
5053 current_namespace = global_namespace;
5054 push_class_stack ();
5055 skip_evaluation = 0;
5056 timevar_pop (TV_NAME_LOOKUP);
5060 pop_from_top_level (void)
5062 struct saved_scope *s = scope_chain;
5063 cxx_saved_binding *saved;
5066 timevar_push (TV_NAME_LOOKUP);
5067 /* Clear out class-level bindings cache. */
5068 if (previous_class_level)
5069 invalidate_class_lookup_cache ();
5072 current_lang_base = 0;
5074 scope_chain = s->prev;
5075 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5077 tree id = saved->identifier;
5079 IDENTIFIER_BINDING (id) = saved->binding;
5080 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5083 /* If we were in the middle of compiling a function, restore our
5085 if (s->need_pop_function_context)
5086 pop_function_context_from (NULL_TREE);
5087 current_function_decl = s->function_decl;
5088 skip_evaluation = s->skip_evaluation;
5089 timevar_pop (TV_NAME_LOOKUP);
5092 /* Pop off extraneous binding levels left over due to syntax errors.
5094 We don't pop past namespaces, as they might be valid. */
5097 pop_everything (void)
5099 if (ENABLE_SCOPE_CHECKING)
5100 verbatim ("XXX entering pop_everything ()\n");
5101 while (!toplevel_bindings_p ())
5103 if (current_binding_level->kind == sk_class)
5104 pop_nested_class ();
5108 if (ENABLE_SCOPE_CHECKING)
5109 verbatim ("XXX leaving pop_everything ()\n");
5112 /* Emit debugging information for using declarations and directives.
5113 If input tree is overloaded fn then emit debug info for all
5117 cp_emit_debug_info_for_using (tree t, tree context)
5119 /* Don't try to emit any debug information if we have errors. */
5120 if (sorrycount || errorcount)
5123 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5124 of a builtin function. */
5125 if (TREE_CODE (t) == FUNCTION_DECL
5126 && DECL_EXTERNAL (t)
5127 && DECL_BUILT_IN (t))
5130 /* Do not supply context to imported_module_or_decl, if
5131 it is a global namespace. */
5132 if (context == global_namespace)
5133 context = NULL_TREE;
5136 t = BASELINK_FUNCTIONS (t);
5138 /* FIXME: Handle TEMPLATE_DECLs. */
5139 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5140 if (TREE_CODE (t) != TEMPLATE_DECL)
5141 (*debug_hooks->imported_module_or_decl) (t, context);
5144 #include "gt-cp-name-lookup.h"