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;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name(void)
68 if (!anonymous_namespace_name)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73 anonymous_namespace_name = get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable)) binding_entry free_binding_entry = NULL;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name, tree type)
99 if (free_binding_entry)
101 entry = free_binding_entry;
102 free_binding_entry = entry->chain;
105 entry = GGC_NEW (struct binding_entry_s);
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry)
121 entry->chain = free_binding_entry;
122 free_binding_entry = entry;
126 /* The datatype used to implement the mapping from names to types at
128 struct binding_table_s GTY(())
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 the member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = GGC_NEW (struct binding_table_s);
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = GGC_NEW (cxx_binding);
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 if (VEC_length (cp_class_binding, scope->class_shadowed))
324 cp_class_binding *old_base;
325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
328 /* Fixup the current bindings, as they might have moved. */
332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
336 b = &IDENTIFIER_BINDING (cb->identifier);
337 while (*b != &old_base[i].base)
338 b = &((*b)->previous);
342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
347 cb->identifier = name;
349 binding->scope = scope;
350 cxx_binding_init (binding, value, type);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id, tree decl, cxx_scope* level)
360 cxx_binding *binding;
362 if (level != class_binding_level)
364 binding = cxx_binding_make (decl, NULL_TREE);
365 binding->scope = level;
368 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
370 /* Now, fill in the binding information. */
371 binding->previous = IDENTIFIER_BINDING (id);
372 INHERITED_VALUE_BINDING_P (binding) = 0;
373 LOCAL_BINDING_P (binding) = (level != class_binding_level);
375 /* And put it on the front of the list of bindings for ID. */
376 IDENTIFIER_BINDING (id) = binding;
379 /* Remove the binding for DECL which should be the innermost binding
383 pop_binding (tree id, tree decl)
385 cxx_binding *binding;
388 /* It's easiest to write the loops that call this function without
389 checking whether or not the entities involved have names. We
390 get here for such an entity. */
393 /* Get the innermost binding for ID. */
394 binding = IDENTIFIER_BINDING (id);
396 /* The name should be bound. */
397 gcc_assert (binding != NULL);
399 /* The DECL will be either the ordinary binding or the type
400 binding for this identifier. Remove that binding. */
401 if (binding->value == decl)
402 binding->value = NULL_TREE;
405 gcc_assert (binding->type == decl);
406 binding->type = NULL_TREE;
409 if (!binding->value && !binding->type)
411 /* We're completely done with the innermost binding for this
412 identifier. Unhook it from the list of bindings. */
413 IDENTIFIER_BINDING (id) = binding->previous;
415 /* Add it to the free list. */
416 cxx_binding_free (binding);
420 /* BINDING records an existing declaration for a name in the current scope.
421 But, DECL is another declaration for that same identifier in the
422 same scope. This is the `struct stat' hack whereby a non-typedef
423 class name or enum-name can be bound at the same level as some other
427 A class name (9.1) or enumeration name (7.2) can be hidden by the
428 name of an object, function, or enumerator declared in the same scope.
429 If a class or enumeration name and an object, function, or enumerator
430 are declared in the same scope (in any order) with the same name, the
431 class or enumeration name is hidden wherever the object, function, or
432 enumerator name is visible.
434 It's the responsibility of the caller to check that
435 inserting this name is valid here. Returns nonzero if the new binding
439 supplement_binding (cxx_binding *binding, tree decl)
441 tree bval = binding->value;
444 timevar_push (TV_NAME_LOOKUP);
445 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
446 /* The new name is the type name. */
447 binding->type = decl;
448 else if (/* BVAL is null when push_class_level_binding moves an
449 inherited type-binding out of the way to make room for a
450 new value binding. */
452 /* BVAL is error_mark_node when DECL's name has been used
453 in a non-class scope prior declaration. In that case,
454 we should have already issued a diagnostic; for graceful
455 error recovery purpose, pretend this was the intended
456 declaration for that name. */
457 || bval == error_mark_node
458 /* If BVAL is anticipated but has not yet been declared,
459 pretend it is not there at all. */
460 || (TREE_CODE (bval) == FUNCTION_DECL
461 && DECL_ANTICIPATED (bval)
462 && !DECL_HIDDEN_FRIEND_P (bval)))
463 binding->value = decl;
464 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
466 /* The old binding was a type name. It was placed in
467 VALUE field because it was thought, at the point it was
468 declared, to be the only entity with such a name. Move the
469 type name into the type slot; it is now hidden by the new
471 binding->type = bval;
472 binding->value = decl;
473 binding->value_is_inherited = false;
475 else if (TREE_CODE (bval) == TYPE_DECL
476 && TREE_CODE (decl) == TYPE_DECL
477 && DECL_NAME (decl) == DECL_NAME (bval)
478 && binding->scope->kind != sk_class
479 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
480 /* If either type involves template parameters, we must
481 wait until instantiation. */
482 || uses_template_parms (TREE_TYPE (decl))
483 || uses_template_parms (TREE_TYPE (bval))))
484 /* We have two typedef-names, both naming the same type to have
485 the same name. In general, this is OK because of:
489 In a given scope, a typedef specifier can be used to redefine
490 the name of any type declared in that scope to refer to the
491 type to which it already refers.
493 However, in class scopes, this rule does not apply due to the
494 stricter language in [class.mem] prohibiting redeclarations of
497 /* There can be two block-scope declarations of the same variable,
498 so long as they are `extern' declarations. However, there cannot
499 be two declarations of the same static data member:
503 A member shall not be declared twice in the
504 member-specification. */
505 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
506 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
507 && !DECL_CLASS_SCOPE_P (decl))
509 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
512 else if (TREE_CODE (decl) == NAMESPACE_DECL
513 && TREE_CODE (bval) == NAMESPACE_DECL
514 && DECL_NAMESPACE_ALIAS (decl)
515 && DECL_NAMESPACE_ALIAS (bval)
516 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
519 In a declarative region, a namespace-alias-definition can be
520 used to redefine a namespace-alias declared in that declarative
521 region to refer only to the namespace to which it already
526 error ("declaration of %q#D", decl);
527 error ("conflicts with previous declaration %q+#D", bval);
531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
534 /* Add DECL to the list of things declared in B. */
537 add_decl_to_level (tree decl, cxx_scope *b)
539 if (TREE_CODE (decl) == NAMESPACE_DECL
540 && !DECL_NAMESPACE_ALIAS (decl))
542 TREE_CHAIN (decl) = b->namespaces;
543 b->namespaces = decl;
545 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
547 TREE_CHAIN (decl) = b->vtables;
552 /* We build up the list in reverse order, and reverse it later if
554 TREE_CHAIN (decl) = b->names;
558 /* If appropriate, add decl to separate list of statics. We
559 include extern variables because they might turn out to be
560 static later. It's OK for this list to contain a few false
562 if (b->kind == sk_namespace)
563 if ((TREE_CODE (decl) == VAR_DECL
564 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
565 || (TREE_CODE (decl) == FUNCTION_DECL
566 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
567 VEC_safe_push (tree, gc, b->static_decls, decl);
571 /* Record a decl-node X as belonging to the current lexical scope.
572 Check for errors (such as an incompatible declaration for the same
573 name already seen in the same scope). IS_FRIEND is true if X is
574 declared as a friend.
576 Returns either X or an old decl for the same name.
577 If an old decl is returned, it may have been smashed
578 to agree with what X says. */
581 pushdecl_maybe_friend (tree x, bool is_friend)
585 int need_new_binding;
587 timevar_push (TV_NAME_LOOKUP);
589 if (x == error_mark_node)
590 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
592 need_new_binding = 1;
594 if (DECL_TEMPLATE_PARM_P (x))
595 /* Template parameters have no context; they are not X::T even
596 when declared within a class or namespace. */
600 if (current_function_decl && x != current_function_decl
601 /* A local declaration for a function doesn't constitute
603 && TREE_CODE (x) != FUNCTION_DECL
604 /* A local declaration for an `extern' variable is in the
605 scope of the current namespace, not the current
607 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
608 && !DECL_CONTEXT (x))
609 DECL_CONTEXT (x) = current_function_decl;
611 /* If this is the declaration for a namespace-scope function,
612 but the declaration itself is in a local scope, mark the
614 if (TREE_CODE (x) == FUNCTION_DECL
615 && DECL_NAMESPACE_SCOPE_P (x)
616 && current_function_decl
617 && x != current_function_decl)
618 DECL_LOCAL_FUNCTION_P (x) = 1;
621 name = DECL_NAME (x);
624 int different_binding_level = 0;
626 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
627 name = TREE_OPERAND (name, 0);
629 /* In case this decl was explicitly namespace-qualified, look it
630 up in its namespace context. */
631 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
632 t = namespace_binding (name, DECL_CONTEXT (x));
634 t = lookup_name_innermost_nonclass_level (name);
636 /* [basic.link] If there is a visible declaration of an entity
637 with linkage having the same name and type, ignoring entities
638 declared outside the innermost enclosing namespace scope, the
639 block scope declaration declares that same entity and
640 receives the linkage of the previous declaration. */
641 if (! t && current_function_decl && x != current_function_decl
642 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
643 && DECL_EXTERNAL (x))
645 /* Look in block scope. */
646 t = innermost_non_namespace_value (name);
647 /* Or in the innermost namespace. */
649 t = namespace_binding (name, DECL_CONTEXT (x));
650 /* Does it have linkage? Note that if this isn't a DECL, it's an
651 OVERLOAD, which is OK. */
652 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
655 different_binding_level = 1;
658 /* If we are declaring a function, and the result of name-lookup
659 was an OVERLOAD, look for an overloaded instance that is
660 actually the same as the function we are declaring. (If
661 there is one, we have to merge our declaration with the
662 previous declaration.) */
663 if (t && TREE_CODE (t) == OVERLOAD)
667 if (TREE_CODE (x) == FUNCTION_DECL)
668 for (match = t; match; match = OVL_NEXT (match))
670 if (decls_match (OVL_CURRENT (match), x))
674 /* Just choose one. */
678 t = OVL_CURRENT (match);
683 if (t && t != error_mark_node)
685 if (different_binding_level)
687 if (decls_match (x, t))
688 /* The standard only says that the local extern
689 inherits linkage from the previous decl; in
690 particular, default args are not shared. Add
691 the decl into a hash table to make sure only
692 the previous decl in this case is seen by the
695 struct cxx_int_tree_map *h;
698 TREE_PUBLIC (x) = TREE_PUBLIC (t);
700 if (cp_function_chain->extern_decl_map == NULL)
701 cp_function_chain->extern_decl_map
702 = htab_create_ggc (20, cxx_int_tree_map_hash,
703 cxx_int_tree_map_eq, NULL);
705 h = GGC_NEW (struct cxx_int_tree_map);
706 h->uid = DECL_UID (x);
708 loc = htab_find_slot_with_hash
709 (cp_function_chain->extern_decl_map, h,
711 *(struct cxx_int_tree_map **) loc = h;
714 else if (TREE_CODE (t) == PARM_DECL)
716 gcc_assert (DECL_CONTEXT (t));
718 /* Check for duplicate params. */
719 if (duplicate_decls (x, t, is_friend))
720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
722 else if ((DECL_EXTERN_C_FUNCTION_P (x)
723 || DECL_FUNCTION_TEMPLATE_P (x))
724 && is_overloaded_fn (t))
725 /* Don't do anything just yet. */;
726 else if (t == wchar_decl_node)
728 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
729 pedwarn ("redeclaration of %<wchar_t%> as %qT",
732 /* Throw away the redeclaration. */
733 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
737 tree olddecl = duplicate_decls (x, t, is_friend);
739 /* If the redeclaration failed, we can stop at this
741 if (olddecl == error_mark_node)
742 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
746 if (TREE_CODE (t) == TYPE_DECL)
747 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
749 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
751 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
753 /* A redeclaration of main, but not a duplicate of the
758 This function shall not be overloaded. */
759 error ("invalid redeclaration of %q+D", t);
761 /* We don't try to push this declaration since that
763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
768 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
769 check_default_args (x);
771 check_template_shadow (x);
773 /* If this is a function conjured up by the back end, massage it
774 so it looks friendly. */
775 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
777 retrofit_lang_decl (x);
778 SET_DECL_LANGUAGE (x, lang_c);
781 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
783 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
785 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
786 if (!namespace_bindings_p ())
787 /* We do not need to create a binding for this name;
788 push_overloaded_decl will have already done so if
790 need_new_binding = 0;
792 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
794 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
796 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
797 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
800 /* If declaring a type as a typedef, copy the type (unless we're
801 at line 0), and install this TYPE_DECL as the new type's typedef
802 name. See the extensive comment in ../c-decl.c (pushdecl). */
803 if (TREE_CODE (x) == TYPE_DECL)
805 tree type = TREE_TYPE (x);
806 if (DECL_IS_BUILTIN (x))
808 if (TYPE_NAME (type) == 0)
809 TYPE_NAME (type) = x;
811 else if (type != error_mark_node && TYPE_NAME (type) != x
812 /* We don't want to copy the type when all we're
813 doing is making a TYPE_DECL for the purposes of
815 && (!TYPE_NAME (type)
816 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
818 DECL_ORIGINAL_TYPE (x) = type;
819 type = build_variant_type_copy (type);
820 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
821 TYPE_NAME (type) = x;
822 TREE_TYPE (x) = type;
825 if (type != error_mark_node
827 && TYPE_IDENTIFIER (type))
828 set_identifier_type_value (DECL_NAME (x), x);
831 /* Multiple external decls of the same identifier ought to match.
833 We get warnings about inline functions where they are defined.
834 We get warnings about other functions from push_overloaded_decl.
836 Avoid duplicate warnings where they are used. */
837 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
841 decl = IDENTIFIER_NAMESPACE_VALUE (name);
842 if (decl && TREE_CODE (decl) == OVERLOAD)
843 decl = OVL_FUNCTION (decl);
845 if (decl && decl != error_mark_node
846 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
847 /* If different sort of thing, we already gave an error. */
848 && TREE_CODE (decl) == TREE_CODE (x)
849 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
851 pedwarn ("type mismatch with previous external decl of %q#D", x);
852 pedwarn ("previous external decl of %q+#D", decl);
856 if (TREE_CODE (x) == FUNCTION_DECL
858 && !flag_friend_injection)
860 /* This is a new declaration of a friend function, so hide
861 it from ordinary function lookup. */
862 DECL_ANTICIPATED (x) = 1;
863 DECL_HIDDEN_FRIEND_P (x) = 1;
866 /* This name is new in its binding level.
867 Install the new declaration and return it. */
868 if (namespace_bindings_p ())
870 /* Install a global value. */
872 /* If the first global decl has external linkage,
873 warn if we later see static one. */
874 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
875 TREE_PUBLIC (name) = 1;
877 /* Bind the name for the entity. */
878 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
880 && (TREE_CODE (x) == TYPE_DECL
881 || TREE_CODE (x) == VAR_DECL
882 || TREE_CODE (x) == NAMESPACE_DECL
883 || TREE_CODE (x) == CONST_DECL
884 || TREE_CODE (x) == TEMPLATE_DECL))
885 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
887 /* If new decl is `static' and an `extern' was seen previously,
889 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
890 warn_extern_redeclared_static (x, t);
894 /* Here to install a non-global value. */
895 tree oldlocal = innermost_non_namespace_value (name);
896 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
898 if (need_new_binding)
900 push_local_binding (name, x, 0);
901 /* Because push_local_binding will hook X on to the
902 current_binding_level's name list, we don't want to
903 do that again below. */
904 need_new_binding = 0;
907 /* If this is a TYPE_DECL, push it into the type value slot. */
908 if (TREE_CODE (x) == TYPE_DECL)
909 set_identifier_type_value (name, x);
911 /* Clear out any TYPE_DECL shadowed by a namespace so that
912 we won't think this is a type. The C struct hack doesn't
913 go through namespaces. */
914 if (TREE_CODE (x) == NAMESPACE_DECL)
915 set_identifier_type_value (name, NULL_TREE);
922 && TREE_CODE (oldlocal) == VAR_DECL
923 && DECL_DEAD_FOR_LOCAL (oldlocal))
924 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
926 if (oldlocal == NULL_TREE)
927 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
930 /* If this is an extern function declaration, see if we
931 have a global definition or declaration for the function. */
932 if (oldlocal == NULL_TREE
934 && oldglobal != NULL_TREE
935 && TREE_CODE (x) == FUNCTION_DECL
936 && TREE_CODE (oldglobal) == FUNCTION_DECL)
938 /* We have one. Their types must agree. */
939 if (decls_match (x, oldglobal))
943 warning (0, "extern declaration of %q#D doesn't match", x);
944 warning (0, "global declaration %q+#D", oldglobal);
947 /* If we have a local external declaration,
948 and no file-scope declaration has yet been seen,
949 then if we later have a file-scope decl it must not be static. */
950 if (oldlocal == NULL_TREE
951 && oldglobal == NULL_TREE
954 TREE_PUBLIC (name) = 1;
956 /* Warn if shadowing an argument at the top level of the body. */
957 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
958 /* Inline decls shadow nothing. */
959 && !DECL_FROM_INLINE (x)
960 && TREE_CODE (oldlocal) == PARM_DECL
961 /* Don't check the `this' parameter. */
962 && !DECL_ARTIFICIAL (oldlocal))
966 /* Don't complain if it's from an enclosing function. */
967 if (DECL_CONTEXT (oldlocal) == current_function_decl
968 && TREE_CODE (x) != PARM_DECL)
970 /* Go to where the parms should be and see if we find
972 struct cp_binding_level *b = current_binding_level->level_chain;
974 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
975 /* Skip the ctor/dtor cleanup level. */
979 if (b->kind == sk_function_parms)
981 error ("declaration of %q#D shadows a parameter", x);
986 if (warn_shadow && !err)
988 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
989 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
993 /* Maybe warn if shadowing something else. */
994 else if (warn_shadow && !DECL_EXTERNAL (x)
995 /* No shadow warnings for internally generated vars. */
996 && ! DECL_ARTIFICIAL (x)
997 /* No shadow warnings for vars made for inlining. */
998 && ! DECL_FROM_INLINE (x))
1002 if (current_class_ptr)
1003 member = lookup_member (current_class_type,
1006 /*want_type=*/false);
1010 if (member && !TREE_STATIC (member))
1012 /* Location of previous decl is not useful in this case. */
1013 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1016 else if (oldlocal != NULL_TREE
1017 && TREE_CODE (oldlocal) == VAR_DECL)
1019 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1020 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1022 else if (oldglobal != NULL_TREE
1023 && TREE_CODE (oldglobal) == VAR_DECL)
1024 /* XXX shadow warnings in outer-more namespaces */
1026 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1028 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1033 if (TREE_CODE (x) == VAR_DECL)
1034 maybe_register_incomplete_var (x);
1037 if (need_new_binding)
1038 add_decl_to_level (x,
1039 DECL_NAMESPACE_SCOPE_P (x)
1040 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1041 : current_binding_level);
1043 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1046 /* Record a decl-node X as belonging to the current lexical scope. */
1051 return pushdecl_maybe_friend (x, false);
1054 /* Enter DECL into the symbol table, if that's appropriate. Returns
1055 DECL, or a modified version thereof. */
1058 maybe_push_decl (tree decl)
1060 tree type = TREE_TYPE (decl);
1062 /* Add this decl to the current binding level, but not if it comes
1063 from another scope, e.g. a static member variable. TEM may equal
1064 DECL or it may be a previous decl of the same name. */
1065 if (decl == error_mark_node
1066 || (TREE_CODE (decl) != PARM_DECL
1067 && DECL_CONTEXT (decl) != NULL_TREE
1068 /* Definitions of namespace members outside their namespace are
1070 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1071 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1072 || TREE_CODE (type) == UNKNOWN_TYPE
1073 /* The declaration of a template specialization does not affect
1074 the functions available for overload resolution, so we do not
1076 || (TREE_CODE (decl) == FUNCTION_DECL
1077 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1080 return pushdecl (decl);
1083 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1084 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1085 doesn't really belong to this binding level, that it got here
1086 through a using-declaration. */
1089 push_local_binding (tree id, tree decl, int flags)
1091 struct cp_binding_level *b;
1093 /* Skip over any local classes. This makes sense if we call
1094 push_local_binding with a friend decl of a local class. */
1095 b = innermost_nonclass_level ();
1097 if (lookup_name_innermost_nonclass_level (id))
1099 /* Supplement the existing binding. */
1100 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1101 /* It didn't work. Something else must be bound at this
1102 level. Do not add DECL to the list of things to pop
1107 /* Create a new binding. */
1108 push_binding (id, decl, b);
1110 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1111 /* We must put the OVERLOAD into a TREE_LIST since the
1112 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1113 decls that got here through a using-declaration. */
1114 decl = build_tree_list (NULL_TREE, decl);
1116 /* And put DECL on the list of things declared by the current
1118 add_decl_to_level (decl, b);
1121 /* Check to see whether or not DECL is a variable that would have been
1122 in scope under the ARM, but is not in scope under the ANSI/ISO
1123 standard. If so, issue an error message. If name lookup would
1124 work in both cases, but return a different result, this function
1125 returns the result of ANSI/ISO lookup. Otherwise, it returns
1129 check_for_out_of_scope_variable (tree decl)
1133 /* We only care about out of scope variables. */
1134 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1137 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1138 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1139 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1140 && DECL_DEAD_FOR_LOCAL (shadowed))
1141 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1142 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1144 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1147 if (!DECL_ERROR_REPORTED (decl))
1149 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1150 warning (0, " matches this %q+D under ISO standard rules",
1152 warning (0, " matches this %q+D under old rules", decl);
1153 DECL_ERROR_REPORTED (decl) = 1;
1158 /* If we have already complained about this declaration, there's no
1159 need to do it again. */
1160 if (DECL_ERROR_REPORTED (decl))
1163 DECL_ERROR_REPORTED (decl) = 1;
1165 if (TREE_TYPE (decl) == error_mark_node)
1168 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1170 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1172 error (" cannot use obsolete binding at %q+D because "
1173 "it has a destructor", decl);
1174 return error_mark_node;
1178 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1180 pedwarn (" using obsolete binding at %q+D", decl);
1186 /* true means unconditionally make a BLOCK for the next level pushed. */
1188 static bool keep_next_level_flag;
1190 static int binding_depth = 0;
1191 static int is_class_level = 0;
1198 for (i = 0; i < depth * 2; i++)
1202 /* Return a string describing the kind of SCOPE we have. */
1204 cxx_scope_descriptor (cxx_scope *scope)
1206 /* The order of this table must match the "scope_kind"
1208 static const char* scope_kind_names[] = {
1214 "function-parameter-scope",
1217 "template-parameter-scope",
1218 "template-explicit-spec-scope"
1220 const scope_kind kind = scope->explicit_spec_p
1221 ? sk_template_spec : scope->kind;
1223 return scope_kind_names[kind];
1226 /* Output a debugging information about SCOPE when performing
1229 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1231 const char *desc = cxx_scope_descriptor (scope);
1232 if (scope->this_entity)
1233 verbatim ("%s %s(%E) %p %d\n", action, desc,
1234 scope->this_entity, (void *) scope, line);
1236 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1239 /* Return the estimated initial size of the hashtable of a NAMESPACE
1242 static inline size_t
1243 namespace_scope_ht_size (tree ns)
1245 tree name = DECL_NAME (ns);
1247 return name == std_identifier
1248 ? NAMESPACE_STD_HT_SIZE
1249 : (name == global_scope_name
1250 ? GLOBAL_SCOPE_HT_SIZE
1251 : NAMESPACE_ORDINARY_HT_SIZE);
1254 /* A chain of binding_level structures awaiting reuse. */
1256 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1258 /* Insert SCOPE as the innermost binding level. */
1261 push_binding_level (struct cp_binding_level *scope)
1263 /* Add it to the front of currently active scopes stack. */
1264 scope->level_chain = current_binding_level;
1265 current_binding_level = scope;
1266 keep_next_level_flag = false;
1268 if (ENABLE_SCOPE_CHECKING)
1270 scope->binding_depth = binding_depth;
1271 indent (binding_depth);
1272 cxx_scope_debug (scope, input_line, "push");
1278 /* Create a new KIND scope and make it the top of the active scopes stack.
1279 ENTITY is the scope of the associated C++ entity (namespace, class,
1280 function); it is NULL otherwise. */
1283 begin_scope (scope_kind kind, tree entity)
1287 /* Reuse or create a struct for this binding level. */
1288 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1290 scope = free_binding_level;
1291 memset (scope, 0, sizeof (cxx_scope));
1292 free_binding_level = scope->level_chain;
1295 scope = GGC_CNEW (cxx_scope);
1297 scope->this_entity = entity;
1298 scope->more_cleanups_ok = true;
1305 case sk_template_spec:
1306 scope->explicit_spec_p = true;
1307 kind = sk_template_parms;
1309 case sk_template_parms:
1315 case sk_function_parms:
1317 scope->keep = keep_next_level_flag;
1321 NAMESPACE_LEVEL (entity) = scope;
1322 scope->static_decls =
1323 VEC_alloc (tree, gc,
1324 DECL_NAME (entity) == std_identifier
1325 || DECL_NAME (entity) == global_scope_name
1330 /* Should not happen. */
1336 push_binding_level (scope);
1341 /* We're about to leave current scope. Pop the top of the stack of
1342 currently active scopes. Return the enclosing scope, now active. */
1347 cxx_scope *scope = current_binding_level;
1349 if (scope->kind == sk_namespace && class_binding_level)
1350 current_binding_level = class_binding_level;
1352 /* We cannot leave a scope, if there are none left. */
1353 if (NAMESPACE_LEVEL (global_namespace))
1354 gcc_assert (!global_scope_p (scope));
1356 if (ENABLE_SCOPE_CHECKING)
1358 indent (--binding_depth);
1359 cxx_scope_debug (scope, input_line, "leave");
1360 if (is_class_level != (scope == class_binding_level))
1362 indent (binding_depth);
1363 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1368 #ifdef HANDLE_PRAGMA_VISIBILITY
1369 if (scope->has_visibility)
1373 /* Move one nesting level up. */
1374 current_binding_level = scope->level_chain;
1376 /* Namespace-scopes are left most probably temporarily, not
1377 completely; they can be reopened later, e.g. in namespace-extension
1378 or any name binding activity that requires us to resume a
1379 namespace. For classes, we cache some binding levels. For other
1380 scopes, we just make the structure available for reuse. */
1381 if (scope->kind != sk_namespace
1382 && scope->kind != sk_class)
1384 scope->level_chain = free_binding_level;
1385 gcc_assert (!ENABLE_SCOPE_CHECKING
1386 || scope->binding_depth == binding_depth);
1387 free_binding_level = scope;
1390 /* Find the innermost enclosing class scope, and reset
1391 CLASS_BINDING_LEVEL appropriately. */
1392 if (scope->kind == sk_class)
1394 class_binding_level = NULL;
1395 for (scope = current_binding_level; scope; scope = scope->level_chain)
1396 if (scope->kind == sk_class)
1398 class_binding_level = scope;
1403 return current_binding_level;
1407 resume_scope (struct cp_binding_level* b)
1409 /* Resuming binding levels is meant only for namespaces,
1410 and those cannot nest into classes. */
1411 gcc_assert (!class_binding_level);
1412 /* Also, resuming a non-directly nested namespace is a no-no. */
1413 gcc_assert (b->level_chain == current_binding_level);
1414 current_binding_level = b;
1415 if (ENABLE_SCOPE_CHECKING)
1417 b->binding_depth = binding_depth;
1418 indent (binding_depth);
1419 cxx_scope_debug (b, input_line, "resume");
1425 /* Return the innermost binding level that is not for a class scope. */
1428 innermost_nonclass_level (void)
1432 b = current_binding_level;
1433 while (b->kind == sk_class)
1439 /* We're defining an object of type TYPE. If it needs a cleanup, but
1440 we're not allowed to add any more objects with cleanups to the current
1441 scope, create a new binding level. */
1444 maybe_push_cleanup_level (tree type)
1446 if (type != error_mark_node
1447 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1448 && current_binding_level->more_cleanups_ok == 0)
1450 begin_scope (sk_cleanup, NULL);
1451 current_binding_level->statement_list = push_stmt_list ();
1455 /* Nonzero if we are currently in the global binding level. */
1458 global_bindings_p (void)
1460 return global_scope_p (current_binding_level);
1463 /* True if we are currently in a toplevel binding level. This
1464 means either the global binding level or a namespace in a toplevel
1465 binding level. Since there are no non-toplevel namespace levels,
1466 this really means any namespace or template parameter level. We
1467 also include a class whose context is toplevel. */
1470 toplevel_bindings_p (void)
1472 struct cp_binding_level *b = innermost_nonclass_level ();
1474 return b->kind == sk_namespace || b->kind == sk_template_parms;
1477 /* True if this is a namespace scope, or if we are defining a class
1478 which is itself at namespace scope, or whose enclosing class is
1479 such a class, etc. */
1482 namespace_bindings_p (void)
1484 struct cp_binding_level *b = innermost_nonclass_level ();
1486 return b->kind == sk_namespace;
1489 /* True if the current level needs to have a BLOCK made. */
1494 return (current_binding_level->blocks != NULL_TREE
1495 || current_binding_level->keep
1496 || current_binding_level->kind == sk_cleanup
1497 || current_binding_level->names != NULL_TREE);
1500 /* Returns the kind of the innermost scope. */
1503 innermost_scope_kind (void)
1505 return current_binding_level->kind;
1508 /* Returns true if this scope was created to store template parameters. */
1511 template_parm_scope_p (void)
1513 return innermost_scope_kind () == sk_template_parms;
1516 /* If KEEP is true, make a BLOCK node for the next binding level,
1517 unconditionally. Otherwise, use the normal logic to decide whether
1518 or not to create a BLOCK. */
1521 keep_next_level (bool keep)
1523 keep_next_level_flag = keep;
1526 /* Return the list of declarations of the current level.
1527 Note that this list is in reverse order unless/until
1528 you nreverse it; and when you do nreverse it, you must
1529 store the result back using `storedecls' or you will lose. */
1534 return current_binding_level->names;
1537 /* For debugging. */
1538 static int no_print_functions = 0;
1539 static int no_print_builtins = 0;
1542 print_binding_level (struct cp_binding_level* lvl)
1546 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1547 if (lvl->more_cleanups_ok)
1548 fprintf (stderr, " more-cleanups-ok");
1549 if (lvl->have_cleanups)
1550 fprintf (stderr, " have-cleanups");
1551 fprintf (stderr, "\n");
1554 fprintf (stderr, " names:\t");
1555 /* We can probably fit 3 names to a line? */
1556 for (t = lvl->names; t; t = TREE_CHAIN (t))
1558 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1560 if (no_print_builtins
1561 && (TREE_CODE (t) == TYPE_DECL)
1562 && DECL_IS_BUILTIN (t))
1565 /* Function decls tend to have longer names. */
1566 if (TREE_CODE (t) == FUNCTION_DECL)
1573 fprintf (stderr, "\n\t");
1576 print_node_brief (stderr, "", t, 0);
1577 if (t == error_mark_node)
1581 fprintf (stderr, "\n");
1583 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1586 cp_class_binding *b;
1587 fprintf (stderr, " class-shadowed:");
1589 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1591 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1592 fprintf (stderr, "\n");
1594 if (lvl->type_shadowed)
1596 fprintf (stderr, " type-shadowed:");
1597 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1599 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1601 fprintf (stderr, "\n");
1606 print_other_binding_stack (struct cp_binding_level *stack)
1608 struct cp_binding_level *level;
1609 for (level = stack; !global_scope_p (level); level = level->level_chain)
1611 fprintf (stderr, "binding level %p\n", (void *) level);
1612 print_binding_level (level);
1617 print_binding_stack (void)
1619 struct cp_binding_level *b;
1620 fprintf (stderr, "current_binding_level=%p\n"
1621 "class_binding_level=%p\n"
1622 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1623 (void *) current_binding_level, (void *) class_binding_level,
1624 (void *) NAMESPACE_LEVEL (global_namespace));
1625 if (class_binding_level)
1627 for (b = class_binding_level; b; b = b->level_chain)
1628 if (b == current_binding_level)
1631 b = class_binding_level;
1633 b = current_binding_level;
1636 b = current_binding_level;
1637 print_other_binding_stack (b);
1638 fprintf (stderr, "global:\n");
1639 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1642 /* Return the type associated with id. */
1645 identifier_type_value (tree id)
1647 timevar_push (TV_NAME_LOOKUP);
1648 /* There is no type with that name, anywhere. */
1649 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1650 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1651 /* This is not the type marker, but the real thing. */
1652 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1653 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1654 /* Have to search for it. It must be on the global level, now.
1655 Ask lookup_name not to return non-types. */
1656 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1662 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1663 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1666 identifier_global_value (tree t)
1668 return IDENTIFIER_GLOBAL_VALUE (t);
1671 /* Push a definition of struct, union or enum tag named ID. into
1672 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1673 the tag ID is not already defined. */
1676 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1680 if (b->kind != sk_namespace)
1682 /* Shadow the marker, not the real thing, so that the marker
1683 gets restored later. */
1684 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1686 = tree_cons (id, old_type_value, b->type_shadowed);
1687 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1688 TREE_TYPE (b->type_shadowed) = type;
1692 cxx_binding *binding =
1693 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1696 supplement_binding (binding, decl);
1698 binding->value = decl;
1700 /* Store marker instead of real type. */
1701 type = global_type_node;
1703 SET_IDENTIFIER_TYPE_VALUE (id, type);
1706 /* As set_identifier_type_value_with_scope, but using
1707 current_binding_level. */
1710 set_identifier_type_value (tree id, tree decl)
1712 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1715 /* Return the name for the constructor (or destructor) for the
1716 specified class TYPE. When given a template, this routine doesn't
1717 lose the specialization. */
1720 constructor_name_full (tree type)
1722 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1725 /* Return the name for the constructor (or destructor) for the
1726 specified class. When given a template, return the plain
1727 unspecialized name. */
1730 constructor_name (tree type)
1733 name = constructor_name_full (type);
1734 if (IDENTIFIER_TEMPLATE (name))
1735 name = IDENTIFIER_TEMPLATE (name);
1739 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1742 constructor_name_p (tree name, tree type)
1749 if (TREE_CODE (name) != IDENTIFIER_NODE)
1752 ctor_name = constructor_name_full (type);
1753 if (name == ctor_name)
1755 if (IDENTIFIER_TEMPLATE (ctor_name)
1756 && name == IDENTIFIER_TEMPLATE (ctor_name))
1761 /* Counter used to create anonymous type names. */
1763 static GTY(()) int anon_cnt;
1765 /* Return an IDENTIFIER which can be used as a name for
1766 anonymous structs and unions. */
1769 make_anon_name (void)
1773 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1774 return get_identifier (buf);
1777 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1779 static inline cxx_binding *
1780 find_binding (cxx_scope *scope, cxx_binding *binding)
1782 timevar_push (TV_NAME_LOOKUP);
1784 for (; binding != NULL; binding = binding->previous)
1785 if (binding->scope == scope)
1786 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1791 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1793 static inline cxx_binding *
1794 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1796 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1799 /* Fold-in case where NAME is used only once. */
1800 if (scope == b->scope && b->previous == NULL)
1802 return find_binding (scope, b);
1807 /* Always returns a binding for name in scope. If no binding is
1808 found, make a new one. */
1810 static cxx_binding *
1811 binding_for_name (cxx_scope *scope, tree name)
1813 cxx_binding *result;
1815 result = cxx_scope_find_binding_for_name (scope, name);
1818 /* Not found, make a new one. */
1819 result = cxx_binding_make (NULL, NULL);
1820 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1821 result->scope = scope;
1822 result->is_local = false;
1823 result->value_is_inherited = false;
1824 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1828 /* Insert another USING_DECL into the current binding level, returning
1829 this declaration. If this is a redeclaration, do nothing, and
1830 return NULL_TREE if this not in namespace scope (in namespace
1831 scope, a using decl might extend any previous bindings). */
1834 push_using_decl (tree scope, tree name)
1838 timevar_push (TV_NAME_LOOKUP);
1839 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1840 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1841 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1842 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1845 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1846 namespace_bindings_p () ? decl : NULL_TREE);
1847 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1848 USING_DECL_SCOPE (decl) = scope;
1849 TREE_CHAIN (decl) = current_binding_level->usings;
1850 current_binding_level->usings = decl;
1851 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1854 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1855 caller to set DECL_CONTEXT properly. */
1858 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1860 struct cp_binding_level *b;
1861 tree function_decl = current_function_decl;
1863 timevar_push (TV_NAME_LOOKUP);
1864 current_function_decl = NULL_TREE;
1865 if (level->kind == sk_class)
1867 b = class_binding_level;
1868 class_binding_level = level;
1869 pushdecl_class_level (x);
1870 class_binding_level = b;
1874 b = current_binding_level;
1875 current_binding_level = level;
1876 x = pushdecl_maybe_friend (x, is_friend);
1877 current_binding_level = b;
1879 current_function_decl = function_decl;
1880 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1883 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1884 other definitions already in place. We get around this by making
1885 the value of the identifier point to a list of all the things that
1886 want to be referenced by that name. It is then up to the users of
1887 that name to decide what to do with that list.
1889 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1890 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1892 FLAGS is a bitwise-or of the following values:
1893 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1895 PUSH_USING: DECL is being pushed as the result of a using
1898 IS_FRIEND is true if this is a friend declaration.
1900 The value returned may be a previous declaration if we guessed wrong
1901 about what language DECL should belong to (C or C++). Otherwise,
1902 it's always DECL (and never something that's not a _DECL). */
1905 push_overloaded_decl (tree decl, int flags, bool is_friend)
1907 tree name = DECL_NAME (decl);
1910 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1912 timevar_push (TV_NAME_LOOKUP);
1914 old = namespace_binding (name, DECL_CONTEXT (decl));
1916 old = lookup_name_innermost_nonclass_level (name);
1920 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1922 tree t = TREE_TYPE (old);
1923 if (IS_AGGR_TYPE (t) && warn_shadow
1924 && (! DECL_IN_SYSTEM_HEADER (decl)
1925 || ! DECL_IN_SYSTEM_HEADER (old)))
1926 warning (0, "%q#D hides constructor for %q#T", decl, t);
1929 else if (is_overloaded_fn (old))
1933 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1935 tree fn = OVL_CURRENT (tmp);
1938 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1939 && !(flags & PUSH_USING)
1940 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1941 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1942 && ! decls_match (fn, decl))
1943 error ("%q#D conflicts with previous using declaration %q#D",
1946 dup = duplicate_decls (decl, fn, is_friend);
1947 /* If DECL was a redeclaration of FN -- even an invalid
1948 one -- pass that information along to our caller. */
1949 if (dup == fn || dup == error_mark_node)
1950 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1953 /* We don't overload implicit built-ins. duplicate_decls()
1954 may fail to merge the decls if the new decl is e.g. a
1955 template function. */
1956 if (TREE_CODE (old) == FUNCTION_DECL
1957 && DECL_ANTICIPATED (old)
1958 && !DECL_HIDDEN_FRIEND_P (old))
1961 else if (old == error_mark_node)
1962 /* Ignore the undefined symbol marker. */
1966 error ("previous non-function declaration %q+#D", old);
1967 error ("conflicts with function declaration %q#D", decl);
1968 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1972 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1973 /* If it's a using declaration, we always need to build an OVERLOAD,
1974 because it's the only way to remember that the declaration comes
1975 from 'using', and have the lookup behave correctly. */
1976 || (flags & PUSH_USING))
1978 if (old && TREE_CODE (old) != OVERLOAD)
1979 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1981 new_binding = ovl_cons (decl, old);
1982 if (flags & PUSH_USING)
1983 OVL_USED (new_binding) = 1;
1986 /* NAME is not ambiguous. */
1990 set_namespace_binding (name, current_namespace, new_binding);
1993 /* We only create an OVERLOAD if there was a previous binding at
1994 this level, or if decl is a template. In the former case, we
1995 need to remove the old binding and replace it with the new
1996 binding. We must also run through the NAMES on the binding
1997 level where the name was bound to update the chain. */
1999 if (TREE_CODE (new_binding) == OVERLOAD && old)
2003 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2005 d = &TREE_CHAIN (*d))
2007 || (TREE_CODE (*d) == TREE_LIST
2008 && TREE_VALUE (*d) == old))
2010 if (TREE_CODE (*d) == TREE_LIST)
2011 /* Just replace the old binding with the new. */
2012 TREE_VALUE (*d) = new_binding;
2014 /* Build a TREE_LIST to wrap the OVERLOAD. */
2015 *d = tree_cons (NULL_TREE, new_binding,
2018 /* And update the cxx_binding node. */
2019 IDENTIFIER_BINDING (name)->value = new_binding;
2020 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2023 /* We should always find a previous binding in this case. */
2027 /* Install the new binding. */
2028 push_local_binding (name, new_binding, flags);
2031 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2034 /* Check a non-member using-declaration. Return the name and scope
2035 being used, and the USING_DECL, or NULL_TREE on failure. */
2038 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2040 /* [namespace.udecl]
2041 A using-declaration for a class member shall be a
2042 member-declaration. */
2045 error ("%qT is not a namespace", scope);
2048 else if (scope == error_mark_node)
2051 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2054 A using-declaration shall not name a template-id. */
2055 error ("a using-declaration cannot specify a template-id. "
2056 "Try %<using %D%>", name);
2060 if (TREE_CODE (decl) == NAMESPACE_DECL)
2062 error ("namespace %qD not allowed in using-declaration", decl);
2066 if (TREE_CODE (decl) == SCOPE_REF)
2068 /* It's a nested name with template parameter dependent scope.
2069 This can only be using-declaration for class member. */
2070 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2074 if (is_overloaded_fn (decl))
2075 decl = get_first_fn (decl);
2077 gcc_assert (DECL_P (decl));
2079 /* Make a USING_DECL. */
2080 return push_using_decl (scope, name);
2083 /* Process local and global using-declarations. */
2086 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2087 tree *newval, tree *newtype)
2089 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2091 *newval = *newtype = NULL_TREE;
2092 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2096 if (!decls.value && !decls.type)
2098 error ("%qD not declared", name);
2102 /* It is impossible to overload a built-in function; any explicit
2103 declaration eliminates the built-in declaration. So, if OLDVAL
2104 is a built-in, then we can just pretend it isn't there. */
2106 && TREE_CODE (oldval) == FUNCTION_DECL
2107 && DECL_ANTICIPATED (oldval)
2108 && !DECL_HIDDEN_FRIEND_P (oldval))
2111 /* Check for using functions. */
2112 if (decls.value && is_overloaded_fn (decls.value))
2116 if (oldval && !is_overloaded_fn (oldval))
2118 if (!DECL_IMPLICIT_TYPEDEF_P (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);
2193 *newtype = decls.type;
2194 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2196 error ("using declaration %qD introduced ambiguous type %qT",
2202 /* Process a using-declaration at function scope. */
2205 do_local_using_decl (tree decl, tree scope, tree name)
2207 tree oldval, oldtype, newval, newtype;
2208 tree orig_decl = decl;
2210 decl = validate_nonmember_using_decl (decl, scope, name);
2211 if (decl == NULL_TREE)
2214 if (building_stmt_tree ()
2215 && at_function_scope_p ())
2216 add_decl_expr (decl);
2218 oldval = lookup_name_innermost_nonclass_level (name);
2219 oldtype = lookup_type_current_level (name);
2221 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2225 if (is_overloaded_fn (newval))
2229 /* We only need to push declarations for those functions
2230 that were not already bound in the current level.
2231 The old value might be NULL_TREE, it might be a single
2232 function, or an OVERLOAD. */
2233 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2234 term = OVL_FUNCTION (oldval);
2237 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2239 push_overloaded_decl (OVL_CURRENT (fn),
2240 PUSH_LOCAL | PUSH_USING,
2244 push_local_binding (name, newval, PUSH_USING);
2248 push_local_binding (name, newtype, PUSH_USING);
2249 set_identifier_type_value (name, newtype);
2252 /* Emit debug info. */
2253 if (!processing_template_decl)
2254 cp_emit_debug_info_for_using (orig_decl, current_scope());
2257 /* Returns true if ROOT (a namespace, class, or function) encloses
2258 CHILD. CHILD may be either a class type or a namespace. */
2261 is_ancestor (tree root, tree child)
2263 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2264 || TREE_CODE (root) == FUNCTION_DECL
2265 || CLASS_TYPE_P (root)));
2266 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2267 || CLASS_TYPE_P (child)));
2269 /* The global namespace encloses everything. */
2270 if (root == global_namespace)
2275 /* If we've run out of scopes, stop. */
2278 /* If we've reached the ROOT, it encloses CHILD. */
2281 /* Go out one level. */
2283 child = TYPE_NAME (child);
2284 child = DECL_CONTEXT (child);
2288 /* Enter the class or namespace scope indicated by T suitable for name
2289 lookup. T can be arbitrary scope, not necessary nested inside the
2290 current scope. Returns a non-null scope to pop iff pop_scope
2291 should be called later to exit this scope. */
2296 if (TREE_CODE (t) == NAMESPACE_DECL)
2297 push_decl_namespace (t);
2298 else if (CLASS_TYPE_P (t))
2300 if (!at_class_scope_p ()
2301 || !same_type_p (current_class_type, t))
2302 push_nested_class (t);
2304 /* T is the same as the current scope. There is therefore no
2305 need to re-enter the scope. Since we are not actually
2306 pushing a new scope, our caller should not call
2314 /* Leave scope pushed by push_scope. */
2319 if (TREE_CODE (t) == NAMESPACE_DECL)
2320 pop_decl_namespace ();
2321 else if CLASS_TYPE_P (t)
2322 pop_nested_class ();
2325 /* Subroutine of push_inner_scope. */
2328 push_inner_scope_r (tree outer, tree inner)
2333 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2336 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2338 push_inner_scope_r (outer, prev);
2339 if (TREE_CODE (inner) == NAMESPACE_DECL)
2341 struct cp_binding_level *save_template_parm = 0;
2342 /* Temporary take out template parameter scopes. They are saved
2343 in reversed order in save_template_parm. */
2344 while (current_binding_level->kind == sk_template_parms)
2346 struct cp_binding_level *b = current_binding_level;
2347 current_binding_level = b->level_chain;
2348 b->level_chain = save_template_parm;
2349 save_template_parm = b;
2352 resume_scope (NAMESPACE_LEVEL (inner));
2353 current_namespace = inner;
2355 /* Restore template parameter scopes. */
2356 while (save_template_parm)
2358 struct cp_binding_level *b = save_template_parm;
2359 save_template_parm = b->level_chain;
2360 b->level_chain = current_binding_level;
2361 current_binding_level = b;
2368 /* Enter the scope INNER from current scope. INNER must be a scope
2369 nested inside current scope. This works with both name lookup and
2370 pushing name into scope. In case a template parameter scope is present,
2371 namespace is pushed under the template parameter scope according to
2372 name lookup rule in 14.6.1/6.
2374 Return the former current scope suitable for pop_inner_scope. */
2377 push_inner_scope (tree inner)
2379 tree outer = current_scope ();
2381 outer = current_namespace;
2383 push_inner_scope_r (outer, inner);
2387 /* Exit the current scope INNER back to scope OUTER. */
2390 pop_inner_scope (tree outer, tree inner)
2393 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2396 while (outer != inner)
2398 if (TREE_CODE (inner) == NAMESPACE_DECL)
2400 struct cp_binding_level *save_template_parm = 0;
2401 /* Temporary take out template parameter scopes. They are saved
2402 in reversed order in save_template_parm. */
2403 while (current_binding_level->kind == sk_template_parms)
2405 struct cp_binding_level *b = current_binding_level;
2406 current_binding_level = b->level_chain;
2407 b->level_chain = save_template_parm;
2408 save_template_parm = b;
2413 /* Restore template parameter scopes. */
2414 while (save_template_parm)
2416 struct cp_binding_level *b = save_template_parm;
2417 save_template_parm = b->level_chain;
2418 b->level_chain = current_binding_level;
2419 current_binding_level = b;
2425 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2429 /* Do a pushlevel for class declarations. */
2432 pushlevel_class (void)
2434 if (ENABLE_SCOPE_CHECKING)
2437 class_binding_level = begin_scope (sk_class, current_class_type);
2440 /* ...and a poplevel for class declarations. */
2443 poplevel_class (void)
2445 struct cp_binding_level *level = class_binding_level;
2446 cp_class_binding *cb;
2450 timevar_push (TV_NAME_LOOKUP);
2451 gcc_assert (level != 0);
2453 /* If we're leaving a toplevel class, cache its binding level. */
2454 if (current_class_depth == 1)
2455 previous_class_level = level;
2456 for (shadowed = level->type_shadowed;
2458 shadowed = TREE_CHAIN (shadowed))
2459 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2461 /* Remove the bindings for all of the class-level declarations. */
2462 if (level->class_shadowed)
2465 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2467 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2468 ggc_free (level->class_shadowed);
2469 level->class_shadowed = NULL;
2472 /* Now, pop out of the binding level which we created up in the
2473 `pushlevel_class' routine. */
2474 if (ENABLE_SCOPE_CHECKING)
2478 timevar_pop (TV_NAME_LOOKUP);
2481 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2482 appropriate. DECL is the value to which a name has just been
2483 bound. CLASS_TYPE is the class in which the lookup occurred. */
2486 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2489 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2493 if (TREE_CODE (decl) == OVERLOAD)
2494 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2497 gcc_assert (DECL_P (decl));
2498 context = context_for_name_lookup (decl);
2501 if (is_properly_derived_from (class_type, context))
2502 INHERITED_VALUE_BINDING_P (binding) = 1;
2504 INHERITED_VALUE_BINDING_P (binding) = 0;
2506 else if (binding->value == decl)
2507 /* We only encounter a TREE_LIST when there is an ambiguity in the
2508 base classes. Such an ambiguity can be overridden by a
2509 definition in this class. */
2510 INHERITED_VALUE_BINDING_P (binding) = 1;
2512 INHERITED_VALUE_BINDING_P (binding) = 0;
2515 /* Make the declaration of X appear in CLASS scope. */
2518 pushdecl_class_level (tree x)
2521 bool is_valid = true;
2523 timevar_push (TV_NAME_LOOKUP);
2524 /* Get the name of X. */
2525 if (TREE_CODE (x) == OVERLOAD)
2526 name = DECL_NAME (get_first_fn (x));
2528 name = DECL_NAME (x);
2532 is_valid = push_class_level_binding (name, x);
2533 if (TREE_CODE (x) == TYPE_DECL)
2534 set_identifier_type_value (name, x);
2536 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2538 /* If X is an anonymous aggregate, all of its members are
2539 treated as if they were members of the class containing the
2540 aggregate, for naming purposes. */
2543 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2545 location_t save_location = input_location;
2546 input_location = DECL_SOURCE_LOCATION (f);
2547 if (!pushdecl_class_level (f))
2549 input_location = save_location;
2552 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2555 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2556 scope. If the value returned is non-NULL, and the PREVIOUS field
2557 is not set, callers must set the PREVIOUS field explicitly. */
2559 static cxx_binding *
2560 get_class_binding (tree name, cxx_scope *scope)
2565 cxx_binding *binding;
2567 class_type = scope->this_entity;
2569 /* Get the type binding. */
2570 type_binding = lookup_member (class_type, name,
2571 /*protect=*/2, /*want_type=*/true);
2572 /* Get the value binding. */
2573 value_binding = lookup_member (class_type, name,
2574 /*protect=*/2, /*want_type=*/false);
2577 && (TREE_CODE (value_binding) == TYPE_DECL
2578 || DECL_CLASS_TEMPLATE_P (value_binding)
2579 || (TREE_CODE (value_binding) == TREE_LIST
2580 && TREE_TYPE (value_binding) == error_mark_node
2581 && (TREE_CODE (TREE_VALUE (value_binding))
2583 /* We found a type binding, even when looking for a non-type
2584 binding. This means that we already processed this binding
2587 else if (value_binding)
2589 if (TREE_CODE (value_binding) == TREE_LIST
2590 && TREE_TYPE (value_binding) == error_mark_node)
2591 /* NAME is ambiguous. */
2593 else if (BASELINK_P (value_binding))
2594 /* NAME is some overloaded functions. */
2595 value_binding = BASELINK_FUNCTIONS (value_binding);
2598 /* If we found either a type binding or a value binding, create a
2599 new binding object. */
2600 if (type_binding || value_binding)
2602 binding = new_class_binding (name,
2606 /* This is a class-scope binding, not a block-scope binding. */
2607 LOCAL_BINDING_P (binding) = 0;
2608 set_inherited_value_binding_p (binding, value_binding, class_type);
2616 /* Make the declaration(s) of X appear in CLASS scope under the name
2617 NAME. Returns true if the binding is valid. */
2620 push_class_level_binding (tree name, tree x)
2622 cxx_binding *binding;
2626 timevar_push (TV_NAME_LOOKUP);
2627 /* The class_binding_level will be NULL if x is a template
2628 parameter name in a member template. */
2629 if (!class_binding_level)
2630 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2632 if (name == error_mark_node)
2633 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2635 /* Check for invalid member names. */
2636 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2637 /* We could have been passed a tree list if this is an ambiguous
2638 declaration. If so, pull the declaration out because
2639 check_template_shadow will not handle a TREE_LIST. */
2640 if (TREE_CODE (decl) == TREE_LIST
2641 && TREE_TYPE (decl) == error_mark_node)
2642 decl = TREE_VALUE (decl);
2644 check_template_shadow (decl);
2648 If T is the name of a class, then each of the following shall
2649 have a name different from T:
2651 -- every static data member of class T;
2653 -- every member of class T that is itself a type;
2655 -- every enumerator of every member of class T that is an
2658 -- every member of every anonymous union that is a member of
2661 (Non-static data members were also forbidden to have the same
2662 name as T until TC1.) */
2663 if ((TREE_CODE (x) == VAR_DECL
2664 || TREE_CODE (x) == CONST_DECL
2665 || (TREE_CODE (x) == TYPE_DECL
2666 && !DECL_SELF_REFERENCE_P (x))
2667 /* A data member of an anonymous union. */
2668 || (TREE_CODE (x) == FIELD_DECL
2669 && DECL_CONTEXT (x) != current_class_type))
2670 && DECL_NAME (x) == constructor_name (current_class_type))
2672 tree scope = context_for_name_lookup (x);
2673 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2675 error ("%qD has the same name as the class in which it is "
2678 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2682 /* Get the current binding for NAME in this class, if any. */
2683 binding = IDENTIFIER_BINDING (name);
2684 if (!binding || binding->scope != class_binding_level)
2686 binding = get_class_binding (name, class_binding_level);
2687 /* If a new binding was created, put it at the front of the
2688 IDENTIFIER_BINDING list. */
2691 binding->previous = IDENTIFIER_BINDING (name);
2692 IDENTIFIER_BINDING (name) = binding;
2696 /* If there is already a binding, then we may need to update the
2698 if (binding && binding->value)
2700 tree bval = binding->value;
2701 tree old_decl = NULL_TREE;
2703 if (INHERITED_VALUE_BINDING_P (binding))
2705 /* If the old binding was from a base class, and was for a
2706 tag name, slide it over to make room for the new binding.
2707 The old binding is still visible if explicitly qualified
2708 with a class-key. */
2709 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2710 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2712 old_decl = binding->type;
2713 binding->type = bval;
2714 binding->value = NULL_TREE;
2715 INHERITED_VALUE_BINDING_P (binding) = 0;
2720 /* Any inherited type declaration is hidden by the type
2721 declaration in the derived class. */
2722 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2723 binding->type = NULL_TREE;
2726 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2728 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2729 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2730 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2732 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2733 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2735 if (old_decl && binding->scope == class_binding_level)
2738 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2739 here. This function is only used to register bindings
2740 from with the class definition itself. */
2741 INHERITED_VALUE_BINDING_P (binding) = 0;
2742 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2746 /* Note that we declared this value so that we can issue an error if
2747 this is an invalid redeclaration of a name already used for some
2749 note_name_declared_in_class (name, decl);
2751 /* If we didn't replace an existing binding, put the binding on the
2752 stack of bindings for the identifier, and update the shadowed
2754 if (binding && binding->scope == class_binding_level)
2755 /* Supplement the existing binding. */
2756 ok = supplement_binding (binding, decl);
2759 /* Create a new binding. */
2760 push_binding (name, decl, class_binding_level);
2764 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2767 /* Process "using SCOPE::NAME" in a class scope. Return the
2768 USING_DECL created. */
2771 do_class_using_decl (tree scope, tree name)
2773 /* The USING_DECL returned by this function. */
2775 /* The declaration (or declarations) name by this using
2776 declaration. NULL if we are in a template and cannot figure out
2777 what has been named. */
2779 /* True if SCOPE is a dependent type. */
2780 bool scope_dependent_p;
2781 /* True if SCOPE::NAME is dependent. */
2782 bool name_dependent_p;
2783 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2784 bool bases_dependent_p;
2789 if (name == error_mark_node)
2792 if (!scope || !TYPE_P (scope))
2794 error ("using-declaration for non-member at class scope");
2798 /* Make sure the name is not invalid */
2799 if (TREE_CODE (name) == BIT_NOT_EXPR)
2801 error ("%<%T::%D%> names destructor", scope, name);
2804 if (constructor_name_p (name, scope))
2806 error ("%<%T::%D%> names constructor", scope, name);
2809 if (constructor_name_p (name, current_class_type))
2811 error ("%<%T::%D%> names constructor in %qT",
2812 scope, name, current_class_type);
2816 scope_dependent_p = dependent_type_p (scope);
2817 name_dependent_p = (scope_dependent_p
2818 || (IDENTIFIER_TYPENAME_P (name)
2819 && dependent_type_p (TREE_TYPE (name))));
2821 bases_dependent_p = false;
2822 if (processing_template_decl)
2823 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2824 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2826 if (dependent_type_p (TREE_TYPE (base_binfo)))
2828 bases_dependent_p = true;
2834 /* From [namespace.udecl]:
2836 A using-declaration used as a member-declaration shall refer to a
2837 member of a base class of the class being defined.
2839 In general, we cannot check this constraint in a template because
2840 we do not know the entire set of base classes of the current
2841 class type. However, if all of the base classes are
2842 non-dependent, then we can avoid delaying the check until
2844 if (!scope_dependent_p)
2847 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2848 if (b_kind < bk_proper_base)
2850 if (!bases_dependent_p)
2852 error_not_base_type (scope, current_class_type);
2856 else if (!name_dependent_p)
2858 decl = lookup_member (binfo, name, 0, false);
2861 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2865 /* The binfo from which the functions came does not matter. */
2866 if (BASELINK_P (decl))
2867 decl = BASELINK_FUNCTIONS (decl);
2871 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2872 USING_DECL_DECLS (value) = decl;
2873 USING_DECL_SCOPE (value) = scope;
2874 DECL_DEPENDENT_P (value) = !decl;
2880 /* Return the binding value for name in scope. */
2883 namespace_binding (tree name, tree scope)
2885 cxx_binding *binding;
2888 scope = global_namespace;
2890 /* Unnecessary for the global namespace because it can't be an alias. */
2891 scope = ORIGINAL_NAMESPACE (scope);
2893 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2895 return binding ? binding->value : NULL_TREE;
2898 /* Set the binding value for name in scope. */
2901 set_namespace_binding (tree name, tree scope, tree val)
2905 timevar_push (TV_NAME_LOOKUP);
2906 if (scope == NULL_TREE)
2907 scope = global_namespace;
2908 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2909 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2912 supplement_binding (b, val);
2913 timevar_pop (TV_NAME_LOOKUP);
2916 /* Set the context of a declaration to scope. Complain if we are not
2920 set_decl_namespace (tree decl, tree scope, bool friendp)
2924 /* Get rid of namespace aliases. */
2925 scope = ORIGINAL_NAMESPACE (scope);
2927 /* It is ok for friends to be qualified in parallel space. */
2928 if (!friendp && !is_ancestor (current_namespace, scope))
2929 error ("declaration of %qD not in a namespace surrounding %qD",
2931 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2933 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2934 if (scope == current_namespace)
2936 if (at_namespace_scope_p ())
2937 error ("explicit qualification in declaration of %qD",
2942 /* See whether this has been declared in the namespace. */
2943 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2945 /* No old declaration at all. */
2947 if (!is_overloaded_fn (decl))
2948 /* Don't compare non-function decls with decls_match here, since
2949 it can't check for the correct constness at this
2950 point. pushdecl will find those errors later. */
2952 /* Since decl is a function, old should contain a function decl. */
2953 if (!is_overloaded_fn (old))
2955 fn = OVL_CURRENT (old);
2956 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2958 /* A template can be explicitly specialized in any namespace. */
2959 if (processing_explicit_instantiation)
2961 if (processing_template_decl || processing_specialization)
2962 /* We have not yet called push_template_decl to turn a
2963 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2964 match. But, we'll check later, when we construct the
2967 /* Instantiations or specializations of templates may be declared as
2968 friends in any namespace. */
2969 if (friendp && DECL_USE_TEMPLATE (decl))
2971 if (is_overloaded_fn (old))
2973 for (; old; old = OVL_NEXT (old))
2974 if (decls_match (decl, OVL_CURRENT (old)))
2977 else if (decls_match (decl, old))
2980 error ("%qD should have been declared inside %qD", decl, scope);
2983 /* Return the namespace where the current declaration is declared. */
2986 current_decl_namespace (void)
2989 /* If we have been pushed into a different namespace, use it. */
2990 if (decl_namespace_list)
2991 return TREE_PURPOSE (decl_namespace_list);
2993 if (current_class_type)
2994 result = decl_namespace_context (current_class_type);
2995 else if (current_function_decl)
2996 result = decl_namespace_context (current_function_decl);
2998 result = current_namespace;
3002 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3003 select a name that is unique to this compilation unit. */
3006 push_namespace (tree name)
3008 push_namespace_with_attribs (name, NULL_TREE);
3011 /* Same, but specify attributes to apply to the namespace. The attributes
3012 only apply to the current namespace-body, not to any later extensions. */
3015 push_namespace_with_attribs (tree name, tree attributes)
3019 int implicit_use = 0;
3022 timevar_push (TV_NAME_LOOKUP);
3024 /* We should not get here if the global_namespace is not yet constructed
3025 nor if NAME designates the global namespace: The global scope is
3026 constructed elsewhere. */
3027 gcc_assert (global_namespace != NULL && name != global_scope_name);
3031 name = get_anonymous_namespace_name();
3032 d = IDENTIFIER_NAMESPACE_VALUE (name);
3034 /* Reopening anonymous namespace. */
3040 /* Check whether this is an extended namespace definition. */
3041 d = IDENTIFIER_NAMESPACE_VALUE (name);
3042 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3045 if (DECL_NAMESPACE_ALIAS (d))
3047 error ("namespace alias %qD not allowed here, assuming %qD",
3048 d, DECL_NAMESPACE_ALIAS (d));
3049 d = DECL_NAMESPACE_ALIAS (d);
3056 /* Make a new namespace, binding the name to it. */
3057 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3058 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3059 /* The name of this namespace is not visible to other translation
3060 units if it is an anonymous namespace or member thereof. */
3061 if (anon || decl_anon_ns_mem_p (current_namespace))
3062 TREE_PUBLIC (d) = 0;
3064 TREE_PUBLIC (d) = 1;
3068 /* Clear DECL_NAME for the benefit of debugging back ends. */
3069 SET_DECL_ASSEMBLER_NAME (d, name);
3070 DECL_NAME (d) = NULL_TREE;
3072 begin_scope (sk_namespace, d);
3075 resume_scope (NAMESPACE_LEVEL (d));
3078 do_using_directive (d);
3079 /* Enter the name space. */
3080 current_namespace = d;
3082 #ifdef HANDLE_PRAGMA_VISIBILITY
3083 /* Clear has_visibility in case a previous namespace-definition had a
3084 visibility attribute and this one doesn't. */
3085 current_binding_level->has_visibility = 0;
3086 for (d = attributes; d; d = TREE_CHAIN (d))
3088 tree name = TREE_PURPOSE (d);
3089 tree args = TREE_VALUE (d);
3092 if (! is_attribute_p ("visibility", name))
3094 warning (OPT_Wattributes, "%qs attribute directive ignored",
3095 IDENTIFIER_POINTER (name));
3099 x = args ? TREE_VALUE (args) : NULL_TREE;
3100 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3102 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3103 IDENTIFIER_POINTER (name));
3107 current_binding_level->has_visibility = 1;
3108 push_visibility (TREE_STRING_POINTER (x));
3114 timevar_pop (TV_NAME_LOOKUP);
3117 /* Pop from the scope of the current namespace. */
3120 pop_namespace (void)
3122 gcc_assert (current_namespace != global_namespace);
3123 current_namespace = CP_DECL_CONTEXT (current_namespace);
3124 /* The binding level is not popped, as it might be re-opened later. */
3128 /* Push into the scope of the namespace NS, even if it is deeply
3129 nested within another namespace. */
3132 push_nested_namespace (tree ns)
3134 if (ns == global_namespace)
3135 push_to_top_level ();
3138 push_nested_namespace (CP_DECL_CONTEXT (ns));
3139 push_namespace (DECL_NAME (ns));
3143 /* Pop back from the scope of the namespace NS, which was previously
3144 entered with push_nested_namespace. */
3147 pop_nested_namespace (tree ns)
3149 timevar_push (TV_NAME_LOOKUP);
3150 while (ns != global_namespace)
3153 ns = CP_DECL_CONTEXT (ns);
3156 pop_from_top_level ();
3157 timevar_pop (TV_NAME_LOOKUP);
3160 /* Temporarily set the namespace for the current declaration. */
3163 push_decl_namespace (tree decl)
3165 if (TREE_CODE (decl) != NAMESPACE_DECL)
3166 decl = decl_namespace_context (decl);
3167 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3168 NULL_TREE, decl_namespace_list);
3171 /* [namespace.memdef]/2 */
3174 pop_decl_namespace (void)
3176 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3179 /* Return the namespace that is the common ancestor
3180 of two given namespaces. */
3183 namespace_ancestor (tree ns1, tree ns2)
3185 timevar_push (TV_NAME_LOOKUP);
3186 if (is_ancestor (ns1, ns2))
3187 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3188 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3189 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3192 /* Process a namespace-alias declaration. */
3195 do_namespace_alias (tree alias, tree namespace)
3197 if (namespace == error_mark_node)
3200 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3202 namespace = ORIGINAL_NAMESPACE (namespace);
3204 /* Build the alias. */
3205 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3206 DECL_NAMESPACE_ALIAS (alias) = namespace;
3207 DECL_EXTERNAL (alias) = 1;
3208 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3211 /* Emit debug info for namespace alias. */
3212 (*debug_hooks->global_decl) (alias);
3215 /* Like pushdecl, only it places X in the current namespace,
3219 pushdecl_namespace_level (tree x, bool is_friend)
3221 struct cp_binding_level *b = current_binding_level;
3224 timevar_push (TV_NAME_LOOKUP);
3225 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3227 /* Now, the type_shadowed stack may screw us. Munge it so it does
3229 if (TREE_CODE (t) == TYPE_DECL)
3231 tree name = DECL_NAME (t);
3233 tree *ptr = (tree *)0;
3234 for (; !global_scope_p (b); b = b->level_chain)
3236 tree shadowed = b->type_shadowed;
3237 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3238 if (TREE_PURPOSE (shadowed) == name)
3240 ptr = &TREE_VALUE (shadowed);
3241 /* Can't break out of the loop here because sometimes
3242 a binding level will have duplicate bindings for
3243 PT names. It's gross, but I haven't time to fix it. */
3246 newval = TREE_TYPE (t);
3247 if (ptr == (tree *)0)
3249 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3250 up here if this is changed to an assertion. --KR */
3251 SET_IDENTIFIER_TYPE_VALUE (name, t);
3258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3261 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3262 directive is not directly from the source. Also find the common
3263 ancestor and let our users know about the new namespace */
3265 add_using_namespace (tree user, tree used, bool indirect)
3268 timevar_push (TV_NAME_LOOKUP);
3269 /* Using oneself is a no-op. */
3272 timevar_pop (TV_NAME_LOOKUP);
3275 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3276 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3277 /* Check if we already have this. */
3278 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3282 /* Promote to direct usage. */
3283 TREE_INDIRECT_USING (t) = 0;
3284 timevar_pop (TV_NAME_LOOKUP);
3288 /* Add used to the user's using list. */
3289 DECL_NAMESPACE_USING (user)
3290 = tree_cons (used, namespace_ancestor (user, used),
3291 DECL_NAMESPACE_USING (user));
3293 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3295 /* Add user to the used's users list. */
3296 DECL_NAMESPACE_USERS (used)
3297 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3299 /* Recursively add all namespaces used. */
3300 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3301 /* indirect usage */
3302 add_using_namespace (user, TREE_PURPOSE (t), 1);
3304 /* Tell everyone using us about the new used namespaces. */
3305 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3306 add_using_namespace (TREE_PURPOSE (t), used, 1);
3307 timevar_pop (TV_NAME_LOOKUP);
3310 /* Process a using-declaration not appearing in class or local scope. */
3313 do_toplevel_using_decl (tree decl, tree scope, tree name)
3315 tree oldval, oldtype, newval, newtype;
3316 tree orig_decl = decl;
3317 cxx_binding *binding;
3319 decl = validate_nonmember_using_decl (decl, scope, name);
3320 if (decl == NULL_TREE)
3323 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3325 oldval = binding->value;
3326 oldtype = binding->type;
3328 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3330 /* Emit debug info. */
3331 if (!processing_template_decl)
3332 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3334 /* Copy declarations found. */
3336 binding->value = newval;
3338 binding->type = newtype;
3341 /* Process a using-directive. */
3344 do_using_directive (tree namespace)
3346 tree context = NULL_TREE;
3348 if (namespace == error_mark_node)
3351 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3353 if (building_stmt_tree ())
3354 add_stmt (build_stmt (USING_STMT, namespace));
3355 namespace = ORIGINAL_NAMESPACE (namespace);
3357 if (!toplevel_bindings_p ())
3359 push_using_directive (namespace);
3360 context = current_scope ();
3365 add_using_namespace (current_namespace, namespace, 0);
3366 if (current_namespace != global_namespace)
3367 context = current_namespace;
3370 /* Emit debugging info. */
3371 if (!processing_template_decl)
3372 (*debug_hooks->imported_module_or_decl) (namespace, context);
3375 /* Deal with a using-directive seen by the parser. Currently we only
3376 handle attributes here, since they cannot appear inside a template. */
3379 parse_using_directive (tree namespace, tree attribs)
3383 do_using_directive (namespace);
3385 for (a = attribs; a; a = TREE_CHAIN (a))
3387 tree name = TREE_PURPOSE (a);
3388 if (is_attribute_p ("strong", name))
3390 if (!toplevel_bindings_p ())
3391 error ("strong using only meaningful at namespace scope");
3392 else if (namespace != error_mark_node)
3394 if (!is_ancestor (current_namespace, namespace))
3395 error ("current namespace %qD does not enclose strongly used namespace %qD",
3396 current_namespace, namespace);
3397 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3398 = tree_cons (current_namespace, 0,
3399 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3403 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3407 /* Like pushdecl, only it places X in the global scope if appropriate.
3408 Calls cp_finish_decl to register the variable, initializing it with
3409 *INIT, if INIT is non-NULL. */
3412 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3414 timevar_push (TV_NAME_LOOKUP);
3415 push_to_top_level ();
3416 x = pushdecl_namespace_level (x, is_friend);
3418 finish_decl (x, *init, NULL_TREE);
3419 pop_from_top_level ();
3420 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3423 /* Like pushdecl, only it places X in the global scope if appropriate. */
3426 pushdecl_top_level (tree x)
3428 return pushdecl_top_level_1 (x, NULL, false);
3431 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3434 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3436 return pushdecl_top_level_1 (x, NULL, is_friend);
3439 /* Like pushdecl, only it places X in the global scope if
3440 appropriate. Calls cp_finish_decl to register the variable,
3441 initializing it with INIT. */
3444 pushdecl_top_level_and_finish (tree x, tree init)
3446 return pushdecl_top_level_1 (x, &init, false);
3449 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3450 duplicates. The first list becomes the tail of the result.
3452 The algorithm is O(n^2). We could get this down to O(n log n) by
3453 doing a sort on the addresses of the functions, if that becomes
3457 merge_functions (tree s1, tree s2)
3459 for (; s2; s2 = OVL_NEXT (s2))
3461 tree fn2 = OVL_CURRENT (s2);
3464 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3466 tree fn1 = OVL_CURRENT (fns1);
3468 /* If the function from S2 is already in S1, there is no
3469 need to add it again. For `extern "C"' functions, we
3470 might have two FUNCTION_DECLs for the same function, in
3471 different namespaces; again, we only need one of them. */
3473 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3474 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3478 /* If we exhausted all of the functions in S1, FN2 is new. */
3480 s1 = build_overload (fn2, s1);
3485 /* This should return an error not all definitions define functions.
3486 It is not an error if we find two functions with exactly the
3487 same signature, only if these are selected in overload resolution.
3488 old is the current set of bindings, new the freshly-found binding.
3489 XXX Do we want to give *all* candidates in case of ambiguity?
3490 XXX In what way should I treat extern declarations?
3491 XXX I don't want to repeat the entire duplicate_decls here */
3494 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3498 gcc_assert (old != NULL);
3500 /* Copy the type. */
3502 if (LOOKUP_NAMESPACES_ONLY (flags)
3503 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3506 /* Copy the value. */
3510 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3513 switch (TREE_CODE (val))
3516 /* If we expect types or namespaces, and not templates,
3517 or this is not a template class. */
3518 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3519 && !DECL_CLASS_TEMPLATE_P (val)))
3523 if (LOOKUP_NAMESPACES_ONLY (flags)
3524 || (type && (flags & LOOKUP_PREFER_TYPES)))
3527 case NAMESPACE_DECL:
3528 if (LOOKUP_TYPES_ONLY (flags))
3532 /* Ignore built-in functions that are still anticipated. */
3533 if (LOOKUP_QUALIFIERS_ONLY (flags))
3537 if (LOOKUP_QUALIFIERS_ONLY (flags))
3542 /* If val is hidden, shift down any class or enumeration name. */
3551 else if (val && val != old->value)
3553 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3554 old->value = merge_functions (old->value, val);
3557 old->value = tree_cons (NULL_TREE, old->value,
3558 build_tree_list (NULL_TREE, val));
3559 TREE_TYPE (old->value) = error_mark_node;
3565 else if (type && old->type != type)
3567 if (flags & LOOKUP_COMPLAIN)
3569 error ("%qD denotes an ambiguous type",name);
3570 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3571 error ("%J other type here", TYPE_MAIN_DECL (type));
3576 /* Return the declarations that are members of the namespace NS. */
3579 cp_namespace_decls (tree ns)
3581 return NAMESPACE_LEVEL (ns)->names;
3584 /* Combine prefer_type and namespaces_only into flags. */
3587 lookup_flags (int prefer_type, int namespaces_only)
3589 if (namespaces_only)
3590 return LOOKUP_PREFER_NAMESPACES;
3591 if (prefer_type > 1)
3592 return LOOKUP_PREFER_TYPES;
3593 if (prefer_type > 0)
3594 return LOOKUP_PREFER_BOTH;
3598 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3599 ignore it or not. Subroutine of lookup_name_real and
3600 lookup_type_scope. */
3603 qualify_lookup (tree val, int flags)
3605 if (val == NULL_TREE)
3607 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3609 if ((flags & LOOKUP_PREFER_TYPES)
3610 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3612 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3617 /* Given a lookup that returned VAL, decide if we want to ignore it or
3618 not based on DECL_ANTICIPATED. */
3621 hidden_name_p (tree val)
3624 && DECL_LANG_SPECIFIC (val)
3625 && DECL_ANTICIPATED (val))
3630 /* Remove any hidden friend functions from a possibly overloaded set
3634 remove_hidden_names (tree fns)
3639 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3641 else if (TREE_CODE (fns) == OVERLOAD)
3645 for (o = fns; o; o = OVL_NEXT (o))
3646 if (hidden_name_p (OVL_CURRENT (o)))
3652 for (o = fns; o; o = OVL_NEXT (o))
3653 if (!hidden_name_p (OVL_CURRENT (o)))
3654 n = build_overload (OVL_CURRENT (o), n);
3662 /* Unscoped lookup of a global: iterate over current namespaces,
3663 considering using-directives. */
3666 unqualified_namespace_lookup (tree name, int flags)
3668 tree initial = current_decl_namespace ();
3669 tree scope = initial;
3671 struct cp_binding_level *level;
3672 tree val = NULL_TREE;
3674 timevar_push (TV_NAME_LOOKUP);
3676 for (; !val; scope = CP_DECL_CONTEXT (scope))
3678 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3680 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3683 ambiguous_decl (name, &binding, b, flags);
3685 /* Add all _DECLs seen through local using-directives. */
3686 for (level = current_binding_level;
3687 level->kind != sk_namespace;
3688 level = level->level_chain)
3689 if (!lookup_using_namespace (name, &binding, level->using_directives,
3691 /* Give up because of error. */
3692 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3694 /* Add all _DECLs seen through global using-directives. */
3695 /* XXX local and global using lists should work equally. */
3699 if (!lookup_using_namespace (name, &binding,
3700 DECL_NAMESPACE_USING (siter),
3702 /* Give up because of error. */
3703 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3704 if (siter == scope) break;
3705 siter = CP_DECL_CONTEXT (siter);
3708 val = binding.value;
3709 if (scope == global_namespace)
3712 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3715 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3716 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3719 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3720 declaration found. If no suitable declaration can be found,
3721 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3722 neither a class-type nor a namespace a diagnostic is issued. */
3725 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3730 if (TREE_CODE (scope) == NAMESPACE_DECL)
3732 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3734 flags |= LOOKUP_COMPLAIN;
3736 flags |= LOOKUP_PREFER_TYPES;
3737 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3740 else if (is_aggr_type (scope, complain))
3741 t = lookup_member (scope, name, 2, is_type_p);
3744 return error_mark_node;
3748 /* Subroutine of unqualified_namespace_lookup:
3749 Add the bindings of NAME in used namespaces to VAL.
3750 We are currently looking for names in namespace SCOPE, so we
3751 look through USINGS for using-directives of namespaces
3752 which have SCOPE as a common ancestor with the current scope.
3753 Returns false on errors. */
3756 lookup_using_namespace (tree name, struct scope_binding *val,
3757 tree usings, tree scope, int flags)
3760 timevar_push (TV_NAME_LOOKUP);
3761 /* Iterate over all used namespaces in current, searching for using
3762 directives of scope. */
3763 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3764 if (TREE_VALUE (iter) == scope)
3766 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3768 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3769 /* Resolve ambiguities. */
3771 ambiguous_decl (name, val, val1, flags);
3773 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3777 Accepts the NAME to lookup and its qualifying SCOPE.
3778 Returns the name/type pair found into the cxx_binding *RESULT,
3779 or false on error. */
3782 qualified_lookup_using_namespace (tree name, tree scope,
3783 struct scope_binding *result, int flags)
3785 /* Maintain a list of namespaces visited... */
3786 tree seen = NULL_TREE;
3787 /* ... and a list of namespace yet to see. */
3788 tree todo = NULL_TREE;
3789 tree todo_maybe = NULL_TREE;
3791 timevar_push (TV_NAME_LOOKUP);
3792 /* Look through namespace aliases. */
3793 scope = ORIGINAL_NAMESPACE (scope);
3794 while (scope && result->value != error_mark_node)
3796 cxx_binding *binding =
3797 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3798 seen = tree_cons (scope, NULL_TREE, seen);
3800 ambiguous_decl (name, result, binding, flags);
3802 /* Consider strong using directives always, and non-strong ones
3803 if we haven't found a binding yet. ??? Shouldn't we consider
3804 non-strong ones if the initial RESULT is non-NULL, but the
3805 binding in the given namespace is? */
3806 for (usings = DECL_NAMESPACE_USING (scope); usings;
3807 usings = TREE_CHAIN (usings))
3808 /* If this was a real directive, and we have not seen it. */
3809 if (!TREE_INDIRECT_USING (usings))
3811 /* Try to avoid queuing the same namespace more than once,
3812 the exception being when a namespace was already
3813 enqueued for todo_maybe and then a strong using is
3814 found for it. We could try to remove it from
3815 todo_maybe, but it's probably not worth the effort. */
3816 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3817 && !purpose_member (TREE_PURPOSE (usings), seen)
3818 && !purpose_member (TREE_PURPOSE (usings), todo))
3819 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3820 else if ((!result->value && !result->type)
3821 && !purpose_member (TREE_PURPOSE (usings), seen)
3822 && !purpose_member (TREE_PURPOSE (usings), todo)
3823 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3824 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3829 scope = TREE_PURPOSE (todo);
3830 todo = TREE_CHAIN (todo);
3833 && (!result->value && !result->type))
3835 scope = TREE_PURPOSE (todo_maybe);
3836 todo = TREE_CHAIN (todo_maybe);
3837 todo_maybe = NULL_TREE;
3840 scope = NULL_TREE; /* If there never was a todo list. */
3842 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3845 /* Return the innermost non-namespace binding for NAME from a scope
3846 containing BINDING, or, if BINDING is NULL, the current scope. If
3847 CLASS_P is false, then class bindings are ignored. */
3850 outer_binding (tree name,
3851 cxx_binding *binding,
3856 cxx_scope *outer_scope;
3860 scope = binding->scope->level_chain;
3861 outer = binding->previous;
3865 scope = current_binding_level;
3866 outer = IDENTIFIER_BINDING (name);
3868 outer_scope = outer ? outer->scope : NULL;
3870 /* Because we create class bindings lazily, we might be missing a
3871 class binding for NAME. If there are any class binding levels
3872 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3873 declared, we must lookup NAME in those class scopes. */
3875 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3877 if (scope->kind == sk_class)
3879 cxx_binding *class_binding;
3881 class_binding = get_class_binding (name, scope);
3884 /* Thread this new class-scope binding onto the
3885 IDENTIFIER_BINDING list so that future lookups
3887 class_binding->previous = outer;
3889 binding->previous = class_binding;
3891 IDENTIFIER_BINDING (name) = class_binding;
3892 return class_binding;
3895 scope = scope->level_chain;
3901 /* Return the innermost block-scope or class-scope value binding for
3902 NAME, or NULL_TREE if there is no such binding. */
3905 innermost_non_namespace_value (tree name)
3907 cxx_binding *binding;
3908 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3909 return binding ? binding->value : NULL_TREE;
3912 /* Look up NAME in the current binding level and its superiors in the
3913 namespace of variables, functions and typedefs. Return a ..._DECL
3914 node of some kind representing its definition if there is only one
3915 such declaration, or return a TREE_LIST with all the overloaded
3916 definitions if there are many, or return 0 if it is undefined.
3917 Hidden name, either friend declaration or built-in function, are
3920 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3921 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3922 Otherwise we prefer non-TYPE_DECLs.
3924 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3925 BLOCK_P is false, bindings in block scopes are ignored. */
3928 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3929 int namespaces_only, int flags)
3932 tree val = NULL_TREE;
3934 timevar_push (TV_NAME_LOOKUP);
3935 /* Conversion operators are handled specially because ordinary
3936 unqualified name lookup will not find template conversion
3938 if (IDENTIFIER_TYPENAME_P (name))
3940 struct cp_binding_level *level;
3942 for (level = current_binding_level;
3943 level && level->kind != sk_namespace;
3944 level = level->level_chain)
3949 /* A conversion operator can only be declared in a class
3951 if (level->kind != sk_class)
3954 /* Lookup the conversion operator in the class. */
3955 class_type = level->this_entity;
3956 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3958 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3961 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3964 flags |= lookup_flags (prefer_type, namespaces_only);
3966 /* First, look in non-namespace scopes. */
3968 if (current_class_type == NULL_TREE)
3971 if (block_p || !nonclass)
3972 for (iter = outer_binding (name, NULL, !nonclass);
3974 iter = outer_binding (name, iter, !nonclass))
3978 /* Skip entities we don't want. */
3979 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3982 /* If this is the kind of thing we're looking for, we're done. */
3983 if (qualify_lookup (iter->value, flags))
3984 binding = iter->value;
3985 else if ((flags & LOOKUP_PREFER_TYPES)
3986 && qualify_lookup (iter->type, flags))
3987 binding = iter->type;
3989 binding = NULL_TREE;
3993 if (hidden_name_p (binding))
3995 /* A non namespace-scope binding can only be hidden if
3996 we are in a local class, due to friend declarations.
3997 In particular, consider:
4002 void g() { B* b; } // error: B is hidden
4007 The standard says that "B" is a local class in "f"
4008 (but not nested within "A") -- but that name lookup
4009 for "B" does not find this declaration until it is
4010 declared directly with "f".
4016 If a friend declaration appears in a local class and
4017 the name specified is an unqualified name, a prior
4018 declaration is looked up without considering scopes
4019 that are outside the innermost enclosing non-class
4020 scope. For a friend class declaration, if there is no
4021 prior declaration, the class that is specified
4022 belongs to the innermost enclosing non-class scope,
4023 but if it is subsequently referenced, its name is not
4024 found by name lookup until a matching declaration is
4025 provided in the innermost enclosing nonclass scope.
4027 gcc_assert (current_class_type &&
4028 LOCAL_CLASS_P (current_class_type));
4030 /* This binding comes from a friend declaration in the local
4031 class. The standard (11.4.8) states that the lookup can
4032 only succeed if there is a non-hidden declaration in the
4033 current scope, which is not the case here. */
4034 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4041 /* Now lookup in namespace scopes. */
4043 val = unqualified_namespace_lookup (name, flags);
4045 /* If we have a single function from a using decl, pull it out. */
4046 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4047 val = OVL_FUNCTION (val);
4049 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4053 lookup_name_nonclass (tree name)
4055 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4059 lookup_function_nonclass (tree name, tree args, bool block_p)
4062 lookup_arg_dependent (name,
4063 lookup_name_real (name, 0, 1, block_p, 0,
4069 lookup_name (tree name)
4071 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4075 lookup_name_prefer_type (tree name, int prefer_type)
4077 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4078 0, LOOKUP_COMPLAIN);
4081 /* Look up NAME for type used in elaborated name specifier in
4082 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4083 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4084 name, more scopes are checked if cleanup or template parameter
4085 scope is encountered.
4087 Unlike lookup_name_real, we make sure that NAME is actually
4088 declared in the desired scope, not from inheritance, nor using
4089 directive. For using declaration, there is DR138 still waiting
4090 to be resolved. Hidden name coming from an earlier friend
4091 declaration is also returned.
4093 A TYPE_DECL best matching the NAME is returned. Catching error
4094 and issuing diagnostics are caller's responsibility. */
4097 lookup_type_scope (tree name, tag_scope scope)
4099 cxx_binding *iter = NULL;
4100 tree val = NULL_TREE;
4102 timevar_push (TV_NAME_LOOKUP);
4104 /* Look in non-namespace scope first. */
4105 if (current_binding_level->kind != sk_namespace)
4106 iter = outer_binding (name, NULL, /*class_p=*/ true);
4107 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4109 /* Check if this is the kind of thing we're looking for.
4110 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4111 base class. For ITER->VALUE, we can simply use
4112 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4115 We check ITER->TYPE before ITER->VALUE in order to handle
4116 typedef struct C {} C;
4119 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4120 && (scope != ts_current
4121 || LOCAL_BINDING_P (iter)
4122 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4124 else if ((scope != ts_current
4125 || !INHERITED_VALUE_BINDING_P (iter))
4126 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4133 /* Look in namespace scope. */
4136 iter = cxx_scope_find_binding_for_name
4137 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4141 /* If this is the kind of thing we're looking for, we're done. */
4142 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4144 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4150 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4151 and template parameter scopes. */
4154 struct cp_binding_level *b = current_binding_level;
4157 if (iter->scope == b)
4158 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4160 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4162 else if (b->kind == sk_class
4163 && scope == ts_within_enclosing_non_class)
4170 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4173 /* Similar to `lookup_name' but look only in the innermost non-class
4177 lookup_name_innermost_nonclass_level (tree name)
4179 struct cp_binding_level *b;
4182 timevar_push (TV_NAME_LOOKUP);
4183 b = innermost_nonclass_level ();
4185 if (b->kind == sk_namespace)
4187 t = IDENTIFIER_NAMESPACE_VALUE (name);
4189 /* extern "C" function() */
4190 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4193 else if (IDENTIFIER_BINDING (name)
4194 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4196 cxx_binding *binding;
4197 binding = IDENTIFIER_BINDING (name);
4200 if (binding->scope == b
4201 && !(TREE_CODE (binding->value) == VAR_DECL
4202 && DECL_DEAD_FOR_LOCAL (binding->value)))
4203 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4205 if (b->kind == sk_cleanup)
4212 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4215 /* Like lookup_name_innermost_nonclass_level, but for types. */
4218 lookup_type_current_level (tree name)
4222 timevar_push (TV_NAME_LOOKUP);
4223 gcc_assert (current_binding_level->kind != sk_namespace);
4225 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4226 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4228 struct cp_binding_level *b = current_binding_level;
4231 if (purpose_member (name, b->type_shadowed))
4232 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4233 REAL_IDENTIFIER_TYPE_VALUE (name));
4234 if (b->kind == sk_cleanup)
4241 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4244 /* [basic.lookup.koenig] */
4245 /* A nonzero return value in the functions below indicates an error. */
4256 static bool arg_assoc (struct arg_lookup*, tree);
4257 static bool arg_assoc_args (struct arg_lookup*, tree);
4258 static bool arg_assoc_type (struct arg_lookup*, tree);
4259 static bool add_function (struct arg_lookup *, tree);
4260 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4261 static bool arg_assoc_class (struct arg_lookup *, tree);
4262 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4264 /* Add a function to the lookup structure.
4265 Returns true on error. */
4268 add_function (struct arg_lookup *k, tree fn)
4270 /* We used to check here to see if the function was already in the list,
4271 but that's O(n^2), which is just too expensive for function lookup.
4272 Now we deal with the occasional duplicate in joust. In doing this, we
4273 assume that the number of duplicates will be small compared to the
4274 total number of functions being compared, which should usually be the
4277 /* We must find only functions, or exactly one non-function. */
4280 else if (fn == k->functions)
4282 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4283 k->functions = build_overload (fn, k->functions);
4286 tree f1 = OVL_CURRENT (k->functions);
4288 if (is_overloaded_fn (f1))
4290 fn = f1; f1 = f2; f2 = fn;
4292 error ("%q+D is not a function,", f1);
4293 error (" conflict with %q+D", f2);
4294 error (" in call to %qD", k->name);
4301 /* Returns true iff CURRENT has declared itself to be an associated
4302 namespace of SCOPE via a strong using-directive (or transitive chain
4303 thereof). Both are namespaces. */
4306 is_associated_namespace (tree current, tree scope)
4308 tree seen = NULL_TREE;
4309 tree todo = NULL_TREE;
4313 if (scope == current)
4315 seen = tree_cons (scope, NULL_TREE, seen);
4316 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4317 if (!purpose_member (TREE_PURPOSE (t), seen))
4318 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4321 scope = TREE_PURPOSE (todo);
4322 todo = TREE_CHAIN (todo);
4329 /* Return whether FN is a friend of an associated class of ARG. */
4332 friend_of_associated_class_p (tree arg, tree fn)
4338 else if (type_unknown_p (arg))
4341 type = TREE_TYPE (arg);
4343 /* If TYPE is a class, the class itself and all base classes are
4344 associated classes. */
4345 if (CLASS_TYPE_P (type))
4347 if (is_friend (type, fn))
4350 if (TYPE_BINFO (type))
4352 tree binfo, base_binfo;
4355 for (binfo = TYPE_BINFO (type), i = 0;
4356 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4358 if (is_friend (BINFO_TYPE (base_binfo), fn))
4363 /* If TYPE is a class member, the class of which it is a member is
4364 an associated class. */
4365 if ((CLASS_TYPE_P (type)
4366 || TREE_CODE (type) == UNION_TYPE
4367 || TREE_CODE (type) == ENUMERAL_TYPE)
4368 && TYPE_CONTEXT (type)
4369 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4370 && is_friend (TYPE_CONTEXT (type), fn))
4376 /* Add functions of a namespace to the lookup structure.
4377 Returns true on error. */
4380 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4384 if (purpose_member (scope, k->namespaces))
4386 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4388 /* Check out our super-users. */
4389 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4390 value = TREE_CHAIN (value))
4391 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4394 value = namespace_binding (k->name, scope);
4398 for (; value; value = OVL_NEXT (value))
4400 /* We don't want to find arbitrary hidden functions via argument
4401 dependent lookup. We only want to find friends of associated
4403 if (hidden_name_p (OVL_CURRENT (value)))
4407 for (args = k->args; args; args = TREE_CHAIN (args))
4408 if (friend_of_associated_class_p (TREE_VALUE (args),
4409 OVL_CURRENT (value)))
4415 if (add_function (k, OVL_CURRENT (value)))
4422 /* Adds everything associated with a template argument to the lookup
4423 structure. Returns true on error. */
4426 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4428 /* [basic.lookup.koenig]
4430 If T is a template-id, its associated namespaces and classes are
4431 ... the namespaces and classes associated with the types of the
4432 template arguments provided for template type parameters
4433 (excluding template template parameters); the namespaces in which
4434 any template template arguments are defined; and the classes in
4435 which any member templates used as template template arguments
4436 are defined. [Note: non-type template arguments do not
4437 contribute to the set of associated namespaces. ] */
4439 /* Consider first template template arguments. */
4440 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4441 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4443 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4445 tree ctx = CP_DECL_CONTEXT (arg);
4447 /* It's not a member template. */
4448 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4449 return arg_assoc_namespace (k, ctx);
4450 /* Otherwise, it must be member template. */
4452 return arg_assoc_class (k, ctx);
4454 /* It's not a template template argument, but it is a type template
4456 else if (TYPE_P (arg))
4457 return arg_assoc_type (k, arg);
4458 /* It's a non-type template argument. */
4463 /* Adds everything associated with class to the lookup structure.
4464 Returns true on error. */
4467 arg_assoc_class (struct arg_lookup *k, tree type)
4469 tree list, friends, context;
4472 /* Backend build structures, such as __builtin_va_list, aren't
4473 affected by all this. */
4474 if (!CLASS_TYPE_P (type))
4477 if (purpose_member (type, k->classes))
4479 k->classes = tree_cons (type, NULL_TREE, k->classes);
4481 context = decl_namespace_context (type);
4482 if (arg_assoc_namespace (k, context))
4485 if (TYPE_BINFO (type))
4487 /* Process baseclasses. */
4488 tree binfo, base_binfo;
4490 for (binfo = TYPE_BINFO (type), i = 0;
4491 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4492 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4496 /* Process friends. */
4497 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4498 list = TREE_CHAIN (list))
4499 if (k->name == FRIEND_NAME (list))
4500 for (friends = FRIEND_DECLS (list); friends;
4501 friends = TREE_CHAIN (friends))
4503 tree fn = TREE_VALUE (friends);
4505 /* Only interested in global functions with potentially hidden
4506 (i.e. unqualified) declarations. */
4507 if (CP_DECL_CONTEXT (fn) != context)
4509 /* Template specializations are never found by name lookup.
4510 (Templates themselves can be found, but not template
4511 specializations.) */
4512 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4514 if (add_function (k, fn))
4518 /* Process template arguments. */
4519 if (CLASSTYPE_TEMPLATE_INFO (type)
4520 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4522 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4523 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4524 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4530 /* Adds everything associated with a given type.
4531 Returns 1 on error. */
4534 arg_assoc_type (struct arg_lookup *k, tree type)
4536 /* As we do not get the type of non-type dependent expressions
4537 right, we can end up with such things without a type. */
4541 if (TYPE_PTRMEM_P (type))
4543 /* Pointer to member: associate class type and value type. */
4544 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4546 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4548 else switch (TREE_CODE (type))
4560 if (TYPE_PTRMEMFUNC_P (type))
4561 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4562 return arg_assoc_class (k, type);
4564 case REFERENCE_TYPE:
4566 return arg_assoc_type (k, TREE_TYPE (type));
4569 return arg_assoc_namespace (k, decl_namespace_context (type));
4571 /* The basetype is referenced in the first arg type, so just
4574 /* Associate the parameter types. */
4575 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4577 /* Associate the return type. */
4578 return arg_assoc_type (k, TREE_TYPE (type));
4579 case TEMPLATE_TYPE_PARM:
4580 case BOUND_TEMPLATE_TEMPLATE_PARM:
4585 gcc_assert (type == unknown_type_node);
4587 case TYPE_PACK_EXPANSION:
4588 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4589 case TYPE_ARGUMENT_PACK:
4591 tree args = ARGUMENT_PACK_ARGS (type);
4592 int i, len = TREE_VEC_LENGTH (args);
4593 for (i = 0; i < len; i++)
4594 if (arg_assoc_type (k, TREE_VEC_ELT (args, i)))
4605 /* Adds everything associated with arguments. Returns true on error. */
4608 arg_assoc_args (struct arg_lookup *k, tree args)
4610 for (; args; args = TREE_CHAIN (args))
4611 if (arg_assoc (k, TREE_VALUE (args)))
4616 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4619 arg_assoc (struct arg_lookup *k, tree n)
4621 if (n == error_mark_node)
4625 return arg_assoc_type (k, n);
4627 if (! type_unknown_p (n))
4628 return arg_assoc_type (k, TREE_TYPE (n));
4630 if (TREE_CODE (n) == ADDR_EXPR)
4631 n = TREE_OPERAND (n, 0);
4632 if (TREE_CODE (n) == COMPONENT_REF)
4633 n = TREE_OPERAND (n, 1);
4634 if (TREE_CODE (n) == OFFSET_REF)
4635 n = TREE_OPERAND (n, 1);
4636 while (TREE_CODE (n) == TREE_LIST)
4638 if (TREE_CODE (n) == BASELINK)
4639 n = BASELINK_FUNCTIONS (n);
4641 if (TREE_CODE (n) == FUNCTION_DECL)
4642 return arg_assoc_type (k, TREE_TYPE (n));
4643 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4645 /* [basic.lookup.koenig]
4647 If T is a template-id, its associated namespaces and classes
4648 are the namespace in which the template is defined; for
4649 member templates, the member template's class... */
4650 tree template = TREE_OPERAND (n, 0);
4651 tree args = TREE_OPERAND (n, 1);
4655 if (TREE_CODE (template) == COMPONENT_REF)
4656 template = TREE_OPERAND (template, 1);
4658 /* First, the template. There may actually be more than one if
4659 this is an overloaded function template. But, in that case,
4660 we only need the first; all the functions will be in the same
4662 template = OVL_CURRENT (template);
4664 ctx = CP_DECL_CONTEXT (template);
4666 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4668 if (arg_assoc_namespace (k, ctx) == 1)
4671 /* It must be a member template. */
4672 else if (arg_assoc_class (k, ctx) == 1)
4675 /* Now the arguments. */
4677 for (ix = TREE_VEC_LENGTH (args); ix--;)
4678 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4681 else if (TREE_CODE (n) == OVERLOAD)
4683 for (; n; n = OVL_CHAIN (n))
4684 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4691 /* Performs Koenig lookup depending on arguments, where fns
4692 are the functions found in normal lookup. */
4695 lookup_arg_dependent (tree name, tree fns, tree args)
4697 struct arg_lookup k;
4699 timevar_push (TV_NAME_LOOKUP);
4701 /* Remove any hidden friend functions from the list of functions
4702 found so far. They will be added back by arg_assoc_class as
4704 fns = remove_hidden_names (fns);
4709 k.classes = NULL_TREE;
4711 /* We previously performed an optimization here by setting
4712 NAMESPACES to the current namespace when it was safe. However, DR
4713 164 says that namespaces that were already searched in the first
4714 stage of template processing are searched again (potentially
4715 picking up later definitions) in the second stage. */
4716 k.namespaces = NULL_TREE;
4718 arg_assoc_args (&k, args);
4723 && TREE_CODE (fns) != VAR_DECL
4724 && !is_overloaded_fn (fns))
4726 error ("argument dependent lookup finds %q+D", fns);
4727 error (" in call to %qD", name);
4728 fns = error_mark_node;
4731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4734 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4735 changed (i.e. there was already a directive), or the fresh
4736 TREE_LIST otherwise. */
4739 push_using_directive (tree used)
4741 tree ud = current_binding_level->using_directives;
4742 tree iter, ancestor;
4744 timevar_push (TV_NAME_LOOKUP);
4745 /* Check if we already have this. */
4746 if (purpose_member (used, ud) != NULL_TREE)
4747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4749 ancestor = namespace_ancestor (current_decl_namespace (), used);
4750 ud = current_binding_level->using_directives;
4751 ud = tree_cons (used, ancestor, ud);
4752 current_binding_level->using_directives = ud;
4754 /* Recursively add all namespaces used. */
4755 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4756 push_using_directive (TREE_PURPOSE (iter));
4758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4761 /* The type TYPE is being declared. If it is a class template, or a
4762 specialization of a class template, do any processing required and
4763 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4764 being declared a friend. B is the binding level at which this TYPE
4767 Returns the TYPE_DECL for TYPE, which may have been altered by this
4771 maybe_process_template_type_declaration (tree type, int is_friend,
4774 tree decl = TYPE_NAME (type);
4776 if (processing_template_parmlist)
4777 /* You can't declare a new template type in a template parameter
4778 list. But, you can declare a non-template type:
4780 template <class A*> struct S;
4782 is a forward-declaration of `A'. */
4784 else if (b->kind == sk_namespace
4785 && current_binding_level->kind != sk_namespace)
4786 /* If this new type is being injected into a containing scope,
4787 then it's not a template type. */
4791 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4793 if (processing_template_decl)
4795 /* This may change after the call to
4796 push_template_decl_real, but we want the original value. */
4797 tree name = DECL_NAME (decl);
4799 decl = push_template_decl_real (decl, is_friend);
4800 /* If the current binding level is the binding level for the
4801 template parameters (see the comment in
4802 begin_template_parm_list) and the enclosing level is a class
4803 scope, and we're not looking at a friend, push the
4804 declaration of the member class into the class scope. In the
4805 friend case, push_template_decl will already have put the
4806 friend into global scope, if appropriate. */
4807 if (TREE_CODE (type) != ENUMERAL_TYPE
4808 && !is_friend && b->kind == sk_template_parms
4809 && b->level_chain->kind == sk_class)
4811 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4813 if (!COMPLETE_TYPE_P (current_class_type))
4815 maybe_add_class_template_decl_list (current_class_type,
4816 type, /*friend_p=*/0);
4817 /* Put this UTD in the table of UTDs for the class. */
4818 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4819 CLASSTYPE_NESTED_UTDS (current_class_type) =
4820 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4822 binding_table_insert
4823 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4832 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4833 that the NAME is a class template, the tag is processed but not pushed.
4835 The pushed scope depend on the SCOPE parameter:
4836 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4838 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4839 non-template-parameter scope. This case is needed for forward
4841 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4842 TS_GLOBAL case except that names within template-parameter scopes
4843 are not pushed at all.
4845 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4848 pushtag (tree name, tree type, tag_scope scope)
4850 struct cp_binding_level *b;
4853 timevar_push (TV_NAME_LOOKUP);
4854 b = current_binding_level;
4855 while (/* Cleanup scopes are not scopes from the point of view of
4857 b->kind == sk_cleanup
4858 /* Neither are the scopes used to hold template parameters
4859 for an explicit specialization. For an ordinary template
4860 declaration, these scopes are not scopes from the point of
4861 view of the language. */
4862 || (b->kind == sk_template_parms
4863 && (b->explicit_spec_p || scope == ts_global))
4864 || (b->kind == sk_class
4865 && (scope != ts_current
4866 /* We may be defining a new type in the initializer
4867 of a static member variable. We allow this when
4868 not pedantic, and it is particularly useful for
4869 type punning via an anonymous union. */
4870 || COMPLETE_TYPE_P (b->this_entity))))
4873 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4875 /* Do C++ gratuitous typedefing. */
4876 if (IDENTIFIER_TYPE_VALUE (name) != type)
4880 tree context = TYPE_CONTEXT (type);
4884 tree cs = current_scope ();
4886 if (scope == ts_current)
4888 else if (cs != NULL_TREE && TYPE_P (cs))
4889 /* When declaring a friend class of a local class, we want
4890 to inject the newly named class into the scope
4891 containing the local class, not the namespace
4893 context = decl_function_context (get_type_decl (cs));
4896 context = current_namespace;
4898 if (b->kind == sk_class
4899 || (b->kind == sk_template_parms
4900 && b->level_chain->kind == sk_class))
4903 if (current_lang_name == lang_name_java)
4904 TYPE_FOR_JAVA (type) = 1;
4906 tdef = create_implicit_typedef (name, type);
4907 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4908 if (scope == ts_within_enclosing_non_class)
4910 /* This is a friend. Make this TYPE_DECL node hidden from
4911 ordinary name lookup. Its corresponding TEMPLATE_DECL
4912 will be marked in push_template_decl_real. */
4913 retrofit_lang_decl (tdef);
4914 DECL_ANTICIPATED (tdef) = 1;
4915 DECL_FRIEND_P (tdef) = 1;
4918 decl = maybe_process_template_type_declaration
4919 (type, scope == ts_within_enclosing_non_class, b);
4920 if (decl == error_mark_node)
4921 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4924 set_identifier_type_value_with_scope (name, tdef, b);
4926 if (b->kind == sk_class)
4928 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4929 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4930 class. But if it's a member template class, we want
4931 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4933 finish_member_declaration (decl);
4935 pushdecl_class_level (decl);
4937 else if (b->kind != sk_template_parms)
4939 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4940 if (decl == error_mark_node)
4941 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4944 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4946 /* If this is a local class, keep track of it. We need this
4947 information for name-mangling, and so that it is possible to
4948 find all function definitions in a translation unit in a
4949 convenient way. (It's otherwise tricky to find a member
4950 function definition it's only pointed to from within a local
4952 if (TYPE_CONTEXT (type)
4953 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4954 VEC_safe_push (tree, gc, local_classes, type);
4956 if (b->kind == sk_class
4957 && !COMPLETE_TYPE_P (current_class_type))
4959 maybe_add_class_template_decl_list (current_class_type,
4960 type, /*friend_p=*/0);
4962 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4963 CLASSTYPE_NESTED_UTDS (current_class_type)
4964 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4966 binding_table_insert
4967 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4970 decl = TYPE_NAME (type);
4971 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4972 TYPE_STUB_DECL (type) = decl;
4974 /* Set type visibility now if this is a forward declaration. */
4975 TREE_PUBLIC (decl) = 1;
4976 determine_visibility (decl);
4978 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4981 /* Subroutines for reverting temporarily to top-level for instantiation
4982 of templates and such. We actually need to clear out the class- and
4983 local-value slots of all identifiers, so that only the global values
4984 are at all visible. Simply setting current_binding_level to the global
4985 scope isn't enough, because more binding levels may be pushed. */
4986 struct saved_scope *scope_chain;
4988 /* If ID has not already been marked, add an appropriate binding to
4992 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4994 cxx_saved_binding *saved;
4996 if (!id || !IDENTIFIER_BINDING (id))
4999 if (IDENTIFIER_MARKED (id))
5002 IDENTIFIER_MARKED (id) = 1;
5004 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5005 saved->identifier = id;
5006 saved->binding = IDENTIFIER_BINDING (id);
5007 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5008 IDENTIFIER_BINDING (id) = NULL;
5012 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5016 timevar_push (TV_NAME_LOOKUP);
5017 for (t = names; t; t = TREE_CHAIN (t))
5021 if (TREE_CODE (t) == TREE_LIST)
5022 id = TREE_PURPOSE (t);
5026 store_binding (id, old_bindings);
5028 timevar_pop (TV_NAME_LOOKUP);
5031 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5032 objects, rather than a TREE_LIST. */
5035 store_class_bindings (VEC(cp_class_binding,gc) *names,
5036 VEC(cxx_saved_binding,gc) **old_bindings)
5039 cp_class_binding *cb;
5041 timevar_push (TV_NAME_LOOKUP);
5042 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5043 store_binding (cb->identifier, old_bindings);
5044 timevar_pop (TV_NAME_LOOKUP);
5048 push_to_top_level (void)
5050 struct saved_scope *s;
5051 struct cp_binding_level *b;
5052 cxx_saved_binding *sb;
5056 timevar_push (TV_NAME_LOOKUP);
5057 s = GGC_CNEW (struct saved_scope);
5059 b = scope_chain ? current_binding_level : 0;
5061 /* If we're in the middle of some function, save our state. */
5065 push_function_context_to (NULL_TREE);
5070 if (scope_chain && previous_class_level)
5071 store_class_bindings (previous_class_level->class_shadowed,
5074 /* Have to include the global scope, because class-scope decls
5075 aren't listed anywhere useful. */
5076 for (; b; b = b->level_chain)
5080 /* Template IDs are inserted into the global level. If they were
5081 inserted into namespace level, finish_file wouldn't find them
5082 when doing pending instantiations. Therefore, don't stop at
5083 namespace level, but continue until :: . */
5084 if (global_scope_p (b))
5087 store_bindings (b->names, &s->old_bindings);
5088 /* We also need to check class_shadowed to save class-level type
5089 bindings, since pushclass doesn't fill in b->names. */
5090 if (b->kind == sk_class)
5091 store_class_bindings (b->class_shadowed, &s->old_bindings);
5093 /* Unwind type-value slots back to top level. */
5094 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5095 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5098 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5099 IDENTIFIER_MARKED (sb->identifier) = 0;
5101 s->prev = scope_chain;
5103 s->need_pop_function_context = need_pop;
5104 s->function_decl = current_function_decl;
5105 s->skip_evaluation = skip_evaluation;
5108 current_function_decl = NULL_TREE;
5109 current_lang_base = VEC_alloc (tree, gc, 10);
5110 current_lang_name = lang_name_cplusplus;
5111 current_namespace = global_namespace;
5112 push_class_stack ();
5113 skip_evaluation = 0;
5114 timevar_pop (TV_NAME_LOOKUP);
5118 pop_from_top_level (void)
5120 struct saved_scope *s = scope_chain;
5121 cxx_saved_binding *saved;
5124 timevar_push (TV_NAME_LOOKUP);
5125 /* Clear out class-level bindings cache. */
5126 if (previous_class_level)
5127 invalidate_class_lookup_cache ();
5130 current_lang_base = 0;
5132 scope_chain = s->prev;
5133 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5135 tree id = saved->identifier;
5137 IDENTIFIER_BINDING (id) = saved->binding;
5138 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5141 /* If we were in the middle of compiling a function, restore our
5143 if (s->need_pop_function_context)
5144 pop_function_context_from (NULL_TREE);
5145 current_function_decl = s->function_decl;
5146 skip_evaluation = s->skip_evaluation;
5147 timevar_pop (TV_NAME_LOOKUP);
5150 /* Pop off extraneous binding levels left over due to syntax errors.
5152 We don't pop past namespaces, as they might be valid. */
5155 pop_everything (void)
5157 if (ENABLE_SCOPE_CHECKING)
5158 verbatim ("XXX entering pop_everything ()\n");
5159 while (!toplevel_bindings_p ())
5161 if (current_binding_level->kind == sk_class)
5162 pop_nested_class ();
5166 if (ENABLE_SCOPE_CHECKING)
5167 verbatim ("XXX leaving pop_everything ()\n");
5170 /* Emit debugging information for using declarations and directives.
5171 If input tree is overloaded fn then emit debug info for all
5175 cp_emit_debug_info_for_using (tree t, tree context)
5177 /* Don't try to emit any debug information if we have errors. */
5178 if (sorrycount || errorcount)
5181 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5182 of a builtin function. */
5183 if (TREE_CODE (t) == FUNCTION_DECL
5184 && DECL_EXTERNAL (t)
5185 && DECL_BUILT_IN (t))
5188 /* Do not supply context to imported_module_or_decl, if
5189 it is a global namespace. */
5190 if (context == global_namespace)
5191 context = NULL_TREE;
5194 t = BASELINK_FUNCTIONS (t);
5196 /* FIXME: Handle TEMPLATE_DECLs. */
5197 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5198 if (TREE_CODE (t) != TEMPLATE_DECL)
5199 (*debug_hooks->imported_module_or_decl) (t, context);
5202 #include "gt-cp-name-lookup.h"