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 cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree lookup_name_innermost_nonclass_level (tree);
47 static tree push_overloaded_decl (tree, int, bool);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
64 /* Compute the chain index of a binding_entry given the HASH value of its
65 name and the total COUNT of chains. COUNT is assumed to be a power
68 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
70 /* A free list of "binding_entry"s awaiting for re-use. */
72 static GTY((deletable)) binding_entry free_binding_entry = NULL;
74 /* Create a binding_entry object for (NAME, TYPE). */
76 static inline binding_entry
77 binding_entry_make (tree name, tree type)
81 if (free_binding_entry)
83 entry = free_binding_entry;
84 free_binding_entry = entry->chain;
87 entry = GGC_NEW (struct binding_entry_s);
96 /* Put ENTRY back on the free list. */
99 binding_entry_free (binding_entry entry)
103 entry->chain = free_binding_entry;
104 free_binding_entry = entry;
108 /* The datatype used to implement the mapping from names to types at
110 struct binding_table_s GTY(())
112 /* Array of chains of "binding_entry"s */
113 binding_entry * GTY((length ("%h.chain_count"))) chain;
115 /* The number of chains in this table. This is the length of the
116 the member "chain" considered as an array. */
119 /* Number of "binding_entry"s in this table. */
123 /* Construct TABLE with an initial CHAIN_COUNT. */
126 binding_table_construct (binding_table table, size_t chain_count)
128 table->chain_count = chain_count;
129 table->entry_count = 0;
130 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
133 /* Make TABLE's entries ready for reuse. */
136 binding_table_free (binding_table table)
144 for (i = 0, count = table->chain_count; i < count; ++i)
146 binding_entry temp = table->chain[i];
149 binding_entry entry = temp;
151 binding_entry_free (entry);
153 table->chain[i] = NULL;
155 table->entry_count = 0;
159 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
161 static inline binding_table
162 binding_table_new (size_t chain_count)
164 binding_table table = GGC_NEW (struct binding_table_s);
166 binding_table_construct (table, chain_count);
170 /* Expand TABLE to twice its current chain_count. */
173 binding_table_expand (binding_table table)
175 const size_t old_chain_count = table->chain_count;
176 const size_t old_entry_count = table->entry_count;
177 const size_t new_chain_count = 2 * old_chain_count;
178 binding_entry *old_chains = table->chain;
181 binding_table_construct (table, new_chain_count);
182 for (i = 0; i < old_chain_count; ++i)
184 binding_entry entry = old_chains[i];
185 for (; entry != NULL; entry = old_chains[i])
187 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
188 const size_t j = ENTRY_INDEX (hash, new_chain_count);
190 old_chains[i] = entry->chain;
191 entry->chain = table->chain[j];
192 table->chain[j] = entry;
195 table->entry_count = old_entry_count;
198 /* Insert a binding for NAME to TYPE into TABLE. */
201 binding_table_insert (binding_table table, tree name, tree type)
203 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
204 const size_t i = ENTRY_INDEX (hash, table->chain_count);
205 binding_entry entry = binding_entry_make (name, type);
207 entry->chain = table->chain[i];
208 table->chain[i] = entry;
209 ++table->entry_count;
211 if (3 * table->chain_count < 5 * table->entry_count)
212 binding_table_expand (table);
215 /* Return the binding_entry, if any, that maps NAME. */
218 binding_table_find (binding_table table, tree name)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
223 while (entry != NULL && entry->name != name)
224 entry = entry->chain;
229 /* Apply PROC -- with DATA -- to all entries in TABLE. */
232 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
234 const size_t chain_count = table->chain_count;
237 for (i = 0; i < chain_count; ++i)
239 binding_entry entry = table->chain[i];
240 for (; entry != NULL; entry = entry->chain)
245 #ifndef ENABLE_SCOPE_CHECKING
246 # define ENABLE_SCOPE_CHECKING 0
248 # define ENABLE_SCOPE_CHECKING 1
251 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
253 static GTY((deletable)) cxx_binding *free_bindings;
255 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
259 cxx_binding_init (cxx_binding *binding, tree value, tree type)
261 binding->value = value;
262 binding->type = type;
263 binding->previous = NULL;
266 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
269 cxx_binding_make (tree value, tree type)
271 cxx_binding *binding;
274 binding = free_bindings;
275 free_bindings = binding->previous;
278 binding = GGC_NEW (cxx_binding);
280 cxx_binding_init (binding, value, type);
285 /* Put BINDING back on the free list. */
288 cxx_binding_free (cxx_binding *binding)
290 binding->scope = NULL;
291 binding->previous = free_bindings;
292 free_bindings = binding;
295 /* Create a new binding for NAME (with the indicated VALUE and TYPE
296 bindings) in the class scope indicated by SCOPE. */
299 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
301 cp_class_binding *cb;
302 cxx_binding *binding;
304 if (VEC_length (cp_class_binding, scope->class_shadowed))
306 cp_class_binding *old_base;
307 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
308 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
310 /* Fixup the current bindings, as they might have moved. */
314 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
318 b = &IDENTIFIER_BINDING (cb->identifier);
319 while (*b != &old_base[i].base)
320 b = &((*b)->previous);
324 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
327 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
329 cb->identifier = name;
331 binding->scope = scope;
332 cxx_binding_init (binding, value, type);
336 /* Make DECL the innermost binding for ID. The LEVEL is the binding
337 level at which this declaration is being bound. */
340 push_binding (tree id, tree decl, cxx_scope* level)
342 cxx_binding *binding;
344 if (level != class_binding_level)
346 binding = cxx_binding_make (decl, NULL_TREE);
347 binding->scope = level;
350 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
352 /* Now, fill in the binding information. */
353 binding->previous = IDENTIFIER_BINDING (id);
354 INHERITED_VALUE_BINDING_P (binding) = 0;
355 LOCAL_BINDING_P (binding) = (level != class_binding_level);
357 /* And put it on the front of the list of bindings for ID. */
358 IDENTIFIER_BINDING (id) = binding;
361 /* Remove the binding for DECL which should be the innermost binding
365 pop_binding (tree id, tree decl)
367 cxx_binding *binding;
370 /* It's easiest to write the loops that call this function without
371 checking whether or not the entities involved have names. We
372 get here for such an entity. */
375 /* Get the innermost binding for ID. */
376 binding = IDENTIFIER_BINDING (id);
378 /* The name should be bound. */
379 gcc_assert (binding != NULL);
381 /* The DECL will be either the ordinary binding or the type
382 binding for this identifier. Remove that binding. */
383 if (binding->value == decl)
384 binding->value = NULL_TREE;
387 gcc_assert (binding->type == decl);
388 binding->type = NULL_TREE;
391 if (!binding->value && !binding->type)
393 /* We're completely done with the innermost binding for this
394 identifier. Unhook it from the list of bindings. */
395 IDENTIFIER_BINDING (id) = binding->previous;
397 /* Add it to the free list. */
398 cxx_binding_free (binding);
402 /* BINDING records an existing declaration for a name in the current scope.
403 But, DECL is another declaration for that same identifier in the
404 same scope. This is the `struct stat' hack whereby a non-typedef
405 class name or enum-name can be bound at the same level as some other
409 A class name (9.1) or enumeration name (7.2) can be hidden by the
410 name of an object, function, or enumerator declared in the same scope.
411 If a class or enumeration name and an object, function, or enumerator
412 are declared in the same scope (in any order) with the same name, the
413 class or enumeration name is hidden wherever the object, function, or
414 enumerator name is visible.
416 It's the responsibility of the caller to check that
417 inserting this name is valid here. Returns nonzero if the new binding
421 supplement_binding (cxx_binding *binding, tree decl)
423 tree bval = binding->value;
426 timevar_push (TV_NAME_LOOKUP);
427 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
428 /* The new name is the type name. */
429 binding->type = decl;
430 else if (/* BVAL is null when push_class_level_binding moves an
431 inherited type-binding out of the way to make room for a
432 new value binding. */
434 /* BVAL is error_mark_node when DECL's name has been used
435 in a non-class scope prior declaration. In that case,
436 we should have already issued a diagnostic; for graceful
437 error recovery purpose, pretend this was the intended
438 declaration for that name. */
439 || bval == error_mark_node
440 /* If BVAL is anticipated but has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval)
444 && !DECL_HIDDEN_FRIEND_P (bval)))
445 binding->value = decl;
446 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
448 /* The old binding was a type name. It was placed in
449 VALUE field because it was thought, at the point it was
450 declared, to be the only entity with such a name. Move the
451 type name into the type slot; it is now hidden by the new
453 binding->type = bval;
454 binding->value = decl;
455 binding->value_is_inherited = false;
457 else if (TREE_CODE (bval) == TYPE_DECL
458 && TREE_CODE (decl) == TYPE_DECL
459 && DECL_NAME (decl) == DECL_NAME (bval)
460 && binding->scope->kind != sk_class
461 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
462 /* If either type involves template parameters, we must
463 wait until instantiation. */
464 || uses_template_parms (TREE_TYPE (decl))
465 || uses_template_parms (TREE_TYPE (bval))))
466 /* We have two typedef-names, both naming the same type to have
467 the same name. In general, this is OK because of:
471 In a given scope, a typedef specifier can be used to redefine
472 the name of any type declared in that scope to refer to the
473 type to which it already refers.
475 However, in class scopes, this rule does not apply due to the
476 stricter language in [class.mem] prohibiting redeclarations of
479 /* There can be two block-scope declarations of the same variable,
480 so long as they are `extern' declarations. However, there cannot
481 be two declarations of the same static data member:
485 A member shall not be declared twice in the
486 member-specification. */
487 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
488 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
489 && !DECL_CLASS_SCOPE_P (decl))
491 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
494 else if (TREE_CODE (decl) == NAMESPACE_DECL
495 && TREE_CODE (bval) == NAMESPACE_DECL
496 && DECL_NAMESPACE_ALIAS (decl)
497 && DECL_NAMESPACE_ALIAS (bval)
498 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
501 In a declarative region, a namespace-alias-definition can be
502 used to redefine a namespace-alias declared in that declarative
503 region to refer only to the namespace to which it already
508 error ("declaration of %q#D", decl);
509 error ("conflicts with previous declaration %q+#D", bval);
513 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
516 /* Add DECL to the list of things declared in B. */
519 add_decl_to_level (tree decl, cxx_scope *b)
521 if (TREE_CODE (decl) == NAMESPACE_DECL
522 && !DECL_NAMESPACE_ALIAS (decl))
524 TREE_CHAIN (decl) = b->namespaces;
525 b->namespaces = decl;
527 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
529 TREE_CHAIN (decl) = b->vtables;
534 /* We build up the list in reverse order, and reverse it later if
536 TREE_CHAIN (decl) = b->names;
540 /* If appropriate, add decl to separate list of statics. We
541 include extern variables because they might turn out to be
542 static later. It's OK for this list to contain a few false
544 if (b->kind == sk_namespace)
545 if ((TREE_CODE (decl) == VAR_DECL
546 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
547 || (TREE_CODE (decl) == FUNCTION_DECL
548 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
549 VEC_safe_push (tree, gc, b->static_decls, decl);
553 /* Record a decl-node X as belonging to the current lexical scope.
554 Check for errors (such as an incompatible declaration for the same
555 name already seen in the same scope). IS_FRIEND is true if X is
556 declared as a friend.
558 Returns either X or an old decl for the same name.
559 If an old decl is returned, it may have been smashed
560 to agree with what X says. */
563 pushdecl_maybe_friend (tree x, bool is_friend)
567 int need_new_binding;
569 timevar_push (TV_NAME_LOOKUP);
571 if (x == error_mark_node)
572 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
574 need_new_binding = 1;
576 if (DECL_TEMPLATE_PARM_P (x))
577 /* Template parameters have no context; they are not X::T even
578 when declared within a class or namespace. */
582 if (current_function_decl && x != current_function_decl
583 /* A local declaration for a function doesn't constitute
585 && TREE_CODE (x) != FUNCTION_DECL
586 /* A local declaration for an `extern' variable is in the
587 scope of the current namespace, not the current
589 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
590 && !DECL_CONTEXT (x))
591 DECL_CONTEXT (x) = current_function_decl;
593 /* If this is the declaration for a namespace-scope function,
594 but the declaration itself is in a local scope, mark the
596 if (TREE_CODE (x) == FUNCTION_DECL
597 && DECL_NAMESPACE_SCOPE_P (x)
598 && current_function_decl
599 && x != current_function_decl)
600 DECL_LOCAL_FUNCTION_P (x) = 1;
603 name = DECL_NAME (x);
606 int different_binding_level = 0;
608 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
609 name = TREE_OPERAND (name, 0);
611 /* In case this decl was explicitly namespace-qualified, look it
612 up in its namespace context. */
613 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
614 t = namespace_binding (name, DECL_CONTEXT (x));
616 t = lookup_name_innermost_nonclass_level (name);
618 /* [basic.link] If there is a visible declaration of an entity
619 with linkage having the same name and type, ignoring entities
620 declared outside the innermost enclosing namespace scope, the
621 block scope declaration declares that same entity and
622 receives the linkage of the previous declaration. */
623 if (! t && current_function_decl && x != current_function_decl
624 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
625 && DECL_EXTERNAL (x))
627 /* Look in block scope. */
628 t = innermost_non_namespace_value (name);
629 /* Or in the innermost namespace. */
631 t = namespace_binding (name, DECL_CONTEXT (x));
632 /* Does it have linkage? Note that if this isn't a DECL, it's an
633 OVERLOAD, which is OK. */
634 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
637 different_binding_level = 1;
640 /* If we are declaring a function, and the result of name-lookup
641 was an OVERLOAD, look for an overloaded instance that is
642 actually the same as the function we are declaring. (If
643 there is one, we have to merge our declaration with the
644 previous declaration.) */
645 if (t && TREE_CODE (t) == OVERLOAD)
649 if (TREE_CODE (x) == FUNCTION_DECL)
650 for (match = t; match; match = OVL_NEXT (match))
652 if (decls_match (OVL_CURRENT (match), x))
656 /* Just choose one. */
660 t = OVL_CURRENT (match);
665 if (t && t != error_mark_node)
667 if (different_binding_level)
669 if (decls_match (x, t))
670 /* The standard only says that the local extern
671 inherits linkage from the previous decl; in
672 particular, default args are not shared. Add
673 the decl into a hash table to make sure only
674 the previous decl in this case is seen by the
677 struct cxx_int_tree_map *h;
680 TREE_PUBLIC (x) = TREE_PUBLIC (t);
682 if (cp_function_chain->extern_decl_map == NULL)
683 cp_function_chain->extern_decl_map
684 = htab_create_ggc (20, cxx_int_tree_map_hash,
685 cxx_int_tree_map_eq, NULL);
687 h = GGC_NEW (struct cxx_int_tree_map);
688 h->uid = DECL_UID (x);
690 loc = htab_find_slot_with_hash
691 (cp_function_chain->extern_decl_map, h,
693 *(struct cxx_int_tree_map **) loc = h;
696 else if (TREE_CODE (t) == PARM_DECL)
698 gcc_assert (DECL_CONTEXT (t));
700 /* Check for duplicate params. */
701 if (duplicate_decls (x, t, is_friend))
702 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
704 else if ((DECL_EXTERN_C_FUNCTION_P (x)
705 || DECL_FUNCTION_TEMPLATE_P (x))
706 && is_overloaded_fn (t))
707 /* Don't do anything just yet. */;
708 else if (t == wchar_decl_node)
710 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
711 pedwarn ("redeclaration of %<wchar_t%> as %qT",
714 /* Throw away the redeclaration. */
715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
719 tree olddecl = duplicate_decls (x, t, is_friend);
721 /* If the redeclaration failed, we can stop at this
723 if (olddecl == error_mark_node)
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
728 if (TREE_CODE (t) == TYPE_DECL)
729 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
733 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
735 /* A redeclaration of main, but not a duplicate of the
740 This function shall not be overloaded. */
741 error ("invalid redeclaration of %q+D", t);
743 /* We don't try to push this declaration since that
745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
750 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
751 check_default_args (x);
753 check_template_shadow (x);
755 /* If this is a function conjured up by the backend, massage it
756 so it looks friendly. */
757 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
759 retrofit_lang_decl (x);
760 SET_DECL_LANGUAGE (x, lang_c);
763 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
765 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
768 if (!namespace_bindings_p ())
769 /* We do not need to create a binding for this name;
770 push_overloaded_decl will have already done so if
772 need_new_binding = 0;
774 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
776 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
778 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
782 /* If declaring a type as a typedef, copy the type (unless we're
783 at line 0), and install this TYPE_DECL as the new type's typedef
784 name. See the extensive comment in ../c-decl.c (pushdecl). */
785 if (TREE_CODE (x) == TYPE_DECL)
787 tree type = TREE_TYPE (x);
788 if (DECL_IS_BUILTIN (x))
790 if (TYPE_NAME (type) == 0)
791 TYPE_NAME (type) = x;
793 else if (type != error_mark_node && TYPE_NAME (type) != x
794 /* We don't want to copy the type when all we're
795 doing is making a TYPE_DECL for the purposes of
797 && (!TYPE_NAME (type)
798 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
800 DECL_ORIGINAL_TYPE (x) = type;
801 type = build_variant_type_copy (type);
802 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
803 TYPE_NAME (type) = x;
804 TREE_TYPE (x) = type;
807 if (type != error_mark_node
809 && TYPE_IDENTIFIER (type))
810 set_identifier_type_value (DECL_NAME (x), x);
813 /* Multiple external decls of the same identifier ought to match.
815 We get warnings about inline functions where they are defined.
816 We get warnings about other functions from push_overloaded_decl.
818 Avoid duplicate warnings where they are used. */
819 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
823 decl = IDENTIFIER_NAMESPACE_VALUE (name);
824 if (decl && TREE_CODE (decl) == OVERLOAD)
825 decl = OVL_FUNCTION (decl);
827 if (decl && decl != error_mark_node
828 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
829 /* If different sort of thing, we already gave an error. */
830 && TREE_CODE (decl) == TREE_CODE (x)
831 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
833 pedwarn ("type mismatch with previous external decl of %q#D", x);
834 pedwarn ("previous external decl of %q+#D", decl);
838 if (TREE_CODE (x) == FUNCTION_DECL
840 && !flag_friend_injection)
842 /* This is a new declaration of a friend function, so hide
843 it from ordinary function lookup. */
844 DECL_ANTICIPATED (x) = 1;
845 DECL_HIDDEN_FRIEND_P (x) = 1;
848 /* This name is new in its binding level.
849 Install the new declaration and return it. */
850 if (namespace_bindings_p ())
852 /* Install a global value. */
854 /* If the first global decl has external linkage,
855 warn if we later see static one. */
856 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
857 TREE_PUBLIC (name) = 1;
859 /* Bind the name for the entity. */
860 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
862 && (TREE_CODE (x) == TYPE_DECL
863 || TREE_CODE (x) == VAR_DECL
864 || TREE_CODE (x) == NAMESPACE_DECL
865 || TREE_CODE (x) == CONST_DECL
866 || TREE_CODE (x) == TEMPLATE_DECL))
867 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
869 /* If new decl is `static' and an `extern' was seen previously,
871 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
872 warn_extern_redeclared_static (x, t);
876 /* Here to install a non-global value. */
877 tree oldlocal = innermost_non_namespace_value (name);
878 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
880 if (need_new_binding)
882 push_local_binding (name, x, 0);
883 /* Because push_local_binding will hook X on to the
884 current_binding_level's name list, we don't want to
885 do that again below. */
886 need_new_binding = 0;
889 /* If this is a TYPE_DECL, push it into the type value slot. */
890 if (TREE_CODE (x) == TYPE_DECL)
891 set_identifier_type_value (name, x);
893 /* Clear out any TYPE_DECL shadowed by a namespace so that
894 we won't think this is a type. The C struct hack doesn't
895 go through namespaces. */
896 if (TREE_CODE (x) == NAMESPACE_DECL)
897 set_identifier_type_value (name, NULL_TREE);
904 && TREE_CODE (oldlocal) == VAR_DECL
905 && DECL_DEAD_FOR_LOCAL (oldlocal))
906 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
908 if (oldlocal == NULL_TREE)
909 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
912 /* If this is an extern function declaration, see if we
913 have a global definition or declaration for the function. */
914 if (oldlocal == NULL_TREE
916 && oldglobal != NULL_TREE
917 && TREE_CODE (x) == FUNCTION_DECL
918 && TREE_CODE (oldglobal) == FUNCTION_DECL)
920 /* We have one. Their types must agree. */
921 if (decls_match (x, oldglobal))
925 warning (0, "extern declaration of %q#D doesn't match", x);
926 warning (0, "global declaration %q+#D", oldglobal);
929 /* If we have a local external declaration,
930 and no file-scope declaration has yet been seen,
931 then if we later have a file-scope decl it must not be static. */
932 if (oldlocal == NULL_TREE
933 && oldglobal == NULL_TREE
936 TREE_PUBLIC (name) = 1;
938 /* Warn if shadowing an argument at the top level of the body. */
939 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
940 /* Inline decls shadow nothing. */
941 && !DECL_FROM_INLINE (x)
942 && TREE_CODE (oldlocal) == PARM_DECL
943 /* Don't check the `this' parameter. */
944 && !DECL_ARTIFICIAL (oldlocal))
948 /* Don't complain if it's from an enclosing function. */
949 if (DECL_CONTEXT (oldlocal) == current_function_decl
950 && TREE_CODE (x) != PARM_DECL)
952 /* Go to where the parms should be and see if we find
954 struct cp_binding_level *b = current_binding_level->level_chain;
956 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
957 /* Skip the ctor/dtor cleanup level. */
961 if (b->kind == sk_function_parms)
963 error ("declaration of %q#D shadows a parameter", x);
968 if (warn_shadow && !err)
970 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
971 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
975 /* Maybe warn if shadowing something else. */
976 else if (warn_shadow && !DECL_EXTERNAL (x)
977 /* No shadow warnings for internally generated vars. */
978 && ! DECL_ARTIFICIAL (x)
979 /* No shadow warnings for vars made for inlining. */
980 && ! DECL_FROM_INLINE (x))
984 if (current_class_ptr)
985 member = lookup_member (current_class_type,
988 /*want_type=*/false);
992 if (member && !TREE_STATIC (member))
994 /* Location of previous decl is not useful in this case. */
995 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
998 else if (oldlocal != NULL_TREE
999 && TREE_CODE (oldlocal) == VAR_DECL)
1001 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1002 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1004 else if (oldglobal != NULL_TREE
1005 && TREE_CODE (oldglobal) == VAR_DECL)
1006 /* XXX shadow warnings in outer-more namespaces */
1008 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1010 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1015 if (TREE_CODE (x) == VAR_DECL)
1016 maybe_register_incomplete_var (x);
1019 if (need_new_binding)
1020 add_decl_to_level (x,
1021 DECL_NAMESPACE_SCOPE_P (x)
1022 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1023 : current_binding_level);
1025 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1028 /* Record a decl-node X as belonging to the current lexical scope. */
1033 return pushdecl_maybe_friend (x, false);
1036 /* Enter DECL into the symbol table, if that's appropriate. Returns
1037 DECL, or a modified version thereof. */
1040 maybe_push_decl (tree decl)
1042 tree type = TREE_TYPE (decl);
1044 /* Add this decl to the current binding level, but not if it comes
1045 from another scope, e.g. a static member variable. TEM may equal
1046 DECL or it may be a previous decl of the same name. */
1047 if (decl == error_mark_node
1048 || (TREE_CODE (decl) != PARM_DECL
1049 && DECL_CONTEXT (decl) != NULL_TREE
1050 /* Definitions of namespace members outside their namespace are
1052 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1053 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1054 || TREE_CODE (type) == UNKNOWN_TYPE
1055 /* The declaration of a template specialization does not affect
1056 the functions available for overload resolution, so we do not
1058 || (TREE_CODE (decl) == FUNCTION_DECL
1059 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1062 return pushdecl (decl);
1065 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1066 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1067 doesn't really belong to this binding level, that it got here
1068 through a using-declaration. */
1071 push_local_binding (tree id, tree decl, int flags)
1073 struct cp_binding_level *b;
1075 /* Skip over any local classes. This makes sense if we call
1076 push_local_binding with a friend decl of a local class. */
1077 b = innermost_nonclass_level ();
1079 if (lookup_name_innermost_nonclass_level (id))
1081 /* Supplement the existing binding. */
1082 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1083 /* It didn't work. Something else must be bound at this
1084 level. Do not add DECL to the list of things to pop
1089 /* Create a new binding. */
1090 push_binding (id, decl, b);
1092 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1093 /* We must put the OVERLOAD into a TREE_LIST since the
1094 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1095 decls that got here through a using-declaration. */
1096 decl = build_tree_list (NULL_TREE, decl);
1098 /* And put DECL on the list of things declared by the current
1100 add_decl_to_level (decl, b);
1103 /* Check to see whether or not DECL is a variable that would have been
1104 in scope under the ARM, but is not in scope under the ANSI/ISO
1105 standard. If so, issue an error message. If name lookup would
1106 work in both cases, but return a different result, this function
1107 returns the result of ANSI/ISO lookup. Otherwise, it returns
1111 check_for_out_of_scope_variable (tree decl)
1115 /* We only care about out of scope variables. */
1116 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1119 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1120 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1121 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1122 && DECL_DEAD_FOR_LOCAL (shadowed))
1123 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1124 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1126 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1129 if (!DECL_ERROR_REPORTED (decl))
1131 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1132 warning (0, " matches this %q+D under ISO standard rules",
1134 warning (0, " matches this %q+D under old rules", decl);
1135 DECL_ERROR_REPORTED (decl) = 1;
1140 /* If we have already complained about this declaration, there's no
1141 need to do it again. */
1142 if (DECL_ERROR_REPORTED (decl))
1145 DECL_ERROR_REPORTED (decl) = 1;
1147 if (TREE_TYPE (decl) == error_mark_node)
1150 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1152 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1154 error (" cannot use obsolete binding at %q+D because "
1155 "it has a destructor", decl);
1156 return error_mark_node;
1160 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1162 pedwarn (" using obsolete binding at %q+D", decl);
1168 /* true means unconditionally make a BLOCK for the next level pushed. */
1170 static bool keep_next_level_flag;
1172 static int binding_depth = 0;
1173 static int is_class_level = 0;
1180 for (i = 0; i < depth * 2; i++)
1184 /* Return a string describing the kind of SCOPE we have. */
1186 cxx_scope_descriptor (cxx_scope *scope)
1188 /* The order of this table must match the "scope_kind"
1190 static const char* scope_kind_names[] = {
1196 "function-parameter-scope",
1199 "template-parameter-scope",
1200 "template-explicit-spec-scope"
1202 const scope_kind kind = scope->explicit_spec_p
1203 ? sk_template_spec : scope->kind;
1205 return scope_kind_names[kind];
1208 /* Output a debugging information about SCOPE when performing
1211 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1213 const char *desc = cxx_scope_descriptor (scope);
1214 if (scope->this_entity)
1215 verbatim ("%s %s(%E) %p %d\n", action, desc,
1216 scope->this_entity, (void *) scope, line);
1218 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1221 /* Return the estimated initial size of the hashtable of a NAMESPACE
1224 static inline size_t
1225 namespace_scope_ht_size (tree ns)
1227 tree name = DECL_NAME (ns);
1229 return name == std_identifier
1230 ? NAMESPACE_STD_HT_SIZE
1231 : (name == global_scope_name
1232 ? GLOBAL_SCOPE_HT_SIZE
1233 : NAMESPACE_ORDINARY_HT_SIZE);
1236 /* A chain of binding_level structures awaiting reuse. */
1238 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1240 /* Insert SCOPE as the innermost binding level. */
1243 push_binding_level (struct cp_binding_level *scope)
1245 /* Add it to the front of currently active scopes stack. */
1246 scope->level_chain = current_binding_level;
1247 current_binding_level = scope;
1248 keep_next_level_flag = false;
1250 if (ENABLE_SCOPE_CHECKING)
1252 scope->binding_depth = binding_depth;
1253 indent (binding_depth);
1254 cxx_scope_debug (scope, input_line, "push");
1260 /* Create a new KIND scope and make it the top of the active scopes stack.
1261 ENTITY is the scope of the associated C++ entity (namespace, class,
1262 function); it is NULL otherwise. */
1265 begin_scope (scope_kind kind, tree entity)
1269 /* Reuse or create a struct for this binding level. */
1270 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1272 scope = free_binding_level;
1273 free_binding_level = scope->level_chain;
1276 scope = GGC_NEW (cxx_scope);
1277 memset (scope, 0, sizeof (cxx_scope));
1279 scope->this_entity = entity;
1280 scope->more_cleanups_ok = true;
1287 case sk_template_spec:
1288 scope->explicit_spec_p = true;
1289 kind = sk_template_parms;
1291 case sk_template_parms:
1297 case sk_function_parms:
1299 scope->keep = keep_next_level_flag;
1303 NAMESPACE_LEVEL (entity) = scope;
1304 scope->static_decls =
1305 VEC_alloc (tree, gc,
1306 DECL_NAME (entity) == std_identifier
1307 || DECL_NAME (entity) == global_scope_name
1312 /* Should not happen. */
1318 push_binding_level (scope);
1323 /* We're about to leave current scope. Pop the top of the stack of
1324 currently active scopes. Return the enclosing scope, now active. */
1329 cxx_scope *scope = current_binding_level;
1331 if (scope->kind == sk_namespace && class_binding_level)
1332 current_binding_level = class_binding_level;
1334 /* We cannot leave a scope, if there are none left. */
1335 if (NAMESPACE_LEVEL (global_namespace))
1336 gcc_assert (!global_scope_p (scope));
1338 if (ENABLE_SCOPE_CHECKING)
1340 indent (--binding_depth);
1341 cxx_scope_debug (scope, input_line, "leave");
1342 if (is_class_level != (scope == class_binding_level))
1344 indent (binding_depth);
1345 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1350 #ifdef HANDLE_PRAGMA_VISIBILITY
1351 if (scope->has_visibility)
1355 /* Move one nesting level up. */
1356 current_binding_level = scope->level_chain;
1358 /* Namespace-scopes are left most probably temporarily, not
1359 completely; they can be reopened later, e.g. in namespace-extension
1360 or any name binding activity that requires us to resume a
1361 namespace. For classes, we cache some binding levels. For other
1362 scopes, we just make the structure available for reuse. */
1363 if (scope->kind != sk_namespace
1364 && scope->kind != sk_class)
1366 scope->level_chain = free_binding_level;
1367 gcc_assert (!ENABLE_SCOPE_CHECKING
1368 || scope->binding_depth == binding_depth);
1369 free_binding_level = scope;
1372 /* Find the innermost enclosing class scope, and reset
1373 CLASS_BINDING_LEVEL appropriately. */
1374 if (scope->kind == sk_class)
1376 class_binding_level = NULL;
1377 for (scope = current_binding_level; scope; scope = scope->level_chain)
1378 if (scope->kind == sk_class)
1380 class_binding_level = scope;
1385 return current_binding_level;
1389 resume_scope (struct cp_binding_level* b)
1391 /* Resuming binding levels is meant only for namespaces,
1392 and those cannot nest into classes. */
1393 gcc_assert (!class_binding_level);
1394 /* Also, resuming a non-directly nested namespace is a no-no. */
1395 gcc_assert (b->level_chain == current_binding_level);
1396 current_binding_level = b;
1397 if (ENABLE_SCOPE_CHECKING)
1399 b->binding_depth = binding_depth;
1400 indent (binding_depth);
1401 cxx_scope_debug (b, input_line, "resume");
1407 /* Return the innermost binding level that is not for a class scope. */
1410 innermost_nonclass_level (void)
1414 b = current_binding_level;
1415 while (b->kind == sk_class)
1421 /* We're defining an object of type TYPE. If it needs a cleanup, but
1422 we're not allowed to add any more objects with cleanups to the current
1423 scope, create a new binding level. */
1426 maybe_push_cleanup_level (tree type)
1428 if (type != error_mark_node
1429 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1430 && current_binding_level->more_cleanups_ok == 0)
1432 begin_scope (sk_cleanup, NULL);
1433 current_binding_level->statement_list = push_stmt_list ();
1437 /* Nonzero if we are currently in the global binding level. */
1440 global_bindings_p (void)
1442 return global_scope_p (current_binding_level);
1445 /* True if we are currently in a toplevel binding level. This
1446 means either the global binding level or a namespace in a toplevel
1447 binding level. Since there are no non-toplevel namespace levels,
1448 this really means any namespace or template parameter level. We
1449 also include a class whose context is toplevel. */
1452 toplevel_bindings_p (void)
1454 struct cp_binding_level *b = innermost_nonclass_level ();
1456 return b->kind == sk_namespace || b->kind == sk_template_parms;
1459 /* True if this is a namespace scope, or if we are defining a class
1460 which is itself at namespace scope, or whose enclosing class is
1461 such a class, etc. */
1464 namespace_bindings_p (void)
1466 struct cp_binding_level *b = innermost_nonclass_level ();
1468 return b->kind == sk_namespace;
1471 /* True if the current level needs to have a BLOCK made. */
1476 return (current_binding_level->blocks != NULL_TREE
1477 || current_binding_level->keep
1478 || current_binding_level->kind == sk_cleanup
1479 || current_binding_level->names != NULL_TREE);
1482 /* Returns the kind of the innermost scope. */
1485 innermost_scope_kind (void)
1487 return current_binding_level->kind;
1490 /* Returns true if this scope was created to store template parameters. */
1493 template_parm_scope_p (void)
1495 return innermost_scope_kind () == sk_template_parms;
1498 /* If KEEP is true, make a BLOCK node for the next binding level,
1499 unconditionally. Otherwise, use the normal logic to decide whether
1500 or not to create a BLOCK. */
1503 keep_next_level (bool keep)
1505 keep_next_level_flag = keep;
1508 /* Return the list of declarations of the current level.
1509 Note that this list is in reverse order unless/until
1510 you nreverse it; and when you do nreverse it, you must
1511 store the result back using `storedecls' or you will lose. */
1516 return current_binding_level->names;
1519 /* For debugging. */
1520 static int no_print_functions = 0;
1521 static int no_print_builtins = 0;
1524 print_binding_level (struct cp_binding_level* lvl)
1528 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1529 if (lvl->more_cleanups_ok)
1530 fprintf (stderr, " more-cleanups-ok");
1531 if (lvl->have_cleanups)
1532 fprintf (stderr, " have-cleanups");
1533 fprintf (stderr, "\n");
1536 fprintf (stderr, " names:\t");
1537 /* We can probably fit 3 names to a line? */
1538 for (t = lvl->names; t; t = TREE_CHAIN (t))
1540 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1542 if (no_print_builtins
1543 && (TREE_CODE (t) == TYPE_DECL)
1544 && DECL_IS_BUILTIN (t))
1547 /* Function decls tend to have longer names. */
1548 if (TREE_CODE (t) == FUNCTION_DECL)
1555 fprintf (stderr, "\n\t");
1558 print_node_brief (stderr, "", t, 0);
1559 if (t == error_mark_node)
1563 fprintf (stderr, "\n");
1565 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1568 cp_class_binding *b;
1569 fprintf (stderr, " class-shadowed:");
1571 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1573 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1574 fprintf (stderr, "\n");
1576 if (lvl->type_shadowed)
1578 fprintf (stderr, " type-shadowed:");
1579 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1581 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1583 fprintf (stderr, "\n");
1588 print_other_binding_stack (struct cp_binding_level *stack)
1590 struct cp_binding_level *level;
1591 for (level = stack; !global_scope_p (level); level = level->level_chain)
1593 fprintf (stderr, "binding level %p\n", (void *) level);
1594 print_binding_level (level);
1599 print_binding_stack (void)
1601 struct cp_binding_level *b;
1602 fprintf (stderr, "current_binding_level=%p\n"
1603 "class_binding_level=%p\n"
1604 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1605 (void *) current_binding_level, (void *) class_binding_level,
1606 (void *) NAMESPACE_LEVEL (global_namespace));
1607 if (class_binding_level)
1609 for (b = class_binding_level; b; b = b->level_chain)
1610 if (b == current_binding_level)
1613 b = class_binding_level;
1615 b = current_binding_level;
1618 b = current_binding_level;
1619 print_other_binding_stack (b);
1620 fprintf (stderr, "global:\n");
1621 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1624 /* Return the type associated with id. */
1627 identifier_type_value (tree id)
1629 timevar_push (TV_NAME_LOOKUP);
1630 /* There is no type with that name, anywhere. */
1631 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1632 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1633 /* This is not the type marker, but the real thing. */
1634 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1635 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1636 /* Have to search for it. It must be on the global level, now.
1637 Ask lookup_name not to return non-types. */
1638 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1640 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1641 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1644 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1645 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1648 identifier_global_value (tree t)
1650 return IDENTIFIER_GLOBAL_VALUE (t);
1653 /* Push a definition of struct, union or enum tag named ID. into
1654 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1655 the tag ID is not already defined. */
1658 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1662 if (b->kind != sk_namespace)
1664 /* Shadow the marker, not the real thing, so that the marker
1665 gets restored later. */
1666 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1668 = tree_cons (id, old_type_value, b->type_shadowed);
1669 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1670 TREE_TYPE (b->type_shadowed) = type;
1674 cxx_binding *binding =
1675 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1678 supplement_binding (binding, decl);
1680 binding->value = decl;
1682 /* Store marker instead of real type. */
1683 type = global_type_node;
1685 SET_IDENTIFIER_TYPE_VALUE (id, type);
1688 /* As set_identifier_type_value_with_scope, but using
1689 current_binding_level. */
1692 set_identifier_type_value (tree id, tree decl)
1694 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1697 /* Return the name for the constructor (or destructor) for the
1698 specified class TYPE. When given a template, this routine doesn't
1699 lose the specialization. */
1702 constructor_name_full (tree type)
1704 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1707 /* Return the name for the constructor (or destructor) for the
1708 specified class. When given a template, return the plain
1709 unspecialized name. */
1712 constructor_name (tree type)
1715 name = constructor_name_full (type);
1716 if (IDENTIFIER_TEMPLATE (name))
1717 name = IDENTIFIER_TEMPLATE (name);
1721 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1724 constructor_name_p (tree name, tree type)
1731 if (TREE_CODE (name) != IDENTIFIER_NODE)
1734 ctor_name = constructor_name_full (type);
1735 if (name == ctor_name)
1737 if (IDENTIFIER_TEMPLATE (ctor_name)
1738 && name == IDENTIFIER_TEMPLATE (ctor_name))
1743 /* Counter used to create anonymous type names. */
1745 static GTY(()) int anon_cnt;
1747 /* Return an IDENTIFIER which can be used as a name for
1748 anonymous structs and unions. */
1751 make_anon_name (void)
1755 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1756 return get_identifier (buf);
1759 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1761 static inline cxx_binding *
1762 find_binding (cxx_scope *scope, cxx_binding *binding)
1764 timevar_push (TV_NAME_LOOKUP);
1766 for (; binding != NULL; binding = binding->previous)
1767 if (binding->scope == scope)
1768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1773 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1775 static inline cxx_binding *
1776 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1778 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1781 /* Fold-in case where NAME is used only once. */
1782 if (scope == b->scope && b->previous == NULL)
1784 return find_binding (scope, b);
1789 /* Always returns a binding for name in scope. If no binding is
1790 found, make a new one. */
1792 static cxx_binding *
1793 binding_for_name (cxx_scope *scope, tree name)
1795 cxx_binding *result;
1797 result = cxx_scope_find_binding_for_name (scope, name);
1800 /* Not found, make a new one. */
1801 result = cxx_binding_make (NULL, NULL);
1802 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1803 result->scope = scope;
1804 result->is_local = false;
1805 result->value_is_inherited = false;
1806 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1810 /* Insert another USING_DECL into the current binding level, returning
1811 this declaration. If this is a redeclaration, do nothing, and
1812 return NULL_TREE if this not in namespace scope (in namespace
1813 scope, a using decl might extend any previous bindings). */
1816 push_using_decl (tree scope, tree name)
1820 timevar_push (TV_NAME_LOOKUP);
1821 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1822 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1823 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1824 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1828 namespace_bindings_p () ? decl : NULL_TREE);
1829 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1830 USING_DECL_SCOPE (decl) = scope;
1831 TREE_CHAIN (decl) = current_binding_level->usings;
1832 current_binding_level->usings = decl;
1833 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1836 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1837 caller to set DECL_CONTEXT properly. */
1840 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1842 struct cp_binding_level *b;
1843 tree function_decl = current_function_decl;
1845 timevar_push (TV_NAME_LOOKUP);
1846 current_function_decl = NULL_TREE;
1847 if (level->kind == sk_class)
1849 b = class_binding_level;
1850 class_binding_level = level;
1851 pushdecl_class_level (x);
1852 class_binding_level = b;
1856 b = current_binding_level;
1857 current_binding_level = level;
1858 x = pushdecl_maybe_friend (x, is_friend);
1859 current_binding_level = b;
1861 current_function_decl = function_decl;
1862 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1865 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1866 other definitions already in place. We get around this by making
1867 the value of the identifier point to a list of all the things that
1868 want to be referenced by that name. It is then up to the users of
1869 that name to decide what to do with that list.
1871 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1872 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1874 FLAGS is a bitwise-or of the following values:
1875 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1877 PUSH_USING: DECL is being pushed as the result of a using
1880 IS_FRIEND is true if this is a friend declaration.
1882 The value returned may be a previous declaration if we guessed wrong
1883 about what language DECL should belong to (C or C++). Otherwise,
1884 it's always DECL (and never something that's not a _DECL). */
1887 push_overloaded_decl (tree decl, int flags, bool is_friend)
1889 tree name = DECL_NAME (decl);
1892 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1894 timevar_push (TV_NAME_LOOKUP);
1896 old = namespace_binding (name, DECL_CONTEXT (decl));
1898 old = lookup_name_innermost_nonclass_level (name);
1902 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1904 tree t = TREE_TYPE (old);
1905 if (IS_AGGR_TYPE (t) && warn_shadow
1906 && (! DECL_IN_SYSTEM_HEADER (decl)
1907 || ! DECL_IN_SYSTEM_HEADER (old)))
1908 warning (0, "%q#D hides constructor for %q#T", decl, t);
1911 else if (is_overloaded_fn (old))
1915 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1917 tree fn = OVL_CURRENT (tmp);
1920 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1921 && !(flags & PUSH_USING)
1922 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1923 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1924 && ! decls_match (fn, decl))
1925 error ("%q#D conflicts with previous using declaration %q#D",
1928 dup = duplicate_decls (decl, fn, is_friend);
1929 /* If DECL was a redeclaration of FN -- even an invalid
1930 one -- pass that information along to our caller. */
1931 if (dup == fn || dup == error_mark_node)
1932 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1935 /* We don't overload implicit built-ins. duplicate_decls()
1936 may fail to merge the decls if the new decl is e.g. a
1937 template function. */
1938 if (TREE_CODE (old) == FUNCTION_DECL
1939 && DECL_ANTICIPATED (old)
1940 && !DECL_HIDDEN_FRIEND_P (old))
1943 else if (old == error_mark_node)
1944 /* Ignore the undefined symbol marker. */
1948 error ("previous non-function declaration %q+#D", old);
1949 error ("conflicts with function declaration %q#D", decl);
1950 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1954 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1955 /* If it's a using declaration, we always need to build an OVERLOAD,
1956 because it's the only way to remember that the declaration comes
1957 from 'using', and have the lookup behave correctly. */
1958 || (flags & PUSH_USING))
1960 if (old && TREE_CODE (old) != OVERLOAD)
1961 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1963 new_binding = ovl_cons (decl, old);
1964 if (flags & PUSH_USING)
1965 OVL_USED (new_binding) = 1;
1968 /* NAME is not ambiguous. */
1972 set_namespace_binding (name, current_namespace, new_binding);
1975 /* We only create an OVERLOAD if there was a previous binding at
1976 this level, or if decl is a template. In the former case, we
1977 need to remove the old binding and replace it with the new
1978 binding. We must also run through the NAMES on the binding
1979 level where the name was bound to update the chain. */
1981 if (TREE_CODE (new_binding) == OVERLOAD && old)
1985 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1987 d = &TREE_CHAIN (*d))
1989 || (TREE_CODE (*d) == TREE_LIST
1990 && TREE_VALUE (*d) == old))
1992 if (TREE_CODE (*d) == TREE_LIST)
1993 /* Just replace the old binding with the new. */
1994 TREE_VALUE (*d) = new_binding;
1996 /* Build a TREE_LIST to wrap the OVERLOAD. */
1997 *d = tree_cons (NULL_TREE, new_binding,
2000 /* And update the cxx_binding node. */
2001 IDENTIFIER_BINDING (name)->value = new_binding;
2002 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2005 /* We should always find a previous binding in this case. */
2009 /* Install the new binding. */
2010 push_local_binding (name, new_binding, flags);
2013 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2016 /* Check a non-member using-declaration. Return the name and scope
2017 being used, and the USING_DECL, or NULL_TREE on failure. */
2020 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2022 /* [namespace.udecl]
2023 A using-declaration for a class member shall be a
2024 member-declaration. */
2027 error ("%qT is not a namespace", scope);
2030 else if (scope == error_mark_node)
2033 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2036 A using-declaration shall not name a template-id. */
2037 error ("a using-declaration cannot specify a template-id. "
2038 "Try %<using %D%>", name);
2042 if (TREE_CODE (decl) == NAMESPACE_DECL)
2044 error ("namespace %qD not allowed in using-declaration", decl);
2048 if (TREE_CODE (decl) == SCOPE_REF)
2050 /* It's a nested name with template parameter dependent scope.
2051 This can only be using-declaration for class member. */
2052 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2056 if (is_overloaded_fn (decl))
2057 decl = get_first_fn (decl);
2059 gcc_assert (DECL_P (decl));
2061 /* Make a USING_DECL. */
2062 return push_using_decl (scope, name);
2065 /* Process local and global using-declarations. */
2068 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2069 tree *newval, tree *newtype)
2071 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2073 *newval = *newtype = NULL_TREE;
2074 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2078 if (!decls.value && !decls.type)
2080 error ("%qD not declared", name);
2084 /* LLVM LOCAL begin mainline */
2085 /* Shift the old and new bindings around so we're comparing class and
2086 enumeration names to each other. */
2087 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2093 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2095 decls.type = decls.value;
2096 decls.value = NULL_TREE;
2098 /* LLVM LOCAL end mainline */
2100 /* It is impossible to overload a built-in function; any explicit
2101 declaration eliminates the built-in declaration. So, if OLDVAL
2102 is a built-in, then we can just pretend it isn't there. */
2104 && TREE_CODE (oldval) == FUNCTION_DECL
2105 && DECL_ANTICIPATED (oldval)
2106 && !DECL_HIDDEN_FRIEND_P (oldval))
2109 /* LLVM LOCAL begin mainline */
2112 /* Check for using functions. */
2113 if (is_overloaded_fn (decls.value))
2117 if (oldval && !is_overloaded_fn (oldval))
2119 error ("%qD is already declared in this scope", name);
2124 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2126 tree new_fn = OVL_CURRENT (tmp);
2128 /* [namespace.udecl]
2130 If a function declaration in namespace scope or block
2131 scope has the same name and the same parameter types as a
2132 function introduced by a using declaration the program is
2134 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2136 tree old_fn = OVL_CURRENT (tmp1);
2138 if (new_fn == old_fn)
2139 /* The function already exists in the current namespace. */
2141 else if (OVL_USED (tmp1))
2142 continue; /* this is a using decl */
2143 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2144 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2146 gcc_assert (!DECL_ANTICIPATED (old_fn)
2147 || DECL_HIDDEN_FRIEND_P (old_fn));
2149 /* There was already a non-using declaration in
2150 this scope with the same parameter types. If both
2151 are the same extern "C" functions, that's ok. */
2152 if (decls_match (new_fn, old_fn))
2156 error ("%qD is already declared in this scope", name);
2162 /* If we broke out of the loop, there's no reason to add
2163 this function to the using declarations for this
2168 /* If we are adding to an existing OVERLOAD, then we no
2169 longer know the type of the set of functions. */
2170 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2171 TREE_TYPE (*newval) = unknown_type_node;
2172 /* Add this new function to the set. */
2173 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2174 /* If there is only one function, then we use its type. (A
2175 using-declaration naming a single function can be used in
2176 contexts where overload resolution cannot be
2178 if (TREE_CODE (*newval) != OVERLOAD)
2180 *newval = ovl_cons (*newval, NULL_TREE);
2181 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2183 OVL_USED (*newval) = 1;
2188 *newval = decls.value;
2189 if (oldval && !decls_match (*newval, oldval))
2190 error ("%qD is already declared in this scope", name);
2196 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2198 error ("reference to %qD is ambiguous", name);
2199 print_candidates (decls.type);
2203 *newtype = decls.type;
2204 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2205 error ("%qD is already declared in this scope", name);
2208 /* If *newval is empty, shift any class or enumeration name down. */
2212 *newtype = NULL_TREE;
2214 /* LLVM LOCAL end mainline */
2217 /* Process a using-declaration at function scope. */
2220 do_local_using_decl (tree decl, tree scope, tree name)
2222 tree oldval, oldtype, newval, newtype;
2223 tree orig_decl = decl;
2225 decl = validate_nonmember_using_decl (decl, scope, name);
2226 if (decl == NULL_TREE)
2229 if (building_stmt_tree ()
2230 && at_function_scope_p ())
2231 add_decl_expr (decl);
2233 oldval = lookup_name_innermost_nonclass_level (name);
2234 oldtype = lookup_type_current_level (name);
2236 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2240 if (is_overloaded_fn (newval))
2244 /* We only need to push declarations for those functions
2245 that were not already bound in the current level.
2246 The old value might be NULL_TREE, it might be a single
2247 function, or an OVERLOAD. */
2248 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2249 term = OVL_FUNCTION (oldval);
2252 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2254 push_overloaded_decl (OVL_CURRENT (fn),
2255 PUSH_LOCAL | PUSH_USING,
2259 push_local_binding (name, newval, PUSH_USING);
2263 push_local_binding (name, newtype, PUSH_USING);
2264 set_identifier_type_value (name, newtype);
2267 /* Emit debug info. */
2268 if (!processing_template_decl)
2269 cp_emit_debug_info_for_using (orig_decl, current_scope());
2272 /* Returns true if ROOT (a namespace, class, or function) encloses
2273 CHILD. CHILD may be either a class type or a namespace. */
2276 is_ancestor (tree root, tree child)
2278 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2279 || TREE_CODE (root) == FUNCTION_DECL
2280 || CLASS_TYPE_P (root)));
2281 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2282 || CLASS_TYPE_P (child)));
2284 /* The global namespace encloses everything. */
2285 if (root == global_namespace)
2290 /* If we've run out of scopes, stop. */
2293 /* If we've reached the ROOT, it encloses CHILD. */
2296 /* Go out one level. */
2298 child = TYPE_NAME (child);
2299 child = DECL_CONTEXT (child);
2303 /* Enter the class or namespace scope indicated by T suitable for name
2304 lookup. T can be arbitrary scope, not necessary nested inside the
2305 current scope. Returns a non-null scope to pop iff pop_scope
2306 should be called later to exit this scope. */
2311 if (TREE_CODE (t) == NAMESPACE_DECL)
2312 push_decl_namespace (t);
2313 else if (CLASS_TYPE_P (t))
2315 if (!at_class_scope_p ()
2316 || !same_type_p (current_class_type, t))
2317 push_nested_class (t);
2319 /* T is the same as the current scope. There is therefore no
2320 need to re-enter the scope. Since we are not actually
2321 pushing a new scope, our caller should not call
2329 /* Leave scope pushed by push_scope. */
2334 if (TREE_CODE (t) == NAMESPACE_DECL)
2335 pop_decl_namespace ();
2336 else if CLASS_TYPE_P (t)
2337 pop_nested_class ();
2340 /* Subroutine of push_inner_scope. */
2343 push_inner_scope_r (tree outer, tree inner)
2348 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2351 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2353 push_inner_scope_r (outer, prev);
2354 if (TREE_CODE (inner) == NAMESPACE_DECL)
2356 struct cp_binding_level *save_template_parm = 0;
2357 /* Temporary take out template parameter scopes. They are saved
2358 in reversed order in save_template_parm. */
2359 while (current_binding_level->kind == sk_template_parms)
2361 struct cp_binding_level *b = current_binding_level;
2362 current_binding_level = b->level_chain;
2363 b->level_chain = save_template_parm;
2364 save_template_parm = b;
2367 resume_scope (NAMESPACE_LEVEL (inner));
2368 current_namespace = inner;
2370 /* Restore template parameter scopes. */
2371 while (save_template_parm)
2373 struct cp_binding_level *b = save_template_parm;
2374 save_template_parm = b->level_chain;
2375 b->level_chain = current_binding_level;
2376 current_binding_level = b;
2383 /* Enter the scope INNER from current scope. INNER must be a scope
2384 nested inside current scope. This works with both name lookup and
2385 pushing name into scope. In case a template parameter scope is present,
2386 namespace is pushed under the template parameter scope according to
2387 name lookup rule in 14.6.1/6.
2389 Return the former current scope suitable for pop_inner_scope. */
2392 push_inner_scope (tree inner)
2394 tree outer = current_scope ();
2396 outer = current_namespace;
2398 push_inner_scope_r (outer, inner);
2402 /* Exit the current scope INNER back to scope OUTER. */
2405 pop_inner_scope (tree outer, tree inner)
2408 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2411 while (outer != inner)
2413 if (TREE_CODE (inner) == NAMESPACE_DECL)
2415 struct cp_binding_level *save_template_parm = 0;
2416 /* Temporary take out template parameter scopes. They are saved
2417 in reversed order in save_template_parm. */
2418 while (current_binding_level->kind == sk_template_parms)
2420 struct cp_binding_level *b = current_binding_level;
2421 current_binding_level = b->level_chain;
2422 b->level_chain = save_template_parm;
2423 save_template_parm = b;
2428 /* Restore template parameter scopes. */
2429 while (save_template_parm)
2431 struct cp_binding_level *b = save_template_parm;
2432 save_template_parm = b->level_chain;
2433 b->level_chain = current_binding_level;
2434 current_binding_level = b;
2440 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2444 /* Do a pushlevel for class declarations. */
2447 pushlevel_class (void)
2449 if (ENABLE_SCOPE_CHECKING)
2452 class_binding_level = begin_scope (sk_class, current_class_type);
2455 /* ...and a poplevel for class declarations. */
2458 poplevel_class (void)
2460 struct cp_binding_level *level = class_binding_level;
2461 cp_class_binding *cb;
2465 timevar_push (TV_NAME_LOOKUP);
2466 gcc_assert (level != 0);
2468 /* If we're leaving a toplevel class, cache its binding level. */
2469 if (current_class_depth == 1)
2470 previous_class_level = level;
2471 for (shadowed = level->type_shadowed;
2473 shadowed = TREE_CHAIN (shadowed))
2474 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2476 /* Remove the bindings for all of the class-level declarations. */
2477 if (level->class_shadowed)
2480 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2482 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2483 ggc_free (level->class_shadowed);
2484 level->class_shadowed = NULL;
2487 /* Now, pop out of the binding level which we created up in the
2488 `pushlevel_class' routine. */
2489 if (ENABLE_SCOPE_CHECKING)
2493 timevar_pop (TV_NAME_LOOKUP);
2496 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2497 appropriate. DECL is the value to which a name has just been
2498 bound. CLASS_TYPE is the class in which the lookup occurred. */
2501 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2504 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2508 if (TREE_CODE (decl) == OVERLOAD)
2509 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2512 gcc_assert (DECL_P (decl));
2513 context = context_for_name_lookup (decl);
2516 if (is_properly_derived_from (class_type, context))
2517 INHERITED_VALUE_BINDING_P (binding) = 1;
2519 INHERITED_VALUE_BINDING_P (binding) = 0;
2521 else if (binding->value == decl)
2522 /* We only encounter a TREE_LIST when there is an ambiguity in the
2523 base classes. Such an ambiguity can be overridden by a
2524 definition in this class. */
2525 INHERITED_VALUE_BINDING_P (binding) = 1;
2527 INHERITED_VALUE_BINDING_P (binding) = 0;
2530 /* Make the declaration of X appear in CLASS scope. */
2533 pushdecl_class_level (tree x)
2536 bool is_valid = true;
2538 timevar_push (TV_NAME_LOOKUP);
2539 /* Get the name of X. */
2540 if (TREE_CODE (x) == OVERLOAD)
2541 name = DECL_NAME (get_first_fn (x));
2543 name = DECL_NAME (x);
2547 is_valid = push_class_level_binding (name, x);
2548 if (TREE_CODE (x) == TYPE_DECL)
2549 set_identifier_type_value (name, x);
2551 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2553 /* If X is an anonymous aggregate, all of its members are
2554 treated as if they were members of the class containing the
2555 aggregate, for naming purposes. */
2558 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2560 location_t save_location = input_location;
2561 input_location = DECL_SOURCE_LOCATION (f);
2562 if (!pushdecl_class_level (f))
2564 input_location = save_location;
2567 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2570 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2571 scope. If the value returned is non-NULL, and the PREVIOUS field
2572 is not set, callers must set the PREVIOUS field explicitly. */
2574 static cxx_binding *
2575 get_class_binding (tree name, cxx_scope *scope)
2580 cxx_binding *binding;
2582 class_type = scope->this_entity;
2584 /* Get the type binding. */
2585 type_binding = lookup_member (class_type, name,
2586 /*protect=*/2, /*want_type=*/true);
2587 /* Get the value binding. */
2588 value_binding = lookup_member (class_type, name,
2589 /*protect=*/2, /*want_type=*/false);
2592 && (TREE_CODE (value_binding) == TYPE_DECL
2593 || DECL_CLASS_TEMPLATE_P (value_binding)
2594 || (TREE_CODE (value_binding) == TREE_LIST
2595 && TREE_TYPE (value_binding) == error_mark_node
2596 && (TREE_CODE (TREE_VALUE (value_binding))
2598 /* We found a type binding, even when looking for a non-type
2599 binding. This means that we already processed this binding
2602 else if (value_binding)
2604 if (TREE_CODE (value_binding) == TREE_LIST
2605 && TREE_TYPE (value_binding) == error_mark_node)
2606 /* NAME is ambiguous. */
2608 else if (BASELINK_P (value_binding))
2609 /* NAME is some overloaded functions. */
2610 value_binding = BASELINK_FUNCTIONS (value_binding);
2613 /* If we found either a type binding or a value binding, create a
2614 new binding object. */
2615 if (type_binding || value_binding)
2617 binding = new_class_binding (name,
2621 /* This is a class-scope binding, not a block-scope binding. */
2622 LOCAL_BINDING_P (binding) = 0;
2623 set_inherited_value_binding_p (binding, value_binding, class_type);
2631 /* Make the declaration(s) of X appear in CLASS scope under the name
2632 NAME. Returns true if the binding is valid. */
2635 push_class_level_binding (tree name, tree x)
2637 cxx_binding *binding;
2641 timevar_push (TV_NAME_LOOKUP);
2642 /* The class_binding_level will be NULL if x is a template
2643 parameter name in a member template. */
2644 if (!class_binding_level)
2645 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2647 if (name == error_mark_node)
2648 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2650 /* Check for invalid member names. */
2651 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2652 /* We could have been passed a tree list if this is an ambiguous
2653 declaration. If so, pull the declaration out because
2654 check_template_shadow will not handle a TREE_LIST. */
2655 if (TREE_CODE (decl) == TREE_LIST
2656 && TREE_TYPE (decl) == error_mark_node)
2657 decl = TREE_VALUE (decl);
2659 check_template_shadow (decl);
2663 If T is the name of a class, then each of the following shall
2664 have a name different from T:
2666 -- every static data member of class T;
2668 -- every member of class T that is itself a type;
2670 -- every enumerator of every member of class T that is an
2673 -- every member of every anonymous union that is a member of
2676 (Non-static data members were also forbidden to have the same
2677 name as T until TC1.) */
2678 if ((TREE_CODE (x) == VAR_DECL
2679 || TREE_CODE (x) == CONST_DECL
2680 || (TREE_CODE (x) == TYPE_DECL
2681 && !DECL_SELF_REFERENCE_P (x))
2682 /* A data member of an anonymous union. */
2683 || (TREE_CODE (x) == FIELD_DECL
2684 && DECL_CONTEXT (x) != current_class_type))
2685 && DECL_NAME (x) == constructor_name (current_class_type))
2687 tree scope = context_for_name_lookup (x);
2688 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2690 error ("%qD has the same name as the class in which it is "
2693 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2697 /* Get the current binding for NAME in this class, if any. */
2698 binding = IDENTIFIER_BINDING (name);
2699 if (!binding || binding->scope != class_binding_level)
2701 binding = get_class_binding (name, class_binding_level);
2702 /* If a new binding was created, put it at the front of the
2703 IDENTIFIER_BINDING list. */
2706 binding->previous = IDENTIFIER_BINDING (name);
2707 IDENTIFIER_BINDING (name) = binding;
2711 /* If there is already a binding, then we may need to update the
2713 if (binding && binding->value)
2715 tree bval = binding->value;
2716 tree old_decl = NULL_TREE;
2718 if (INHERITED_VALUE_BINDING_P (binding))
2720 /* If the old binding was from a base class, and was for a
2721 tag name, slide it over to make room for the new binding.
2722 The old binding is still visible if explicitly qualified
2723 with a class-key. */
2724 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2725 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2727 old_decl = binding->type;
2728 binding->type = bval;
2729 binding->value = NULL_TREE;
2730 INHERITED_VALUE_BINDING_P (binding) = 0;
2735 /* Any inherited type declaration is hidden by the type
2736 declaration in the derived class. */
2737 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2738 binding->type = NULL_TREE;
2741 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2743 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2744 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2745 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2747 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2750 if (old_decl && binding->scope == class_binding_level)
2753 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2754 here. This function is only used to register bindings
2755 from with the class definition itself. */
2756 INHERITED_VALUE_BINDING_P (binding) = 0;
2757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2761 /* Note that we declared this value so that we can issue an error if
2762 this is an invalid redeclaration of a name already used for some
2764 note_name_declared_in_class (name, decl);
2766 /* If we didn't replace an existing binding, put the binding on the
2767 stack of bindings for the identifier, and update the shadowed
2769 if (binding && binding->scope == class_binding_level)
2770 /* Supplement the existing binding. */
2771 ok = supplement_binding (binding, decl);
2774 /* Create a new binding. */
2775 push_binding (name, decl, class_binding_level);
2779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2782 /* Process "using SCOPE::NAME" in a class scope. Return the
2783 USING_DECL created. */
2786 do_class_using_decl (tree scope, tree name)
2788 /* The USING_DECL returned by this function. */
2790 /* The declaration (or declarations) name by this using
2791 declaration. NULL if we are in a template and cannot figure out
2792 what has been named. */
2794 /* True if SCOPE is a dependent type. */
2795 bool scope_dependent_p;
2796 /* True if SCOPE::NAME is dependent. */
2797 bool name_dependent_p;
2798 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2799 bool bases_dependent_p;
2804 if (name == error_mark_node)
2807 if (!scope || !TYPE_P (scope))
2809 error ("using-declaration for non-member at class scope");
2813 /* Make sure the name is not invalid */
2814 if (TREE_CODE (name) == BIT_NOT_EXPR)
2816 error ("%<%T::%D%> names destructor", scope, name);
2819 if (constructor_name_p (name, scope))
2821 error ("%<%T::%D%> names constructor", scope, name);
2824 if (constructor_name_p (name, current_class_type))
2826 error ("%<%T::%D%> names constructor in %qT",
2827 scope, name, current_class_type);
2831 scope_dependent_p = dependent_type_p (scope);
2832 name_dependent_p = (scope_dependent_p
2833 || (IDENTIFIER_TYPENAME_P (name)
2834 && dependent_type_p (TREE_TYPE (name))));
2836 bases_dependent_p = false;
2837 if (processing_template_decl)
2838 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2839 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2841 if (dependent_type_p (TREE_TYPE (base_binfo)))
2843 bases_dependent_p = true;
2849 /* From [namespace.udecl]:
2851 A using-declaration used as a member-declaration shall refer to a
2852 member of a base class of the class being defined.
2854 In general, we cannot check this constraint in a template because
2855 we do not know the entire set of base classes of the current
2856 class type. However, if all of the base classes are
2857 non-dependent, then we can avoid delaying the check until
2859 if (!scope_dependent_p)
2862 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2863 if (b_kind < bk_proper_base)
2865 if (!bases_dependent_p)
2867 error_not_base_type (scope, current_class_type);
2871 else if (!name_dependent_p)
2873 decl = lookup_member (binfo, name, 0, false);
2876 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2880 /* The binfo from which the functions came does not matter. */
2881 if (BASELINK_P (decl))
2882 decl = BASELINK_FUNCTIONS (decl);
2886 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2887 USING_DECL_DECLS (value) = decl;
2888 USING_DECL_SCOPE (value) = scope;
2889 DECL_DEPENDENT_P (value) = !decl;
2895 /* Return the binding value for name in scope. */
2898 namespace_binding (tree name, tree scope)
2900 cxx_binding *binding;
2903 scope = global_namespace;
2905 /* Unnecessary for the global namespace because it can't be an alias. */
2906 scope = ORIGINAL_NAMESPACE (scope);
2908 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2910 return binding ? binding->value : NULL_TREE;
2913 /* Set the binding value for name in scope. */
2916 set_namespace_binding (tree name, tree scope, tree val)
2920 timevar_push (TV_NAME_LOOKUP);
2921 if (scope == NULL_TREE)
2922 scope = global_namespace;
2923 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2924 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2927 supplement_binding (b, val);
2928 timevar_pop (TV_NAME_LOOKUP);
2931 /* Set the context of a declaration to scope. Complain if we are not
2935 set_decl_namespace (tree decl, tree scope, bool friendp)
2939 /* Get rid of namespace aliases. */
2940 scope = ORIGINAL_NAMESPACE (scope);
2942 /* It is ok for friends to be qualified in parallel space. */
2943 if (!friendp && !is_ancestor (current_namespace, scope))
2944 error ("declaration of %qD not in a namespace surrounding %qD",
2946 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2948 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2949 if (scope == current_namespace)
2951 if (at_namespace_scope_p ())
2952 error ("explicit qualification in declaration of %qD",
2957 /* See whether this has been declared in the namespace. */
2958 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2959 if (old == error_mark_node)
2960 /* No old declaration at all. */
2962 if (!is_overloaded_fn (decl))
2963 /* Don't compare non-function decls with decls_match here, since
2964 it can't check for the correct constness at this
2965 point. pushdecl will find those errors later. */
2967 /* Since decl is a function, old should contain a function decl. */
2968 if (!is_overloaded_fn (old))
2970 fn = OVL_CURRENT (old);
2971 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2973 /* A template can be explicitly specialized in any namespace. */
2974 if (processing_explicit_instantiation)
2976 if (processing_template_decl || processing_specialization)
2977 /* We have not yet called push_template_decl to turn a
2978 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2979 match. But, we'll check later, when we construct the
2982 /* Instantiations or specializations of templates may be declared as
2983 friends in any namespace. */
2984 if (friendp && DECL_USE_TEMPLATE (decl))
2986 if (is_overloaded_fn (old))
2988 for (; old; old = OVL_NEXT (old))
2989 if (decls_match (decl, OVL_CURRENT (old)))
2992 else if (decls_match (decl, old))
2995 error ("%qD should have been declared inside %qD", decl, scope);
2998 /* Return the namespace where the current declaration is declared. */
3001 current_decl_namespace (void)
3004 /* If we have been pushed into a different namespace, use it. */
3005 if (decl_namespace_list)
3006 return TREE_PURPOSE (decl_namespace_list);
3008 if (current_class_type)
3009 result = decl_namespace_context (current_class_type);
3010 else if (current_function_decl)
3011 result = decl_namespace_context (current_function_decl);
3013 result = current_namespace;
3017 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3018 select a name that is unique to this compilation unit. */
3021 push_namespace (tree name)
3023 push_namespace_with_attribs (name, NULL_TREE);
3026 /* Same, but specify attributes to apply to the namespace. The attributes
3027 only apply to the current namespace-body, not to any later extensions. */
3030 push_namespace_with_attribs (tree name, tree attributes)
3034 int implicit_use = 0;
3037 timevar_push (TV_NAME_LOOKUP);
3039 /* We should not get here if the global_namespace is not yet constructed
3040 nor if NAME designates the global namespace: The global scope is
3041 constructed elsewhere. */
3042 gcc_assert (global_namespace != NULL && name != global_scope_name);
3046 /* The name of anonymous namespace is unique for the translation
3048 if (!anonymous_namespace_name)
3049 anonymous_namespace_name = get_file_function_name ('N');
3050 name = anonymous_namespace_name;
3051 d = IDENTIFIER_NAMESPACE_VALUE (name);
3053 /* Reopening anonymous namespace. */
3059 /* Check whether this is an extended namespace definition. */
3060 d = IDENTIFIER_NAMESPACE_VALUE (name);
3061 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3064 if (DECL_NAMESPACE_ALIAS (d))
3066 error ("namespace alias %qD not allowed here, assuming %qD",
3067 d, DECL_NAMESPACE_ALIAS (d));
3068 d = DECL_NAMESPACE_ALIAS (d);
3075 /* Make a new namespace, binding the name to it. */
3076 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3077 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3078 /* The name of this namespace is not visible to other translation
3079 units if it is an anonymous namespace or member thereof. */
3080 if (anon || decl_anon_ns_mem_p (current_namespace))
3081 TREE_PUBLIC (d) = 0;
3083 TREE_PUBLIC (d) = 1;
3087 /* Clear DECL_NAME for the benefit of debugging back ends. */
3088 SET_DECL_ASSEMBLER_NAME (d, name);
3089 DECL_NAME (d) = NULL_TREE;
3091 begin_scope (sk_namespace, d);
3094 resume_scope (NAMESPACE_LEVEL (d));
3097 do_using_directive (d);
3098 /* Enter the name space. */
3099 current_namespace = d;
3101 #ifdef HANDLE_PRAGMA_VISIBILITY
3102 /* Clear has_visibility in case a previous namespace-definition had a
3103 visibility attribute and this one doesn't. */
3104 current_binding_level->has_visibility = 0;
3105 for (d = attributes; d; d = TREE_CHAIN (d))
3107 tree name = TREE_PURPOSE (d);
3108 tree args = TREE_VALUE (d);
3111 if (! is_attribute_p ("visibility", name))
3113 warning (OPT_Wattributes, "%qs attribute directive ignored",
3114 IDENTIFIER_POINTER (name));
3118 x = args ? TREE_VALUE (args) : NULL_TREE;
3119 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3121 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3122 IDENTIFIER_POINTER (name));
3126 current_binding_level->has_visibility = 1;
3127 push_visibility (TREE_STRING_POINTER (x));
3133 timevar_pop (TV_NAME_LOOKUP);
3136 /* Pop from the scope of the current namespace. */
3139 pop_namespace (void)
3141 gcc_assert (current_namespace != global_namespace);
3142 current_namespace = CP_DECL_CONTEXT (current_namespace);
3143 /* The binding level is not popped, as it might be re-opened later. */
3147 /* Push into the scope of the namespace NS, even if it is deeply
3148 nested within another namespace. */
3151 push_nested_namespace (tree ns)
3153 if (ns == global_namespace)
3154 push_to_top_level ();
3157 push_nested_namespace (CP_DECL_CONTEXT (ns));
3158 push_namespace (DECL_NAME (ns));
3162 /* Pop back from the scope of the namespace NS, which was previously
3163 entered with push_nested_namespace. */
3166 pop_nested_namespace (tree ns)
3168 timevar_push (TV_NAME_LOOKUP);
3169 while (ns != global_namespace)
3172 ns = CP_DECL_CONTEXT (ns);
3175 pop_from_top_level ();
3176 timevar_pop (TV_NAME_LOOKUP);
3179 /* Temporarily set the namespace for the current declaration. */
3182 push_decl_namespace (tree decl)
3184 if (TREE_CODE (decl) != NAMESPACE_DECL)
3185 decl = decl_namespace_context (decl);
3186 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3187 NULL_TREE, decl_namespace_list);
3190 /* [namespace.memdef]/2 */
3193 pop_decl_namespace (void)
3195 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3198 /* Return the namespace that is the common ancestor
3199 of two given namespaces. */
3202 namespace_ancestor (tree ns1, tree ns2)
3204 timevar_push (TV_NAME_LOOKUP);
3205 if (is_ancestor (ns1, ns2))
3206 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3207 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3208 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3211 /* Process a namespace-alias declaration. */
3214 do_namespace_alias (tree alias, tree namespace)
3216 if (namespace == error_mark_node)
3219 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3221 namespace = ORIGINAL_NAMESPACE (namespace);
3223 /* Build the alias. */
3224 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3225 DECL_NAMESPACE_ALIAS (alias) = namespace;
3226 DECL_EXTERNAL (alias) = 1;
3227 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3230 /* Emit debug info for namespace alias. */
3231 (*debug_hooks->global_decl) (alias);
3234 /* Like pushdecl, only it places X in the current namespace,
3238 pushdecl_namespace_level (tree x, bool is_friend)
3240 struct cp_binding_level *b = current_binding_level;
3243 timevar_push (TV_NAME_LOOKUP);
3244 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3246 /* Now, the type_shadowed stack may screw us. Munge it so it does
3248 if (TREE_CODE (t) == TYPE_DECL)
3250 tree name = DECL_NAME (t);
3252 tree *ptr = (tree *)0;
3253 for (; !global_scope_p (b); b = b->level_chain)
3255 tree shadowed = b->type_shadowed;
3256 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3257 if (TREE_PURPOSE (shadowed) == name)
3259 ptr = &TREE_VALUE (shadowed);
3260 /* Can't break out of the loop here because sometimes
3261 a binding level will have duplicate bindings for
3262 PT names. It's gross, but I haven't time to fix it. */
3265 newval = TREE_TYPE (t);
3266 if (ptr == (tree *)0)
3268 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3269 up here if this is changed to an assertion. --KR */
3270 SET_IDENTIFIER_TYPE_VALUE (name, t);
3277 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3280 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3281 directive is not directly from the source. Also find the common
3282 ancestor and let our users know about the new namespace */
3284 add_using_namespace (tree user, tree used, bool indirect)
3287 timevar_push (TV_NAME_LOOKUP);
3288 /* Using oneself is a no-op. */
3291 timevar_pop (TV_NAME_LOOKUP);
3294 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3295 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3296 /* Check if we already have this. */
3297 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3301 /* Promote to direct usage. */
3302 TREE_INDIRECT_USING (t) = 0;
3303 timevar_pop (TV_NAME_LOOKUP);
3307 /* Add used to the user's using list. */
3308 DECL_NAMESPACE_USING (user)
3309 = tree_cons (used, namespace_ancestor (user, used),
3310 DECL_NAMESPACE_USING (user));
3312 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3314 /* Add user to the used's users list. */
3315 DECL_NAMESPACE_USERS (used)
3316 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3318 /* Recursively add all namespaces used. */
3319 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3320 /* indirect usage */
3321 add_using_namespace (user, TREE_PURPOSE (t), 1);
3323 /* Tell everyone using us about the new used namespaces. */
3324 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3325 add_using_namespace (TREE_PURPOSE (t), used, 1);
3326 timevar_pop (TV_NAME_LOOKUP);
3329 /* Process a using-declaration not appearing in class or local scope. */
3332 do_toplevel_using_decl (tree decl, tree scope, tree name)
3334 tree oldval, oldtype, newval, newtype;
3335 tree orig_decl = decl;
3336 cxx_binding *binding;
3338 decl = validate_nonmember_using_decl (decl, scope, name);
3339 if (decl == NULL_TREE)
3342 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3344 oldval = binding->value;
3345 oldtype = binding->type;
3347 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3349 /* Emit debug info. */
3350 if (!processing_template_decl)
3351 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3353 /* Copy declarations found. */
3355 binding->value = newval;
3357 binding->type = newtype;
3360 /* Process a using-directive. */
3363 do_using_directive (tree namespace)
3365 tree context = NULL_TREE;
3367 if (namespace == error_mark_node)
3370 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3372 if (building_stmt_tree ())
3373 add_stmt (build_stmt (USING_STMT, namespace));
3374 namespace = ORIGINAL_NAMESPACE (namespace);
3376 if (!toplevel_bindings_p ())
3378 push_using_directive (namespace);
3379 context = current_scope ();
3384 add_using_namespace (current_namespace, namespace, 0);
3385 if (current_namespace != global_namespace)
3386 context = current_namespace;
3389 /* Emit debugging info. */
3390 if (!processing_template_decl)
3391 (*debug_hooks->imported_module_or_decl) (namespace, context);
3394 /* Deal with a using-directive seen by the parser. Currently we only
3395 handle attributes here, since they cannot appear inside a template. */
3398 parse_using_directive (tree namespace, tree attribs)
3402 do_using_directive (namespace);
3404 for (a = attribs; a; a = TREE_CHAIN (a))
3406 tree name = TREE_PURPOSE (a);
3407 if (is_attribute_p ("strong", name))
3409 if (!toplevel_bindings_p ())
3410 error ("strong using only meaningful at namespace scope");
3411 else if (namespace != error_mark_node)
3413 if (!is_ancestor (current_namespace, namespace))
3414 error ("current namespace %qD does not enclose strongly used namespace %qD",
3415 current_namespace, namespace);
3416 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3417 = tree_cons (current_namespace, 0,
3418 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3422 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3426 /* Like pushdecl, only it places X in the global scope if appropriate.
3427 Calls cp_finish_decl to register the variable, initializing it with
3428 *INIT, if INIT is non-NULL. */
3431 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3433 timevar_push (TV_NAME_LOOKUP);
3434 push_to_top_level ();
3435 x = pushdecl_namespace_level (x, is_friend);
3437 finish_decl (x, *init, NULL_TREE);
3438 pop_from_top_level ();
3439 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3442 /* Like pushdecl, only it places X in the global scope if appropriate. */
3445 pushdecl_top_level (tree x)
3447 return pushdecl_top_level_1 (x, NULL, false);
3450 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3453 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3455 return pushdecl_top_level_1 (x, NULL, is_friend);
3458 /* Like pushdecl, only it places X in the global scope if
3459 appropriate. Calls cp_finish_decl to register the variable,
3460 initializing it with INIT. */
3463 pushdecl_top_level_and_finish (tree x, tree init)
3465 return pushdecl_top_level_1 (x, &init, false);
3468 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3469 duplicates. The first list becomes the tail of the result.
3471 The algorithm is O(n^2). We could get this down to O(n log n) by
3472 doing a sort on the addresses of the functions, if that becomes
3476 merge_functions (tree s1, tree s2)
3478 for (; s2; s2 = OVL_NEXT (s2))
3480 tree fn2 = OVL_CURRENT (s2);
3483 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3485 tree fn1 = OVL_CURRENT (fns1);
3487 /* If the function from S2 is already in S1, there is no
3488 need to add it again. For `extern "C"' functions, we
3489 might have two FUNCTION_DECLs for the same function, in
3490 different namespaces; again, we only need one of them. */
3492 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3493 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3497 /* If we exhausted all of the functions in S1, FN2 is new. */
3499 s1 = build_overload (fn2, s1);
3504 /* This should return an error not all definitions define functions.
3505 It is not an error if we find two functions with exactly the
3506 same signature, only if these are selected in overload resolution.
3507 old is the current set of bindings, new the freshly-found binding.
3508 XXX Do we want to give *all* candidates in case of ambiguity?
3509 XXX In what way should I treat extern declarations?
3510 XXX I don't want to repeat the entire duplicate_decls here */
3512 /* LLVM LOCAL begin mainline */
3514 ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
3517 gcc_assert (old != NULL);
3519 /* Copy the type. */
3521 if (LOOKUP_NAMESPACES_ONLY (flags)
3522 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3525 /* Copy the value. */
3529 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3532 switch (TREE_CODE (val))
3535 /* If we expect types or namespaces, and not templates,
3536 or this is not a template class. */
3537 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3538 && !DECL_CLASS_TEMPLATE_P (val)))
3542 if (LOOKUP_NAMESPACES_ONLY (flags)
3543 || (type && (flags & LOOKUP_PREFER_TYPES)))
3546 case NAMESPACE_DECL:
3547 if (LOOKUP_TYPES_ONLY (flags))
3551 /* Ignore built-in functions that are still anticipated. */
3552 if (LOOKUP_QUALIFIERS_ONLY (flags))
3556 if (LOOKUP_QUALIFIERS_ONLY (flags))
3561 /* If val is hidden, shift down any class or enumeration name. */
3568 /* LLVM LOCAL end mainline */
3571 else if (val && val != old->value)
3573 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3574 old->value = merge_functions (old->value, val);
3577 old->value = tree_cons (NULL_TREE, old->value,
3578 build_tree_list (NULL_TREE, val));
3579 TREE_TYPE (old->value) = error_mark_node;
3583 /* LLVM LOCAL begin mainline */
3586 else if (type && old->type != type)
3588 old->type = tree_cons (NULL_TREE, old->type,
3589 build_tree_list (NULL_TREE, type));
3590 TREE_TYPE (old->type) = error_mark_node;
3592 /* LLVM LOCAL end mainline */
3595 /* Return the declarations that are members of the namespace NS. */
3598 cp_namespace_decls (tree ns)
3600 return NAMESPACE_LEVEL (ns)->names;
3603 /* Combine prefer_type and namespaces_only into flags. */
3606 lookup_flags (int prefer_type, int namespaces_only)
3608 if (namespaces_only)
3609 return LOOKUP_PREFER_NAMESPACES;
3610 if (prefer_type > 1)
3611 return LOOKUP_PREFER_TYPES;
3612 if (prefer_type > 0)
3613 return LOOKUP_PREFER_BOTH;
3617 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3618 ignore it or not. Subroutine of lookup_name_real and
3619 lookup_type_scope. */
3622 qualify_lookup (tree val, int flags)
3624 if (val == NULL_TREE)
3626 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3628 if ((flags & LOOKUP_PREFER_TYPES)
3629 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3631 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3636 /* Given a lookup that returned VAL, decide if we want to ignore it or
3637 not based on DECL_ANTICIPATED. */
3640 hidden_name_p (tree val)
3643 && DECL_LANG_SPECIFIC (val)
3644 && DECL_ANTICIPATED (val))
3649 /* Remove any hidden friend functions from a possibly overloaded set
3653 remove_hidden_names (tree fns)
3658 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3660 else if (TREE_CODE (fns) == OVERLOAD)
3664 for (o = fns; o; o = OVL_NEXT (o))
3665 if (hidden_name_p (OVL_CURRENT (o)))
3671 for (o = fns; o; o = OVL_NEXT (o))
3672 if (!hidden_name_p (OVL_CURRENT (o)))
3673 n = build_overload (OVL_CURRENT (o), n);
3681 /* Unscoped lookup of a global: iterate over current namespaces,
3682 considering using-directives. */
3685 unqualified_namespace_lookup (tree name, int flags)
3687 tree initial = current_decl_namespace ();
3688 tree scope = initial;
3690 struct cp_binding_level *level;
3691 tree val = NULL_TREE;
3693 timevar_push (TV_NAME_LOOKUP);
3695 for (; !val; scope = CP_DECL_CONTEXT (scope))
3697 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3699 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3702 /* LLVM LOCAL mainline */
3703 ambiguous_decl (&binding, b, flags);
3705 /* Add all _DECLs seen through local using-directives. */
3706 for (level = current_binding_level;
3707 level->kind != sk_namespace;
3708 level = level->level_chain)
3709 if (!lookup_using_namespace (name, &binding, level->using_directives,
3711 /* Give up because of error. */
3712 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3714 /* Add all _DECLs seen through global using-directives. */
3715 /* XXX local and global using lists should work equally. */
3719 if (!lookup_using_namespace (name, &binding,
3720 DECL_NAMESPACE_USING (siter),
3722 /* Give up because of error. */
3723 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3724 if (siter == scope) break;
3725 siter = CP_DECL_CONTEXT (siter);
3728 val = binding.value;
3729 if (scope == global_namespace)
3732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3735 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3736 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3739 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3740 declaration found. If no suitable declaration can be found,
3741 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3742 neither a class-type nor a namespace a diagnostic is issued. */
3745 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3750 if (TREE_CODE (scope) == NAMESPACE_DECL)
3752 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3754 flags |= LOOKUP_COMPLAIN;
3756 flags |= LOOKUP_PREFER_TYPES;
3757 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3760 else if (is_aggr_type (scope, complain))
3761 t = lookup_member (scope, name, 2, is_type_p);
3764 return error_mark_node;
3768 /* Subroutine of unqualified_namespace_lookup:
3769 Add the bindings of NAME in used namespaces to VAL.
3770 We are currently looking for names in namespace SCOPE, so we
3771 look through USINGS for using-directives of namespaces
3772 which have SCOPE as a common ancestor with the current scope.
3773 Returns false on errors. */
3776 lookup_using_namespace (tree name, struct scope_binding *val,
3777 tree usings, tree scope, int flags)
3780 timevar_push (TV_NAME_LOOKUP);
3781 /* Iterate over all used namespaces in current, searching for using
3782 directives of scope. */
3783 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3784 if (TREE_VALUE (iter) == scope)
3786 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3788 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3789 /* Resolve ambiguities. */
3791 /* LLVM LOCAL mainline */
3792 ambiguous_decl (val, val1, flags);
3794 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3798 Accepts the NAME to lookup and its qualifying SCOPE.
3799 Returns the name/type pair found into the cxx_binding *RESULT,
3800 or false on error. */
3803 qualified_lookup_using_namespace (tree name, tree scope,
3804 struct scope_binding *result, int flags)
3806 /* Maintain a list of namespaces visited... */
3807 tree seen = NULL_TREE;
3808 /* ... and a list of namespace yet to see. */
3809 tree todo = NULL_TREE;
3810 tree todo_maybe = NULL_TREE;
3812 timevar_push (TV_NAME_LOOKUP);
3813 /* Look through namespace aliases. */
3814 scope = ORIGINAL_NAMESPACE (scope);
3815 while (scope && result->value != error_mark_node)
3817 cxx_binding *binding =
3818 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3819 seen = tree_cons (scope, NULL_TREE, seen);
3821 /* LLVM LOCAL mainline */
3822 ambiguous_decl (result, binding, flags);
3824 /* Consider strong using directives always, and non-strong ones
3825 if we haven't found a binding yet. ??? Shouldn't we consider
3826 non-strong ones if the initial RESULT is non-NULL, but the
3827 binding in the given namespace is? */
3828 for (usings = DECL_NAMESPACE_USING (scope); usings;
3829 usings = TREE_CHAIN (usings))
3830 /* If this was a real directive, and we have not seen it. */
3831 if (!TREE_INDIRECT_USING (usings))
3833 /* Try to avoid queuing the same namespace more than once,
3834 the exception being when a namespace was already
3835 enqueued for todo_maybe and then a strong using is
3836 found for it. We could try to remove it from
3837 todo_maybe, but it's probably not worth the effort. */
3838 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3839 && !purpose_member (TREE_PURPOSE (usings), seen)
3840 && !purpose_member (TREE_PURPOSE (usings), todo))
3841 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3842 else if ((!result->value && !result->type)
3843 && !purpose_member (TREE_PURPOSE (usings), seen)
3844 && !purpose_member (TREE_PURPOSE (usings), todo)
3845 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3846 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3851 scope = TREE_PURPOSE (todo);
3852 todo = TREE_CHAIN (todo);
3855 && (!result->value && !result->type))
3857 scope = TREE_PURPOSE (todo_maybe);
3858 todo = TREE_CHAIN (todo_maybe);
3859 todo_maybe = NULL_TREE;
3862 scope = NULL_TREE; /* If there never was a todo list. */
3864 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3867 /* Return the innermost non-namespace binding for NAME from a scope
3868 containing BINDING, or, if BINDING is NULL, the current scope. If
3869 CLASS_P is false, then class bindings are ignored. */
3872 outer_binding (tree name,
3873 cxx_binding *binding,
3878 cxx_scope *outer_scope;
3882 scope = binding->scope->level_chain;
3883 outer = binding->previous;
3887 scope = current_binding_level;
3888 outer = IDENTIFIER_BINDING (name);
3890 outer_scope = outer ? outer->scope : NULL;
3892 /* Because we create class bindings lazily, we might be missing a
3893 class binding for NAME. If there are any class binding levels
3894 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3895 declared, we must lookup NAME in those class scopes. */
3897 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3899 if (scope->kind == sk_class)
3901 cxx_binding *class_binding;
3903 class_binding = get_class_binding (name, scope);
3906 /* Thread this new class-scope binding onto the
3907 IDENTIFIER_BINDING list so that future lookups
3909 class_binding->previous = outer;
3911 binding->previous = class_binding;
3913 IDENTIFIER_BINDING (name) = class_binding;
3914 return class_binding;
3917 scope = scope->level_chain;
3923 /* Return the innermost block-scope or class-scope value binding for
3924 NAME, or NULL_TREE if there is no such binding. */
3927 innermost_non_namespace_value (tree name)
3929 cxx_binding *binding;
3930 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3931 return binding ? binding->value : NULL_TREE;
3934 /* Look up NAME in the current binding level and its superiors in the
3935 namespace of variables, functions and typedefs. Return a ..._DECL
3936 node of some kind representing its definition if there is only one
3937 such declaration, or return a TREE_LIST with all the overloaded
3938 definitions if there are many, or return 0 if it is undefined.
3939 Hidden name, either friend declaration or built-in function, are
3942 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3943 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3944 Otherwise we prefer non-TYPE_DECLs.
3946 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3947 BLOCK_P is false, bindings in block scopes are ignored. */
3950 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3951 int namespaces_only, int flags)
3954 tree val = NULL_TREE;
3956 timevar_push (TV_NAME_LOOKUP);
3957 /* Conversion operators are handled specially because ordinary
3958 unqualified name lookup will not find template conversion
3960 if (IDENTIFIER_TYPENAME_P (name))
3962 struct cp_binding_level *level;
3964 for (level = current_binding_level;
3965 level && level->kind != sk_namespace;
3966 level = level->level_chain)
3971 /* A conversion operator can only be declared in a class
3973 if (level->kind != sk_class)
3976 /* Lookup the conversion operator in the class. */
3977 class_type = level->this_entity;
3978 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3980 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3983 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3986 flags |= lookup_flags (prefer_type, namespaces_only);
3988 /* First, look in non-namespace scopes. */
3990 if (current_class_type == NULL_TREE)
3993 if (block_p || !nonclass)
3994 for (iter = outer_binding (name, NULL, !nonclass);
3996 iter = outer_binding (name, iter, !nonclass))
4000 /* Skip entities we don't want. */
4001 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4004 /* If this is the kind of thing we're looking for, we're done. */
4005 if (qualify_lookup (iter->value, flags))
4006 binding = iter->value;
4007 else if ((flags & LOOKUP_PREFER_TYPES)
4008 && qualify_lookup (iter->type, flags))
4009 binding = iter->type;
4011 binding = NULL_TREE;
4015 if (hidden_name_p (binding))
4017 /* A non namespace-scope binding can only be hidden if
4018 we are in a local class, due to friend declarations.
4019 In particular, consider:
4024 void g() { B* b; } // error: B is hidden
4029 The standard says that "B" is a local class in "f"
4030 (but not nested within "A") -- but that name lookup
4031 for "B" does not find this declaration until it is
4032 declared directly with "f".
4038 If a friend declaration appears in a local class and
4039 the name specified is an unqualified name, a prior
4040 declaration is looked up without considering scopes
4041 that are outside the innermost enclosing non-class
4042 scope. For a friend class declaration, if there is no
4043 prior declaration, the class that is specified
4044 belongs to the innermost enclosing non-class scope,
4045 but if it is subsequently referenced, its name is not
4046 found by name lookup until a matching declaration is
4047 provided in the innermost enclosing nonclass scope.
4049 gcc_assert (current_class_type &&
4050 LOCAL_CLASS_P (current_class_type));
4052 /* This binding comes from a friend declaration in the local
4053 class. The standard (11.4.8) states that the lookup can
4054 only succeed if there is a non-hidden declaration in the
4055 current scope, which is not the case here. */
4056 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4063 /* Now lookup in namespace scopes. */
4065 val = unqualified_namespace_lookup (name, flags);
4067 /* If we have a single function from a using decl, pull it out. */
4068 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4069 val = OVL_FUNCTION (val);
4071 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4075 lookup_name_nonclass (tree name)
4077 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4081 lookup_function_nonclass (tree name, tree args, bool block_p)
4084 lookup_arg_dependent (name,
4085 lookup_name_real (name, 0, 1, block_p, 0,
4091 lookup_name (tree name)
4093 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4097 lookup_name_prefer_type (tree name, int prefer_type)
4099 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4100 0, LOOKUP_COMPLAIN);
4103 /* Look up NAME for type used in elaborated name specifier in
4104 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4105 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4106 name, more scopes are checked if cleanup or template parameter
4107 scope is encountered.
4109 Unlike lookup_name_real, we make sure that NAME is actually
4110 declared in the desired scope, not from inheritance, nor using
4111 directive. For using declaration, there is DR138 still waiting
4112 to be resolved. Hidden name coming from an earlier friend
4113 declaration is also returned.
4115 A TYPE_DECL best matching the NAME is returned. Catching error
4116 and issuing diagnostics are caller's responsibility. */
4119 lookup_type_scope (tree name, tag_scope scope)
4121 cxx_binding *iter = NULL;
4122 tree val = NULL_TREE;
4124 timevar_push (TV_NAME_LOOKUP);
4126 /* Look in non-namespace scope first. */
4127 if (current_binding_level->kind != sk_namespace)
4128 iter = outer_binding (name, NULL, /*class_p=*/ true);
4129 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4131 /* Check if this is the kind of thing we're looking for.
4132 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4133 base class. For ITER->VALUE, we can simply use
4134 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4137 We check ITER->TYPE before ITER->VALUE in order to handle
4138 typedef struct C {} C;
4141 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4142 && (scope != ts_current
4143 || LOCAL_BINDING_P (iter)
4144 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4146 else if ((scope != ts_current
4147 || !INHERITED_VALUE_BINDING_P (iter))
4148 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4155 /* Look in namespace scope. */
4158 iter = cxx_scope_find_binding_for_name
4159 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4163 /* If this is the kind of thing we're looking for, we're done. */
4164 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4166 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4172 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4173 and template parameter scopes. */
4176 struct cp_binding_level *b = current_binding_level;
4179 if (iter->scope == b)
4180 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4182 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4184 else if (b->kind == sk_class
4185 && scope == ts_within_enclosing_non_class)
4192 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4195 /* Similar to `lookup_name' but look only in the innermost non-class
4199 lookup_name_innermost_nonclass_level (tree name)
4201 struct cp_binding_level *b;
4204 timevar_push (TV_NAME_LOOKUP);
4205 b = innermost_nonclass_level ();
4207 if (b->kind == sk_namespace)
4209 t = IDENTIFIER_NAMESPACE_VALUE (name);
4211 /* extern "C" function() */
4212 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4215 else if (IDENTIFIER_BINDING (name)
4216 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4218 cxx_binding *binding;
4219 binding = IDENTIFIER_BINDING (name);
4222 if (binding->scope == b
4223 && !(TREE_CODE (binding->value) == VAR_DECL
4224 && DECL_DEAD_FOR_LOCAL (binding->value)))
4225 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4227 if (b->kind == sk_cleanup)
4234 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4237 /* Like lookup_name_innermost_nonclass_level, but for types. */
4240 lookup_type_current_level (tree name)
4244 timevar_push (TV_NAME_LOOKUP);
4245 gcc_assert (current_binding_level->kind != sk_namespace);
4247 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4248 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4250 struct cp_binding_level *b = current_binding_level;
4253 if (purpose_member (name, b->type_shadowed))
4254 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4255 REAL_IDENTIFIER_TYPE_VALUE (name));
4256 if (b->kind == sk_cleanup)
4263 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4266 /* [basic.lookup.koenig] */
4267 /* A nonzero return value in the functions below indicates an error. */
4278 static bool arg_assoc (struct arg_lookup*, tree);
4279 static bool arg_assoc_args (struct arg_lookup*, tree);
4280 static bool arg_assoc_type (struct arg_lookup*, tree);
4281 static bool add_function (struct arg_lookup *, tree);
4282 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4283 static bool arg_assoc_class (struct arg_lookup *, tree);
4284 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4286 /* Add a function to the lookup structure.
4287 Returns true on error. */
4290 add_function (struct arg_lookup *k, tree fn)
4292 /* We used to check here to see if the function was already in the list,
4293 but that's O(n^2), which is just too expensive for function lookup.
4294 Now we deal with the occasional duplicate in joust. In doing this, we
4295 assume that the number of duplicates will be small compared to the
4296 total number of functions being compared, which should usually be the
4299 /* We must find only functions, or exactly one non-function. */
4302 else if (fn == k->functions)
4304 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4305 k->functions = build_overload (fn, k->functions);
4308 tree f1 = OVL_CURRENT (k->functions);
4310 if (is_overloaded_fn (f1))
4312 fn = f1; f1 = f2; f2 = fn;
4314 error ("%q+D is not a function,", f1);
4315 error (" conflict with %q+D", f2);
4316 error (" in call to %qD", k->name);
4323 /* Returns true iff CURRENT has declared itself to be an associated
4324 namespace of SCOPE via a strong using-directive (or transitive chain
4325 thereof). Both are namespaces. */
4328 is_associated_namespace (tree current, tree scope)
4330 tree seen = NULL_TREE;
4331 tree todo = NULL_TREE;
4335 if (scope == current)
4337 seen = tree_cons (scope, NULL_TREE, seen);
4338 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4339 if (!purpose_member (TREE_PURPOSE (t), seen))
4340 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4343 scope = TREE_PURPOSE (todo);
4344 todo = TREE_CHAIN (todo);
4351 /* Return whether FN is a friend of an associated class of ARG. */
4354 friend_of_associated_class_p (tree arg, tree fn)
4360 else if (type_unknown_p (arg))
4363 type = TREE_TYPE (arg);
4365 /* If TYPE is a class, the class itself and all base classes are
4366 associated classes. */
4367 if (CLASS_TYPE_P (type))
4369 if (is_friend (type, fn))
4372 if (TYPE_BINFO (type))
4374 tree binfo, base_binfo;
4377 for (binfo = TYPE_BINFO (type), i = 0;
4378 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4380 if (is_friend (BINFO_TYPE (base_binfo), fn))
4385 /* If TYPE is a class member, the class of which it is a member is
4386 an associated class. */
4387 if ((CLASS_TYPE_P (type)
4388 || TREE_CODE (type) == UNION_TYPE
4389 || TREE_CODE (type) == ENUMERAL_TYPE)
4390 && TYPE_CONTEXT (type)
4391 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4392 && is_friend (TYPE_CONTEXT (type), fn))
4398 /* Add functions of a namespace to the lookup structure.
4399 Returns true on error. */
4402 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4406 if (purpose_member (scope, k->namespaces))
4408 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4410 /* Check out our super-users. */
4411 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4412 value = TREE_CHAIN (value))
4413 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4416 value = namespace_binding (k->name, scope);
4420 for (; value; value = OVL_NEXT (value))
4422 /* We don't want to find arbitrary hidden functions via argument
4423 dependent lookup. We only want to find friends of associated
4425 if (hidden_name_p (OVL_CURRENT (value)))
4429 for (args = k->args; args; args = TREE_CHAIN (args))
4430 if (friend_of_associated_class_p (TREE_VALUE (args),
4431 OVL_CURRENT (value)))
4437 if (add_function (k, OVL_CURRENT (value)))
4444 /* Adds everything associated with a template argument to the lookup
4445 structure. Returns true on error. */
4448 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4450 /* [basic.lookup.koenig]
4452 If T is a template-id, its associated namespaces and classes are
4453 ... the namespaces and classes associated with the types of the
4454 template arguments provided for template type parameters
4455 (excluding template template parameters); the namespaces in which
4456 any template template arguments are defined; and the classes in
4457 which any member templates used as template template arguments
4458 are defined. [Note: non-type template arguments do not
4459 contribute to the set of associated namespaces. ] */
4461 /* Consider first template template arguments. */
4462 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4463 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4465 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4467 tree ctx = CP_DECL_CONTEXT (arg);
4469 /* It's not a member template. */
4470 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4471 return arg_assoc_namespace (k, ctx);
4472 /* Otherwise, it must be member template. */
4474 return arg_assoc_class (k, ctx);
4476 /* It's not a template template argument, but it is a type template
4478 else if (TYPE_P (arg))
4479 return arg_assoc_type (k, arg);
4480 /* It's a non-type template argument. */
4485 /* Adds everything associated with class to the lookup structure.
4486 Returns true on error. */
4489 arg_assoc_class (struct arg_lookup *k, tree type)
4491 tree list, friends, context;
4494 /* Backend build structures, such as __builtin_va_list, aren't
4495 affected by all this. */
4496 if (!CLASS_TYPE_P (type))
4499 if (purpose_member (type, k->classes))
4501 k->classes = tree_cons (type, NULL_TREE, k->classes);
4503 context = decl_namespace_context (type);
4504 if (arg_assoc_namespace (k, context))
4507 if (TYPE_BINFO (type))
4509 /* Process baseclasses. */
4510 tree binfo, base_binfo;
4512 for (binfo = TYPE_BINFO (type), i = 0;
4513 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4514 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4518 /* Process friends. */
4519 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4520 list = TREE_CHAIN (list))
4521 if (k->name == FRIEND_NAME (list))
4522 for (friends = FRIEND_DECLS (list); friends;
4523 friends = TREE_CHAIN (friends))
4525 tree fn = TREE_VALUE (friends);
4527 /* Only interested in global functions with potentially hidden
4528 (i.e. unqualified) declarations. */
4529 if (CP_DECL_CONTEXT (fn) != context)
4531 /* Template specializations are never found by name lookup.
4532 (Templates themselves can be found, but not template
4533 specializations.) */
4534 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4536 if (add_function (k, fn))
4540 /* Process template arguments. */
4541 if (CLASSTYPE_TEMPLATE_INFO (type)
4542 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4544 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4545 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4546 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4552 /* Adds everything associated with a given type.
4553 Returns 1 on error. */
4556 arg_assoc_type (struct arg_lookup *k, tree type)
4558 /* As we do not get the type of non-type dependent expressions
4559 right, we can end up with such things without a type. */
4563 if (TYPE_PTRMEM_P (type))
4565 /* Pointer to member: associate class type and value type. */
4566 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4568 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4570 else switch (TREE_CODE (type))
4582 if (TYPE_PTRMEMFUNC_P (type))
4583 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4584 return arg_assoc_class (k, type);
4586 case REFERENCE_TYPE:
4588 return arg_assoc_type (k, TREE_TYPE (type));
4591 return arg_assoc_namespace (k, decl_namespace_context (type));
4593 /* The basetype is referenced in the first arg type, so just
4596 /* Associate the parameter types. */
4597 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4599 /* Associate the return type. */
4600 return arg_assoc_type (k, TREE_TYPE (type));
4601 case TEMPLATE_TYPE_PARM:
4602 case BOUND_TEMPLATE_TEMPLATE_PARM:
4607 gcc_assert (type == unknown_type_node);
4615 /* Adds everything associated with arguments. Returns true on error. */
4618 arg_assoc_args (struct arg_lookup *k, tree args)
4620 for (; args; args = TREE_CHAIN (args))
4621 if (arg_assoc (k, TREE_VALUE (args)))
4626 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4629 arg_assoc (struct arg_lookup *k, tree n)
4631 if (n == error_mark_node)
4635 return arg_assoc_type (k, n);
4637 if (! type_unknown_p (n))
4638 return arg_assoc_type (k, TREE_TYPE (n));
4640 if (TREE_CODE (n) == ADDR_EXPR)
4641 n = TREE_OPERAND (n, 0);
4642 if (TREE_CODE (n) == COMPONENT_REF)
4643 n = TREE_OPERAND (n, 1);
4644 if (TREE_CODE (n) == OFFSET_REF)
4645 n = TREE_OPERAND (n, 1);
4646 while (TREE_CODE (n) == TREE_LIST)
4648 if (TREE_CODE (n) == BASELINK)
4649 n = BASELINK_FUNCTIONS (n);
4651 if (TREE_CODE (n) == FUNCTION_DECL)
4652 return arg_assoc_type (k, TREE_TYPE (n));
4653 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4655 /* [basic.lookup.koenig]
4657 If T is a template-id, its associated namespaces and classes
4658 are the namespace in which the template is defined; for
4659 member templates, the member template's class... */
4660 tree template = TREE_OPERAND (n, 0);
4661 tree args = TREE_OPERAND (n, 1);
4665 if (TREE_CODE (template) == COMPONENT_REF)
4666 template = TREE_OPERAND (template, 1);
4668 /* First, the template. There may actually be more than one if
4669 this is an overloaded function template. But, in that case,
4670 we only need the first; all the functions will be in the same
4672 template = OVL_CURRENT (template);
4674 ctx = CP_DECL_CONTEXT (template);
4676 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4678 if (arg_assoc_namespace (k, ctx) == 1)
4681 /* It must be a member template. */
4682 else if (arg_assoc_class (k, ctx) == 1)
4685 /* Now the arguments. */
4687 for (ix = TREE_VEC_LENGTH (args); ix--;)
4688 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4691 else if (TREE_CODE (n) == OVERLOAD)
4693 for (; n; n = OVL_CHAIN (n))
4694 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4701 /* Performs Koenig lookup depending on arguments, where fns
4702 are the functions found in normal lookup. */
4705 lookup_arg_dependent (tree name, tree fns, tree args)
4707 struct arg_lookup k;
4709 timevar_push (TV_NAME_LOOKUP);
4711 /* Remove any hidden friend functions from the list of functions
4712 found so far. They will be added back by arg_assoc_class as
4714 fns = remove_hidden_names (fns);
4719 k.classes = NULL_TREE;
4721 /* We previously performed an optimization here by setting
4722 NAMESPACES to the current namespace when it was safe. However, DR
4723 164 says that namespaces that were already searched in the first
4724 stage of template processing are searched again (potentially
4725 picking up later definitions) in the second stage. */
4726 k.namespaces = NULL_TREE;
4728 arg_assoc_args (&k, args);
4733 && TREE_CODE (fns) != VAR_DECL
4734 && !is_overloaded_fn (fns))
4736 error ("argument dependent lookup finds %q+D", fns);
4737 error (" in call to %qD", name);
4738 fns = error_mark_node;
4741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4744 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4745 changed (i.e. there was already a directive), or the fresh
4746 TREE_LIST otherwise. */
4749 push_using_directive (tree used)
4751 tree ud = current_binding_level->using_directives;
4752 tree iter, ancestor;
4754 timevar_push (TV_NAME_LOOKUP);
4755 /* Check if we already have this. */
4756 if (purpose_member (used, ud) != NULL_TREE)
4757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4759 ancestor = namespace_ancestor (current_decl_namespace (), used);
4760 ud = current_binding_level->using_directives;
4761 ud = tree_cons (used, ancestor, ud);
4762 current_binding_level->using_directives = ud;
4764 /* Recursively add all namespaces used. */
4765 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4766 push_using_directive (TREE_PURPOSE (iter));
4768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4771 /* The type TYPE is being declared. If it is a class template, or a
4772 specialization of a class template, do any processing required and
4773 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4774 being declared a friend. B is the binding level at which this TYPE
4777 Returns the TYPE_DECL for TYPE, which may have been altered by this
4781 maybe_process_template_type_declaration (tree type, int is_friend,
4784 tree decl = TYPE_NAME (type);
4786 if (processing_template_parmlist)
4787 /* You can't declare a new template type in a template parameter
4788 list. But, you can declare a non-template type:
4790 template <class A*> struct S;
4792 is a forward-declaration of `A'. */
4794 else if (b->kind == sk_namespace
4795 && current_binding_level->kind != sk_namespace)
4796 /* If this new type is being injected into a containing scope,
4797 then it's not a template type. */
4801 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4803 if (processing_template_decl)
4805 /* This may change after the call to
4806 push_template_decl_real, but we want the original value. */
4807 tree name = DECL_NAME (decl);
4809 decl = push_template_decl_real (decl, is_friend);
4810 /* If the current binding level is the binding level for the
4811 template parameters (see the comment in
4812 begin_template_parm_list) and the enclosing level is a class
4813 scope, and we're not looking at a friend, push the
4814 declaration of the member class into the class scope. In the
4815 friend case, push_template_decl will already have put the
4816 friend into global scope, if appropriate. */
4817 if (TREE_CODE (type) != ENUMERAL_TYPE
4818 && !is_friend && b->kind == sk_template_parms
4819 && b->level_chain->kind == sk_class)
4821 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4823 if (!COMPLETE_TYPE_P (current_class_type))
4825 maybe_add_class_template_decl_list (current_class_type,
4826 type, /*friend_p=*/0);
4827 /* Put this UTD in the table of UTDs for the class. */
4828 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4829 CLASSTYPE_NESTED_UTDS (current_class_type) =
4830 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4832 binding_table_insert
4833 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4842 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4843 that the NAME is a class template, the tag is processed but not pushed.
4845 The pushed scope depend on the SCOPE parameter:
4846 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4848 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4849 non-template-parameter scope. This case is needed for forward
4851 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4852 TS_GLOBAL case except that names within template-parameter scopes
4853 are not pushed at all.
4855 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4858 pushtag (tree name, tree type, tag_scope scope)
4860 struct cp_binding_level *b;
4863 timevar_push (TV_NAME_LOOKUP);
4864 b = current_binding_level;
4865 while (/* Cleanup scopes are not scopes from the point of view of
4867 b->kind == sk_cleanup
4868 /* Neither are the scopes used to hold template parameters
4869 for an explicit specialization. For an ordinary template
4870 declaration, these scopes are not scopes from the point of
4871 view of the language. */
4872 || (b->kind == sk_template_parms
4873 && (b->explicit_spec_p || scope == ts_global))
4874 || (b->kind == sk_class
4875 && (scope != ts_current
4876 /* We may be defining a new type in the initializer
4877 of a static member variable. We allow this when
4878 not pedantic, and it is particularly useful for
4879 type punning via an anonymous union. */
4880 || COMPLETE_TYPE_P (b->this_entity))))
4883 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4885 /* Do C++ gratuitous typedefing. */
4886 if (IDENTIFIER_TYPE_VALUE (name) != type)
4890 tree context = TYPE_CONTEXT (type);
4894 tree cs = current_scope ();
4896 if (scope == ts_current)
4898 else if (cs != NULL_TREE && TYPE_P (cs))
4899 /* When declaring a friend class of a local class, we want
4900 to inject the newly named class into the scope
4901 containing the local class, not the namespace
4903 context = decl_function_context (get_type_decl (cs));
4906 context = current_namespace;
4908 if (b->kind == sk_class
4909 || (b->kind == sk_template_parms
4910 && b->level_chain->kind == sk_class))
4913 if (current_lang_name == lang_name_java)
4914 TYPE_FOR_JAVA (type) = 1;
4916 tdef = create_implicit_typedef (name, type);
4917 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4918 if (scope == ts_within_enclosing_non_class)
4920 /* This is a friend. Make this TYPE_DECL node hidden from
4921 ordinary name lookup. Its corresponding TEMPLATE_DECL
4922 will be marked in push_template_decl_real. */
4923 retrofit_lang_decl (tdef);
4924 DECL_ANTICIPATED (tdef) = 1;
4925 DECL_FRIEND_P (tdef) = 1;
4928 decl = maybe_process_template_type_declaration
4929 (type, scope == ts_within_enclosing_non_class, b);
4930 if (decl == error_mark_node)
4931 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4934 set_identifier_type_value_with_scope (name, tdef, b);
4936 if (b->kind == sk_class)
4938 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4939 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4940 class. But if it's a member template class, we want
4941 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4943 finish_member_declaration (decl);
4945 pushdecl_class_level (decl);
4947 else if (b->kind != sk_template_parms)
4949 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4950 if (decl == error_mark_node)
4951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4954 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4956 /* If this is a local class, keep track of it. We need this
4957 information for name-mangling, and so that it is possible to
4958 find all function definitions in a translation unit in a
4959 convenient way. (It's otherwise tricky to find a member
4960 function definition it's only pointed to from within a local
4962 if (TYPE_CONTEXT (type)
4963 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4964 VEC_safe_push (tree, gc, local_classes, type);
4966 if (b->kind == sk_class
4967 && !COMPLETE_TYPE_P (current_class_type))
4969 maybe_add_class_template_decl_list (current_class_type,
4970 type, /*friend_p=*/0);
4972 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4973 CLASSTYPE_NESTED_UTDS (current_class_type)
4974 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4976 binding_table_insert
4977 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4980 decl = TYPE_NAME (type);
4981 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4982 TYPE_STUB_DECL (type) = decl;
4984 /* Set type visibility now if this is a forward declaration. */
4985 TREE_PUBLIC (decl) = 1;
4986 determine_visibility (decl);
4988 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4991 /* Subroutines for reverting temporarily to top-level for instantiation
4992 of templates and such. We actually need to clear out the class- and
4993 local-value slots of all identifiers, so that only the global values
4994 are at all visible. Simply setting current_binding_level to the global
4995 scope isn't enough, because more binding levels may be pushed. */
4996 struct saved_scope *scope_chain;
4998 /* If ID has not already been marked, add an appropriate binding to
5002 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5004 cxx_saved_binding *saved;
5006 if (!id || !IDENTIFIER_BINDING (id))
5009 if (IDENTIFIER_MARKED (id))
5012 IDENTIFIER_MARKED (id) = 1;
5014 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5015 saved->identifier = id;
5016 saved->binding = IDENTIFIER_BINDING (id);
5017 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5018 IDENTIFIER_BINDING (id) = NULL;
5022 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5026 timevar_push (TV_NAME_LOOKUP);
5027 for (t = names; t; t = TREE_CHAIN (t))
5031 if (TREE_CODE (t) == TREE_LIST)
5032 id = TREE_PURPOSE (t);
5036 store_binding (id, old_bindings);
5038 timevar_pop (TV_NAME_LOOKUP);
5041 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5042 objects, rather than a TREE_LIST. */
5045 store_class_bindings (VEC(cp_class_binding,gc) *names,
5046 VEC(cxx_saved_binding,gc) **old_bindings)
5049 cp_class_binding *cb;
5051 timevar_push (TV_NAME_LOOKUP);
5052 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5053 store_binding (cb->identifier, old_bindings);
5054 timevar_pop (TV_NAME_LOOKUP);
5058 push_to_top_level (void)
5060 struct saved_scope *s;
5061 struct cp_binding_level *b;
5062 cxx_saved_binding *sb;
5066 timevar_push (TV_NAME_LOOKUP);
5067 s = GGC_CNEW (struct saved_scope);
5069 b = scope_chain ? current_binding_level : 0;
5071 /* If we're in the middle of some function, save our state. */
5075 push_function_context_to (NULL_TREE);
5080 if (scope_chain && previous_class_level)
5081 store_class_bindings (previous_class_level->class_shadowed,
5084 /* Have to include the global scope, because class-scope decls
5085 aren't listed anywhere useful. */
5086 for (; b; b = b->level_chain)
5090 /* Template IDs are inserted into the global level. If they were
5091 inserted into namespace level, finish_file wouldn't find them
5092 when doing pending instantiations. Therefore, don't stop at
5093 namespace level, but continue until :: . */
5094 if (global_scope_p (b))
5097 store_bindings (b->names, &s->old_bindings);
5098 /* We also need to check class_shadowed to save class-level type
5099 bindings, since pushclass doesn't fill in b->names. */
5100 if (b->kind == sk_class)
5101 store_class_bindings (b->class_shadowed, &s->old_bindings);
5103 /* Unwind type-value slots back to top level. */
5104 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5105 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5108 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5109 IDENTIFIER_MARKED (sb->identifier) = 0;
5111 s->prev = scope_chain;
5113 s->need_pop_function_context = need_pop;
5114 s->function_decl = current_function_decl;
5115 s->skip_evaluation = skip_evaluation;
5118 current_function_decl = NULL_TREE;
5119 current_lang_base = VEC_alloc (tree, gc, 10);
5120 current_lang_name = lang_name_cplusplus;
5121 current_namespace = global_namespace;
5122 push_class_stack ();
5123 skip_evaluation = 0;
5124 timevar_pop (TV_NAME_LOOKUP);
5128 pop_from_top_level (void)
5130 struct saved_scope *s = scope_chain;
5131 cxx_saved_binding *saved;
5134 timevar_push (TV_NAME_LOOKUP);
5135 /* Clear out class-level bindings cache. */
5136 if (previous_class_level)
5137 invalidate_class_lookup_cache ();
5140 current_lang_base = 0;
5142 scope_chain = s->prev;
5143 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5145 tree id = saved->identifier;
5147 IDENTIFIER_BINDING (id) = saved->binding;
5148 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5151 /* If we were in the middle of compiling a function, restore our
5153 if (s->need_pop_function_context)
5154 pop_function_context_from (NULL_TREE);
5155 current_function_decl = s->function_decl;
5156 skip_evaluation = s->skip_evaluation;
5157 timevar_pop (TV_NAME_LOOKUP);
5160 /* Pop off extraneous binding levels left over due to syntax errors.
5162 We don't pop past namespaces, as they might be valid. */
5165 pop_everything (void)
5167 if (ENABLE_SCOPE_CHECKING)
5168 verbatim ("XXX entering pop_everything ()\n");
5169 while (!toplevel_bindings_p ())
5171 if (current_binding_level->kind == sk_class)
5172 pop_nested_class ();
5176 if (ENABLE_SCOPE_CHECKING)
5177 verbatim ("XXX leaving pop_everything ()\n");
5180 /* Emit debugging information for using declarations and directives.
5181 If input tree is overloaded fn then emit debug info for all
5185 cp_emit_debug_info_for_using (tree t, tree context)
5187 /* Don't try to emit any debug information if we have errors. */
5188 if (sorrycount || errorcount)
5191 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5192 of a builtin function. */
5193 if (TREE_CODE (t) == FUNCTION_DECL
5194 && DECL_EXTERNAL (t)
5195 && DECL_BUILT_IN (t))
5198 /* Do not supply context to imported_module_or_decl, if
5199 it is a global namespace. */
5200 if (context == global_namespace)
5201 context = NULL_TREE;
5204 t = BASELINK_FUNCTIONS (t);
5206 /* FIXME: Handle TEMPLATE_DECLs. */
5207 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5208 if (TREE_CODE (t) != TEMPLATE_DECL)
5209 (*debug_hooks->imported_module_or_decl) (t, context);
5212 #include "gt-cp-name-lookup.h"