1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
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 /* Shift the old and new bindings around so we're comparing class and
2103 enumeration names to each other. */
2104 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2110 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2112 decls.type = decls.value;
2113 decls.value = NULL_TREE;
2116 /* It is impossible to overload a built-in function; any explicit
2117 declaration eliminates the built-in declaration. So, if OLDVAL
2118 is a built-in, then we can just pretend it isn't there. */
2120 && TREE_CODE (oldval) == FUNCTION_DECL
2121 && DECL_ANTICIPATED (oldval)
2122 && !DECL_HIDDEN_FRIEND_P (oldval))
2127 /* Check for using functions. */
2128 if (is_overloaded_fn (decls.value))
2132 if (oldval && !is_overloaded_fn (oldval))
2134 error ("%qD is already declared in this scope", name);
2139 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2141 tree new_fn = OVL_CURRENT (tmp);
2143 /* [namespace.udecl]
2145 If a function declaration in namespace scope or block
2146 scope has the same name and the same parameter types as a
2147 function introduced by a using declaration the program is
2149 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2151 tree old_fn = OVL_CURRENT (tmp1);
2153 if (new_fn == old_fn)
2154 /* The function already exists in the current namespace. */
2156 else if (OVL_USED (tmp1))
2157 continue; /* this is a using decl */
2158 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2159 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2161 gcc_assert (!DECL_ANTICIPATED (old_fn)
2162 || DECL_HIDDEN_FRIEND_P (old_fn));
2164 /* There was already a non-using declaration in
2165 this scope with the same parameter types. If both
2166 are the same extern "C" functions, that's ok. */
2167 if (decls_match (new_fn, old_fn))
2171 error ("%qD is already declared in this scope", name);
2177 /* If we broke out of the loop, there's no reason to add
2178 this function to the using declarations for this
2183 /* If we are adding to an existing OVERLOAD, then we no
2184 longer know the type of the set of functions. */
2185 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2186 TREE_TYPE (*newval) = unknown_type_node;
2187 /* Add this new function to the set. */
2188 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2189 /* If there is only one function, then we use its type. (A
2190 using-declaration naming a single function can be used in
2191 contexts where overload resolution cannot be
2193 if (TREE_CODE (*newval) != OVERLOAD)
2195 *newval = ovl_cons (*newval, NULL_TREE);
2196 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2198 OVL_USED (*newval) = 1;
2203 *newval = decls.value;
2204 if (oldval && !decls_match (*newval, oldval))
2205 error ("%qD is already declared in this scope", name);
2211 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2213 error ("reference to %qD is ambiguous", name);
2214 print_candidates (decls.type);
2218 *newtype = decls.type;
2219 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2220 error ("%qD is already declared in this scope", name);
2223 /* If *newval is empty, shift any class or enumeration name down. */
2227 *newtype = NULL_TREE;
2231 /* Process a using-declaration at function scope. */
2234 do_local_using_decl (tree decl, tree scope, tree name)
2236 tree oldval, oldtype, newval, newtype;
2237 tree orig_decl = decl;
2239 decl = validate_nonmember_using_decl (decl, scope, name);
2240 if (decl == NULL_TREE)
2243 if (building_stmt_tree ()
2244 && at_function_scope_p ())
2245 add_decl_expr (decl);
2247 oldval = lookup_name_innermost_nonclass_level (name);
2248 oldtype = lookup_type_current_level (name);
2250 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2254 if (is_overloaded_fn (newval))
2258 /* We only need to push declarations for those functions
2259 that were not already bound in the current level.
2260 The old value might be NULL_TREE, it might be a single
2261 function, or an OVERLOAD. */
2262 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2263 term = OVL_FUNCTION (oldval);
2266 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2268 push_overloaded_decl (OVL_CURRENT (fn),
2269 PUSH_LOCAL | PUSH_USING,
2273 push_local_binding (name, newval, PUSH_USING);
2277 push_local_binding (name, newtype, PUSH_USING);
2278 set_identifier_type_value (name, newtype);
2281 /* Emit debug info. */
2282 if (!processing_template_decl)
2283 cp_emit_debug_info_for_using (orig_decl, current_scope());
2286 /* Returns true if ROOT (a namespace, class, or function) encloses
2287 CHILD. CHILD may be either a class type or a namespace. */
2290 is_ancestor (tree root, tree child)
2292 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2293 || TREE_CODE (root) == FUNCTION_DECL
2294 || CLASS_TYPE_P (root)));
2295 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2296 || CLASS_TYPE_P (child)));
2298 /* The global namespace encloses everything. */
2299 if (root == global_namespace)
2304 /* If we've run out of scopes, stop. */
2307 /* If we've reached the ROOT, it encloses CHILD. */
2310 /* Go out one level. */
2312 child = TYPE_NAME (child);
2313 child = DECL_CONTEXT (child);
2317 /* Enter the class or namespace scope indicated by T suitable for name
2318 lookup. T can be arbitrary scope, not necessary nested inside the
2319 current scope. Returns a non-null scope to pop iff pop_scope
2320 should be called later to exit this scope. */
2325 if (TREE_CODE (t) == NAMESPACE_DECL)
2326 push_decl_namespace (t);
2327 else if (CLASS_TYPE_P (t))
2329 if (!at_class_scope_p ()
2330 || !same_type_p (current_class_type, t))
2331 push_nested_class (t);
2333 /* T is the same as the current scope. There is therefore no
2334 need to re-enter the scope. Since we are not actually
2335 pushing a new scope, our caller should not call
2343 /* Leave scope pushed by push_scope. */
2348 if (TREE_CODE (t) == NAMESPACE_DECL)
2349 pop_decl_namespace ();
2350 else if CLASS_TYPE_P (t)
2351 pop_nested_class ();
2354 /* Subroutine of push_inner_scope. */
2357 push_inner_scope_r (tree outer, tree inner)
2362 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2365 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2367 push_inner_scope_r (outer, prev);
2368 if (TREE_CODE (inner) == NAMESPACE_DECL)
2370 struct cp_binding_level *save_template_parm = 0;
2371 /* Temporary take out template parameter scopes. They are saved
2372 in reversed order in save_template_parm. */
2373 while (current_binding_level->kind == sk_template_parms)
2375 struct cp_binding_level *b = current_binding_level;
2376 current_binding_level = b->level_chain;
2377 b->level_chain = save_template_parm;
2378 save_template_parm = b;
2381 resume_scope (NAMESPACE_LEVEL (inner));
2382 current_namespace = inner;
2384 /* Restore template parameter scopes. */
2385 while (save_template_parm)
2387 struct cp_binding_level *b = save_template_parm;
2388 save_template_parm = b->level_chain;
2389 b->level_chain = current_binding_level;
2390 current_binding_level = b;
2397 /* Enter the scope INNER from current scope. INNER must be a scope
2398 nested inside current scope. This works with both name lookup and
2399 pushing name into scope. In case a template parameter scope is present,
2400 namespace is pushed under the template parameter scope according to
2401 name lookup rule in 14.6.1/6.
2403 Return the former current scope suitable for pop_inner_scope. */
2406 push_inner_scope (tree inner)
2408 tree outer = current_scope ();
2410 outer = current_namespace;
2412 push_inner_scope_r (outer, inner);
2416 /* Exit the current scope INNER back to scope OUTER. */
2419 pop_inner_scope (tree outer, tree inner)
2422 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2425 while (outer != inner)
2427 if (TREE_CODE (inner) == NAMESPACE_DECL)
2429 struct cp_binding_level *save_template_parm = 0;
2430 /* Temporary take out template parameter scopes. They are saved
2431 in reversed order in save_template_parm. */
2432 while (current_binding_level->kind == sk_template_parms)
2434 struct cp_binding_level *b = current_binding_level;
2435 current_binding_level = b->level_chain;
2436 b->level_chain = save_template_parm;
2437 save_template_parm = b;
2442 /* Restore template parameter scopes. */
2443 while (save_template_parm)
2445 struct cp_binding_level *b = save_template_parm;
2446 save_template_parm = b->level_chain;
2447 b->level_chain = current_binding_level;
2448 current_binding_level = b;
2454 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2458 /* Do a pushlevel for class declarations. */
2461 pushlevel_class (void)
2463 if (ENABLE_SCOPE_CHECKING)
2466 class_binding_level = begin_scope (sk_class, current_class_type);
2469 /* ...and a poplevel for class declarations. */
2472 poplevel_class (void)
2474 struct cp_binding_level *level = class_binding_level;
2475 cp_class_binding *cb;
2479 timevar_push (TV_NAME_LOOKUP);
2480 gcc_assert (level != 0);
2482 /* If we're leaving a toplevel class, cache its binding level. */
2483 if (current_class_depth == 1)
2484 previous_class_level = level;
2485 for (shadowed = level->type_shadowed;
2487 shadowed = TREE_CHAIN (shadowed))
2488 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2490 /* Remove the bindings for all of the class-level declarations. */
2491 if (level->class_shadowed)
2494 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2496 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2497 ggc_free (level->class_shadowed);
2498 level->class_shadowed = NULL;
2501 /* Now, pop out of the binding level which we created up in the
2502 `pushlevel_class' routine. */
2503 if (ENABLE_SCOPE_CHECKING)
2507 timevar_pop (TV_NAME_LOOKUP);
2510 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2511 appropriate. DECL is the value to which a name has just been
2512 bound. CLASS_TYPE is the class in which the lookup occurred. */
2515 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2518 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2522 if (TREE_CODE (decl) == OVERLOAD)
2523 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2526 gcc_assert (DECL_P (decl));
2527 context = context_for_name_lookup (decl);
2530 if (is_properly_derived_from (class_type, context))
2531 INHERITED_VALUE_BINDING_P (binding) = 1;
2533 INHERITED_VALUE_BINDING_P (binding) = 0;
2535 else if (binding->value == decl)
2536 /* We only encounter a TREE_LIST when there is an ambiguity in the
2537 base classes. Such an ambiguity can be overridden by a
2538 definition in this class. */
2539 INHERITED_VALUE_BINDING_P (binding) = 1;
2541 INHERITED_VALUE_BINDING_P (binding) = 0;
2544 /* Make the declaration of X appear in CLASS scope. */
2547 pushdecl_class_level (tree x)
2550 bool is_valid = true;
2552 timevar_push (TV_NAME_LOOKUP);
2553 /* Get the name of X. */
2554 if (TREE_CODE (x) == OVERLOAD)
2555 name = DECL_NAME (get_first_fn (x));
2557 name = DECL_NAME (x);
2561 is_valid = push_class_level_binding (name, x);
2562 if (TREE_CODE (x) == TYPE_DECL)
2563 set_identifier_type_value (name, x);
2565 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2567 /* If X is an anonymous aggregate, all of its members are
2568 treated as if they were members of the class containing the
2569 aggregate, for naming purposes. */
2572 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2574 location_t save_location = input_location;
2575 input_location = DECL_SOURCE_LOCATION (f);
2576 if (!pushdecl_class_level (f))
2578 input_location = save_location;
2581 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2584 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2585 scope. If the value returned is non-NULL, and the PREVIOUS field
2586 is not set, callers must set the PREVIOUS field explicitly. */
2588 static cxx_binding *
2589 get_class_binding (tree name, cxx_scope *scope)
2594 cxx_binding *binding;
2596 class_type = scope->this_entity;
2598 /* Get the type binding. */
2599 type_binding = lookup_member (class_type, name,
2600 /*protect=*/2, /*want_type=*/true);
2601 /* Get the value binding. */
2602 value_binding = lookup_member (class_type, name,
2603 /*protect=*/2, /*want_type=*/false);
2606 && (TREE_CODE (value_binding) == TYPE_DECL
2607 || DECL_CLASS_TEMPLATE_P (value_binding)
2608 || (TREE_CODE (value_binding) == TREE_LIST
2609 && TREE_TYPE (value_binding) == error_mark_node
2610 && (TREE_CODE (TREE_VALUE (value_binding))
2612 /* We found a type binding, even when looking for a non-type
2613 binding. This means that we already processed this binding
2616 else if (value_binding)
2618 if (TREE_CODE (value_binding) == TREE_LIST
2619 && TREE_TYPE (value_binding) == error_mark_node)
2620 /* NAME is ambiguous. */
2622 else if (BASELINK_P (value_binding))
2623 /* NAME is some overloaded functions. */
2624 value_binding = BASELINK_FUNCTIONS (value_binding);
2627 /* If we found either a type binding or a value binding, create a
2628 new binding object. */
2629 if (type_binding || value_binding)
2631 binding = new_class_binding (name,
2635 /* This is a class-scope binding, not a block-scope binding. */
2636 LOCAL_BINDING_P (binding) = 0;
2637 set_inherited_value_binding_p (binding, value_binding, class_type);
2645 /* Make the declaration(s) of X appear in CLASS scope under the name
2646 NAME. Returns true if the binding is valid. */
2649 push_class_level_binding (tree name, tree x)
2651 cxx_binding *binding;
2655 timevar_push (TV_NAME_LOOKUP);
2656 /* The class_binding_level will be NULL if x is a template
2657 parameter name in a member template. */
2658 if (!class_binding_level)
2659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2661 if (name == error_mark_node)
2662 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2664 /* Check for invalid member names. */
2665 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2666 /* We could have been passed a tree list if this is an ambiguous
2667 declaration. If so, pull the declaration out because
2668 check_template_shadow will not handle a TREE_LIST. */
2669 if (TREE_CODE (decl) == TREE_LIST
2670 && TREE_TYPE (decl) == error_mark_node)
2671 decl = TREE_VALUE (decl);
2673 check_template_shadow (decl);
2677 If T is the name of a class, then each of the following shall
2678 have a name different from T:
2680 -- every static data member of class T;
2682 -- every member of class T that is itself a type;
2684 -- every enumerator of every member of class T that is an
2687 -- every member of every anonymous union that is a member of
2690 (Non-static data members were also forbidden to have the same
2691 name as T until TC1.) */
2692 if ((TREE_CODE (x) == VAR_DECL
2693 || TREE_CODE (x) == CONST_DECL
2694 || (TREE_CODE (x) == TYPE_DECL
2695 && !DECL_SELF_REFERENCE_P (x))
2696 /* A data member of an anonymous union. */
2697 || (TREE_CODE (x) == FIELD_DECL
2698 && DECL_CONTEXT (x) != current_class_type))
2699 && DECL_NAME (x) == constructor_name (current_class_type))
2701 tree scope = context_for_name_lookup (x);
2702 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2704 error ("%qD has the same name as the class in which it is "
2707 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2711 /* Get the current binding for NAME in this class, if any. */
2712 binding = IDENTIFIER_BINDING (name);
2713 if (!binding || binding->scope != class_binding_level)
2715 binding = get_class_binding (name, class_binding_level);
2716 /* If a new binding was created, put it at the front of the
2717 IDENTIFIER_BINDING list. */
2720 binding->previous = IDENTIFIER_BINDING (name);
2721 IDENTIFIER_BINDING (name) = binding;
2725 /* If there is already a binding, then we may need to update the
2727 if (binding && binding->value)
2729 tree bval = binding->value;
2730 tree old_decl = NULL_TREE;
2732 if (INHERITED_VALUE_BINDING_P (binding))
2734 /* If the old binding was from a base class, and was for a
2735 tag name, slide it over to make room for the new binding.
2736 The old binding is still visible if explicitly qualified
2737 with a class-key. */
2738 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2739 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2741 old_decl = binding->type;
2742 binding->type = bval;
2743 binding->value = NULL_TREE;
2744 INHERITED_VALUE_BINDING_P (binding) = 0;
2749 /* Any inherited type declaration is hidden by the type
2750 declaration in the derived class. */
2751 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2752 binding->type = NULL_TREE;
2755 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2757 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2759 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2761 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2762 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2764 if (old_decl && binding->scope == class_binding_level)
2767 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2768 here. This function is only used to register bindings
2769 from with the class definition itself. */
2770 INHERITED_VALUE_BINDING_P (binding) = 0;
2771 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2775 /* Note that we declared this value so that we can issue an error if
2776 this is an invalid redeclaration of a name already used for some
2778 note_name_declared_in_class (name, decl);
2780 /* If we didn't replace an existing binding, put the binding on the
2781 stack of bindings for the identifier, and update the shadowed
2783 if (binding && binding->scope == class_binding_level)
2784 /* Supplement the existing binding. */
2785 ok = supplement_binding (binding, decl);
2788 /* Create a new binding. */
2789 push_binding (name, decl, class_binding_level);
2793 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2796 /* Process "using SCOPE::NAME" in a class scope. Return the
2797 USING_DECL created. */
2800 do_class_using_decl (tree scope, tree name)
2802 /* The USING_DECL returned by this function. */
2804 /* The declaration (or declarations) name by this using
2805 declaration. NULL if we are in a template and cannot figure out
2806 what has been named. */
2808 /* True if SCOPE is a dependent type. */
2809 bool scope_dependent_p;
2810 /* True if SCOPE::NAME is dependent. */
2811 bool name_dependent_p;
2812 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2813 bool bases_dependent_p;
2818 if (name == error_mark_node)
2821 if (!scope || !TYPE_P (scope))
2823 error ("using-declaration for non-member at class scope");
2827 /* Make sure the name is not invalid */
2828 if (TREE_CODE (name) == BIT_NOT_EXPR)
2830 error ("%<%T::%D%> names destructor", scope, name);
2833 if (constructor_name_p (name, scope))
2835 error ("%<%T::%D%> names constructor", scope, name);
2838 if (constructor_name_p (name, current_class_type))
2840 error ("%<%T::%D%> names constructor in %qT",
2841 scope, name, current_class_type);
2845 scope_dependent_p = dependent_type_p (scope);
2846 name_dependent_p = (scope_dependent_p
2847 || (IDENTIFIER_TYPENAME_P (name)
2848 && dependent_type_p (TREE_TYPE (name))));
2850 bases_dependent_p = false;
2851 if (processing_template_decl)
2852 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2853 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2855 if (dependent_type_p (TREE_TYPE (base_binfo)))
2857 bases_dependent_p = true;
2863 /* From [namespace.udecl]:
2865 A using-declaration used as a member-declaration shall refer to a
2866 member of a base class of the class being defined.
2868 In general, we cannot check this constraint in a template because
2869 we do not know the entire set of base classes of the current
2870 class type. However, if all of the base classes are
2871 non-dependent, then we can avoid delaying the check until
2873 if (!scope_dependent_p)
2876 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2877 if (b_kind < bk_proper_base)
2879 if (!bases_dependent_p)
2881 error_not_base_type (scope, current_class_type);
2885 else if (!name_dependent_p)
2887 decl = lookup_member (binfo, name, 0, false);
2890 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2894 /* The binfo from which the functions came does not matter. */
2895 if (BASELINK_P (decl))
2896 decl = BASELINK_FUNCTIONS (decl);
2900 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2901 USING_DECL_DECLS (value) = decl;
2902 USING_DECL_SCOPE (value) = scope;
2903 DECL_DEPENDENT_P (value) = !decl;
2909 /* Return the binding value for name in scope. */
2912 namespace_binding (tree name, tree scope)
2914 cxx_binding *binding;
2917 scope = global_namespace;
2919 /* Unnecessary for the global namespace because it can't be an alias. */
2920 scope = ORIGINAL_NAMESPACE (scope);
2922 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2924 return binding ? binding->value : NULL_TREE;
2927 /* Set the binding value for name in scope. */
2930 set_namespace_binding (tree name, tree scope, tree val)
2934 timevar_push (TV_NAME_LOOKUP);
2935 if (scope == NULL_TREE)
2936 scope = global_namespace;
2937 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2938 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2941 supplement_binding (b, val);
2942 timevar_pop (TV_NAME_LOOKUP);
2945 /* Set the context of a declaration to scope. Complain if we are not
2949 set_decl_namespace (tree decl, tree scope, bool friendp)
2953 /* Get rid of namespace aliases. */
2954 scope = ORIGINAL_NAMESPACE (scope);
2956 /* It is ok for friends to be qualified in parallel space. */
2957 if (!friendp && !is_ancestor (current_namespace, scope))
2958 error ("declaration of %qD not in a namespace surrounding %qD",
2960 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2962 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2963 if (scope == current_namespace)
2965 if (at_namespace_scope_p ())
2966 error ("explicit qualification in declaration of %qD",
2971 /* See whether this has been declared in the namespace. */
2972 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2973 if (old == error_mark_node)
2974 /* No old declaration at all. */
2976 if (!is_overloaded_fn (decl))
2977 /* Don't compare non-function decls with decls_match here, since
2978 it can't check for the correct constness at this
2979 point. pushdecl will find those errors later. */
2981 /* Since decl is a function, old should contain a function decl. */
2982 if (!is_overloaded_fn (old))
2984 fn = OVL_CURRENT (old);
2985 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2987 /* A template can be explicitly specialized in any namespace. */
2988 if (processing_explicit_instantiation)
2990 if (processing_template_decl || processing_specialization)
2991 /* We have not yet called push_template_decl to turn a
2992 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2993 match. But, we'll check later, when we construct the
2996 /* Instantiations or specializations of templates may be declared as
2997 friends in any namespace. */
2998 if (friendp && DECL_USE_TEMPLATE (decl))
3000 if (is_overloaded_fn (old))
3002 for (; old; old = OVL_NEXT (old))
3003 if (decls_match (decl, OVL_CURRENT (old)))
3006 else if (decls_match (decl, old))
3009 error ("%qD should have been declared inside %qD", decl, scope);
3012 /* Return the namespace where the current declaration is declared. */
3015 current_decl_namespace (void)
3018 /* If we have been pushed into a different namespace, use it. */
3019 if (decl_namespace_list)
3020 return TREE_PURPOSE (decl_namespace_list);
3022 if (current_class_type)
3023 result = decl_namespace_context (current_class_type);
3024 else if (current_function_decl)
3025 result = decl_namespace_context (current_function_decl);
3027 result = current_namespace;
3031 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3032 select a name that is unique to this compilation unit. */
3035 push_namespace (tree name)
3037 push_namespace_with_attribs (name, NULL_TREE);
3040 /* Same, but specify attributes to apply to the namespace. The attributes
3041 only apply to the current namespace-body, not to any later extensions. */
3044 push_namespace_with_attribs (tree name, tree attributes)
3048 int implicit_use = 0;
3051 timevar_push (TV_NAME_LOOKUP);
3053 /* We should not get here if the global_namespace is not yet constructed
3054 nor if NAME designates the global namespace: The global scope is
3055 constructed elsewhere. */
3056 gcc_assert (global_namespace != NULL && name != global_scope_name);
3060 name = get_anonymous_namespace_name();
3061 d = IDENTIFIER_NAMESPACE_VALUE (name);
3063 /* Reopening anonymous namespace. */
3069 /* Check whether this is an extended namespace definition. */
3070 d = IDENTIFIER_NAMESPACE_VALUE (name);
3071 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3074 if (DECL_NAMESPACE_ALIAS (d))
3076 error ("namespace alias %qD not allowed here, assuming %qD",
3077 d, DECL_NAMESPACE_ALIAS (d));
3078 d = DECL_NAMESPACE_ALIAS (d);
3085 /* Make a new namespace, binding the name to it. */
3086 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3087 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3088 /* The name of this namespace is not visible to other translation
3089 units if it is an anonymous namespace or member thereof. */
3090 if (anon || decl_anon_ns_mem_p (current_namespace))
3091 TREE_PUBLIC (d) = 0;
3093 TREE_PUBLIC (d) = 1;
3097 /* Clear DECL_NAME for the benefit of debugging back ends. */
3098 SET_DECL_ASSEMBLER_NAME (d, name);
3099 DECL_NAME (d) = NULL_TREE;
3101 begin_scope (sk_namespace, d);
3104 resume_scope (NAMESPACE_LEVEL (d));
3107 do_using_directive (d);
3108 /* Enter the name space. */
3109 current_namespace = d;
3111 #ifdef HANDLE_PRAGMA_VISIBILITY
3112 /* Clear has_visibility in case a previous namespace-definition had a
3113 visibility attribute and this one doesn't. */
3114 current_binding_level->has_visibility = 0;
3115 for (d = attributes; d; d = TREE_CHAIN (d))
3117 tree name = TREE_PURPOSE (d);
3118 tree args = TREE_VALUE (d);
3121 if (! is_attribute_p ("visibility", name))
3123 warning (OPT_Wattributes, "%qs attribute directive ignored",
3124 IDENTIFIER_POINTER (name));
3128 x = args ? TREE_VALUE (args) : NULL_TREE;
3129 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3131 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3132 IDENTIFIER_POINTER (name));
3136 current_binding_level->has_visibility = 1;
3137 push_visibility (TREE_STRING_POINTER (x));
3143 timevar_pop (TV_NAME_LOOKUP);
3146 /* Pop from the scope of the current namespace. */
3149 pop_namespace (void)
3151 gcc_assert (current_namespace != global_namespace);
3152 current_namespace = CP_DECL_CONTEXT (current_namespace);
3153 /* The binding level is not popped, as it might be re-opened later. */
3157 /* Push into the scope of the namespace NS, even if it is deeply
3158 nested within another namespace. */
3161 push_nested_namespace (tree ns)
3163 if (ns == global_namespace)
3164 push_to_top_level ();
3167 push_nested_namespace (CP_DECL_CONTEXT (ns));
3168 push_namespace (DECL_NAME (ns));
3172 /* Pop back from the scope of the namespace NS, which was previously
3173 entered with push_nested_namespace. */
3176 pop_nested_namespace (tree ns)
3178 timevar_push (TV_NAME_LOOKUP);
3179 while (ns != global_namespace)
3182 ns = CP_DECL_CONTEXT (ns);
3185 pop_from_top_level ();
3186 timevar_pop (TV_NAME_LOOKUP);
3189 /* Temporarily set the namespace for the current declaration. */
3192 push_decl_namespace (tree decl)
3194 if (TREE_CODE (decl) != NAMESPACE_DECL)
3195 decl = decl_namespace_context (decl);
3196 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3197 NULL_TREE, decl_namespace_list);
3200 /* [namespace.memdef]/2 */
3203 pop_decl_namespace (void)
3205 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3208 /* Return the namespace that is the common ancestor
3209 of two given namespaces. */
3212 namespace_ancestor (tree ns1, tree ns2)
3214 timevar_push (TV_NAME_LOOKUP);
3215 if (is_ancestor (ns1, ns2))
3216 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3217 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3218 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3221 /* Process a namespace-alias declaration. */
3224 do_namespace_alias (tree alias, tree namespace)
3226 if (namespace == error_mark_node)
3229 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3231 namespace = ORIGINAL_NAMESPACE (namespace);
3233 /* Build the alias. */
3234 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3235 DECL_NAMESPACE_ALIAS (alias) = namespace;
3236 DECL_EXTERNAL (alias) = 1;
3237 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3240 /* Emit debug info for namespace alias. */
3241 (*debug_hooks->global_decl) (alias);
3244 /* Like pushdecl, only it places X in the current namespace,
3248 pushdecl_namespace_level (tree x, bool is_friend)
3250 struct cp_binding_level *b = current_binding_level;
3253 timevar_push (TV_NAME_LOOKUP);
3254 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3256 /* Now, the type_shadowed stack may screw us. Munge it so it does
3258 if (TREE_CODE (t) == TYPE_DECL)
3260 tree name = DECL_NAME (t);
3262 tree *ptr = (tree *)0;
3263 for (; !global_scope_p (b); b = b->level_chain)
3265 tree shadowed = b->type_shadowed;
3266 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3267 if (TREE_PURPOSE (shadowed) == name)
3269 ptr = &TREE_VALUE (shadowed);
3270 /* Can't break out of the loop here because sometimes
3271 a binding level will have duplicate bindings for
3272 PT names. It's gross, but I haven't time to fix it. */
3275 newval = TREE_TYPE (t);
3276 if (ptr == (tree *)0)
3278 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3279 up here if this is changed to an assertion. --KR */
3280 SET_IDENTIFIER_TYPE_VALUE (name, t);
3287 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3290 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3291 directive is not directly from the source. Also find the common
3292 ancestor and let our users know about the new namespace */
3294 add_using_namespace (tree user, tree used, bool indirect)
3297 timevar_push (TV_NAME_LOOKUP);
3298 /* Using oneself is a no-op. */
3301 timevar_pop (TV_NAME_LOOKUP);
3304 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3305 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3306 /* Check if we already have this. */
3307 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3311 /* Promote to direct usage. */
3312 TREE_INDIRECT_USING (t) = 0;
3313 timevar_pop (TV_NAME_LOOKUP);
3317 /* Add used to the user's using list. */
3318 DECL_NAMESPACE_USING (user)
3319 = tree_cons (used, namespace_ancestor (user, used),
3320 DECL_NAMESPACE_USING (user));
3322 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3324 /* Add user to the used's users list. */
3325 DECL_NAMESPACE_USERS (used)
3326 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3328 /* Recursively add all namespaces used. */
3329 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3330 /* indirect usage */
3331 add_using_namespace (user, TREE_PURPOSE (t), 1);
3333 /* Tell everyone using us about the new used namespaces. */
3334 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3335 add_using_namespace (TREE_PURPOSE (t), used, 1);
3336 timevar_pop (TV_NAME_LOOKUP);
3339 /* Process a using-declaration not appearing in class or local scope. */
3342 do_toplevel_using_decl (tree decl, tree scope, tree name)
3344 tree oldval, oldtype, newval, newtype;
3345 tree orig_decl = decl;
3346 cxx_binding *binding;
3348 decl = validate_nonmember_using_decl (decl, scope, name);
3349 if (decl == NULL_TREE)
3352 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3354 oldval = binding->value;
3355 oldtype = binding->type;
3357 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3359 /* Emit debug info. */
3360 if (!processing_template_decl)
3361 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3363 /* Copy declarations found. */
3365 binding->value = newval;
3367 binding->type = newtype;
3370 /* Process a using-directive. */
3373 do_using_directive (tree namespace)
3375 tree context = NULL_TREE;
3377 if (namespace == error_mark_node)
3380 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3382 if (building_stmt_tree ())
3383 add_stmt (build_stmt (USING_STMT, namespace));
3384 namespace = ORIGINAL_NAMESPACE (namespace);
3386 if (!toplevel_bindings_p ())
3388 push_using_directive (namespace);
3389 context = current_scope ();
3394 add_using_namespace (current_namespace, namespace, 0);
3395 if (current_namespace != global_namespace)
3396 context = current_namespace;
3399 /* Emit debugging info. */
3400 if (!processing_template_decl)
3401 (*debug_hooks->imported_module_or_decl) (namespace, context);
3404 /* Deal with a using-directive seen by the parser. Currently we only
3405 handle attributes here, since they cannot appear inside a template. */
3408 parse_using_directive (tree namespace, tree attribs)
3412 do_using_directive (namespace);
3414 for (a = attribs; a; a = TREE_CHAIN (a))
3416 tree name = TREE_PURPOSE (a);
3417 if (is_attribute_p ("strong", name))
3419 if (!toplevel_bindings_p ())
3420 error ("strong using only meaningful at namespace scope");
3421 else if (namespace != error_mark_node)
3423 if (!is_ancestor (current_namespace, namespace))
3424 error ("current namespace %qD does not enclose strongly used namespace %qD",
3425 current_namespace, namespace);
3426 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3427 = tree_cons (current_namespace, 0,
3428 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3432 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3436 /* Like pushdecl, only it places X in the global scope if appropriate.
3437 Calls cp_finish_decl to register the variable, initializing it with
3438 *INIT, if INIT is non-NULL. */
3441 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3443 timevar_push (TV_NAME_LOOKUP);
3444 push_to_top_level ();
3445 x = pushdecl_namespace_level (x, is_friend);
3447 finish_decl (x, *init, NULL_TREE);
3448 pop_from_top_level ();
3449 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3452 /* Like pushdecl, only it places X in the global scope if appropriate. */
3455 pushdecl_top_level (tree x)
3457 return pushdecl_top_level_1 (x, NULL, false);
3460 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3463 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3465 return pushdecl_top_level_1 (x, NULL, is_friend);
3468 /* Like pushdecl, only it places X in the global scope if
3469 appropriate. Calls cp_finish_decl to register the variable,
3470 initializing it with INIT. */
3473 pushdecl_top_level_and_finish (tree x, tree init)
3475 return pushdecl_top_level_1 (x, &init, false);
3478 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3479 duplicates. The first list becomes the tail of the result.
3481 The algorithm is O(n^2). We could get this down to O(n log n) by
3482 doing a sort on the addresses of the functions, if that becomes
3486 merge_functions (tree s1, tree s2)
3488 for (; s2; s2 = OVL_NEXT (s2))
3490 tree fn2 = OVL_CURRENT (s2);
3493 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3495 tree fn1 = OVL_CURRENT (fns1);
3497 /* If the function from S2 is already in S1, there is no
3498 need to add it again. For `extern "C"' functions, we
3499 might have two FUNCTION_DECLs for the same function, in
3500 different namespaces; again, we only need one of them. */
3502 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3503 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3507 /* If we exhausted all of the functions in S1, FN2 is new. */
3509 s1 = build_overload (fn2, s1);
3514 /* This should return an error not all definitions define functions.
3515 It is not an error if we find two functions with exactly the
3516 same signature, only if these are selected in overload resolution.
3517 old is the current set of bindings, new the freshly-found binding.
3518 XXX Do we want to give *all* candidates in case of ambiguity?
3519 XXX In what way should I treat extern declarations?
3520 XXX I don't want to repeat the entire duplicate_decls here */
3523 ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
3526 gcc_assert (old != NULL);
3528 /* Copy the type. */
3530 if (LOOKUP_NAMESPACES_ONLY (flags)
3531 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3534 /* Copy the value. */
3538 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3541 switch (TREE_CODE (val))
3544 /* If we expect types or namespaces, and not templates,
3545 or this is not a template class. */
3546 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3547 && !DECL_CLASS_TEMPLATE_P (val)))
3551 if (LOOKUP_NAMESPACES_ONLY (flags)
3552 || (type && (flags & LOOKUP_PREFER_TYPES)))
3555 case NAMESPACE_DECL:
3556 if (LOOKUP_TYPES_ONLY (flags))
3560 /* Ignore built-in functions that are still anticipated. */
3561 if (LOOKUP_QUALIFIERS_ONLY (flags))
3565 if (LOOKUP_QUALIFIERS_ONLY (flags))
3570 /* If val is hidden, shift down any class or enumeration name. */
3579 else if (val && val != old->value)
3581 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3582 old->value = merge_functions (old->value, val);
3585 old->value = tree_cons (NULL_TREE, old->value,
3586 build_tree_list (NULL_TREE, val));
3587 TREE_TYPE (old->value) = error_mark_node;
3593 else if (type && old->type != type)
3595 old->type = tree_cons (NULL_TREE, old->type,
3596 build_tree_list (NULL_TREE, type));
3597 TREE_TYPE (old->type) = error_mark_node;
3601 /* Return the declarations that are members of the namespace NS. */
3604 cp_namespace_decls (tree ns)
3606 return NAMESPACE_LEVEL (ns)->names;
3609 /* Combine prefer_type and namespaces_only into flags. */
3612 lookup_flags (int prefer_type, int namespaces_only)
3614 if (namespaces_only)
3615 return LOOKUP_PREFER_NAMESPACES;
3616 if (prefer_type > 1)
3617 return LOOKUP_PREFER_TYPES;
3618 if (prefer_type > 0)
3619 return LOOKUP_PREFER_BOTH;
3623 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3624 ignore it or not. Subroutine of lookup_name_real and
3625 lookup_type_scope. */
3628 qualify_lookup (tree val, int flags)
3630 if (val == NULL_TREE)
3632 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3634 if ((flags & LOOKUP_PREFER_TYPES)
3635 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3637 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3642 /* Given a lookup that returned VAL, decide if we want to ignore it or
3643 not based on DECL_ANTICIPATED. */
3646 hidden_name_p (tree val)
3649 && DECL_LANG_SPECIFIC (val)
3650 && DECL_ANTICIPATED (val))
3655 /* Remove any hidden friend functions from a possibly overloaded set
3659 remove_hidden_names (tree fns)
3664 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3666 else if (TREE_CODE (fns) == OVERLOAD)
3670 for (o = fns; o; o = OVL_NEXT (o))
3671 if (hidden_name_p (OVL_CURRENT (o)))
3677 for (o = fns; o; o = OVL_NEXT (o))
3678 if (!hidden_name_p (OVL_CURRENT (o)))
3679 n = build_overload (OVL_CURRENT (o), n);
3687 /* Unscoped lookup of a global: iterate over current namespaces,
3688 considering using-directives. */
3691 unqualified_namespace_lookup (tree name, int flags)
3693 tree initial = current_decl_namespace ();
3694 tree scope = initial;
3696 struct cp_binding_level *level;
3697 tree val = NULL_TREE;
3699 timevar_push (TV_NAME_LOOKUP);
3701 for (; !val; scope = CP_DECL_CONTEXT (scope))
3703 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3705 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3708 ambiguous_decl (&binding, b, flags);
3710 /* Add all _DECLs seen through local using-directives. */
3711 for (level = current_binding_level;
3712 level->kind != sk_namespace;
3713 level = level->level_chain)
3714 if (!lookup_using_namespace (name, &binding, level->using_directives,
3716 /* Give up because of error. */
3717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3719 /* Add all _DECLs seen through global using-directives. */
3720 /* XXX local and global using lists should work equally. */
3724 if (!lookup_using_namespace (name, &binding,
3725 DECL_NAMESPACE_USING (siter),
3727 /* Give up because of error. */
3728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3729 if (siter == scope) break;
3730 siter = CP_DECL_CONTEXT (siter);
3733 val = binding.value;
3734 if (scope == global_namespace)
3737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3740 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3741 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3744 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3745 declaration found. If no suitable declaration can be found,
3746 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3747 neither a class-type nor a namespace a diagnostic is issued. */
3750 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3755 if (TREE_CODE (scope) == NAMESPACE_DECL)
3757 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3759 flags |= LOOKUP_COMPLAIN;
3761 flags |= LOOKUP_PREFER_TYPES;
3762 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3765 else if (is_aggr_type (scope, complain))
3766 t = lookup_member (scope, name, 2, is_type_p);
3769 return error_mark_node;
3773 /* Subroutine of unqualified_namespace_lookup:
3774 Add the bindings of NAME in used namespaces to VAL.
3775 We are currently looking for names in namespace SCOPE, so we
3776 look through USINGS for using-directives of namespaces
3777 which have SCOPE as a common ancestor with the current scope.
3778 Returns false on errors. */
3781 lookup_using_namespace (tree name, struct scope_binding *val,
3782 tree usings, tree scope, int flags)
3785 timevar_push (TV_NAME_LOOKUP);
3786 /* Iterate over all used namespaces in current, searching for using
3787 directives of scope. */
3788 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3789 if (TREE_VALUE (iter) == scope)
3791 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3793 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3794 /* Resolve ambiguities. */
3796 ambiguous_decl (val, val1, flags);
3798 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3802 Accepts the NAME to lookup and its qualifying SCOPE.
3803 Returns the name/type pair found into the cxx_binding *RESULT,
3804 or false on error. */
3807 qualified_lookup_using_namespace (tree name, tree scope,
3808 struct scope_binding *result, int flags)
3810 /* Maintain a list of namespaces visited... */
3811 tree seen = NULL_TREE;
3812 /* ... and a list of namespace yet to see. */
3813 tree todo = NULL_TREE;
3814 tree todo_maybe = NULL_TREE;
3816 timevar_push (TV_NAME_LOOKUP);
3817 /* Look through namespace aliases. */
3818 scope = ORIGINAL_NAMESPACE (scope);
3819 while (scope && result->value != error_mark_node)
3821 cxx_binding *binding =
3822 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3823 seen = tree_cons (scope, NULL_TREE, seen);
3825 ambiguous_decl (result, binding, flags);
3827 /* Consider strong using directives always, and non-strong ones
3828 if we haven't found a binding yet. ??? Shouldn't we consider
3829 non-strong ones if the initial RESULT is non-NULL, but the
3830 binding in the given namespace is? */
3831 for (usings = DECL_NAMESPACE_USING (scope); usings;
3832 usings = TREE_CHAIN (usings))
3833 /* If this was a real directive, and we have not seen it. */
3834 if (!TREE_INDIRECT_USING (usings))
3836 /* Try to avoid queuing the same namespace more than once,
3837 the exception being when a namespace was already
3838 enqueued for todo_maybe and then a strong using is
3839 found for it. We could try to remove it from
3840 todo_maybe, but it's probably not worth the effort. */
3841 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3842 && !purpose_member (TREE_PURPOSE (usings), seen)
3843 && !purpose_member (TREE_PURPOSE (usings), todo))
3844 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3845 else if ((!result->value && !result->type)
3846 && !purpose_member (TREE_PURPOSE (usings), seen)
3847 && !purpose_member (TREE_PURPOSE (usings), todo)
3848 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3849 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3854 scope = TREE_PURPOSE (todo);
3855 todo = TREE_CHAIN (todo);
3858 && (!result->value && !result->type))
3860 scope = TREE_PURPOSE (todo_maybe);
3861 todo = TREE_CHAIN (todo_maybe);
3862 todo_maybe = NULL_TREE;
3865 scope = NULL_TREE; /* If there never was a todo list. */
3867 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3870 /* Return the innermost non-namespace binding for NAME from a scope
3871 containing BINDING, or, if BINDING is NULL, the current scope. If
3872 CLASS_P is false, then class bindings are ignored. */
3875 outer_binding (tree name,
3876 cxx_binding *binding,
3881 cxx_scope *outer_scope;
3885 scope = binding->scope->level_chain;
3886 outer = binding->previous;
3890 scope = current_binding_level;
3891 outer = IDENTIFIER_BINDING (name);
3893 outer_scope = outer ? outer->scope : NULL;
3895 /* Because we create class bindings lazily, we might be missing a
3896 class binding for NAME. If there are any class binding levels
3897 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3898 declared, we must lookup NAME in those class scopes. */
3900 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3902 if (scope->kind == sk_class)
3904 cxx_binding *class_binding;
3906 class_binding = get_class_binding (name, scope);
3909 /* Thread this new class-scope binding onto the
3910 IDENTIFIER_BINDING list so that future lookups
3912 class_binding->previous = outer;
3914 binding->previous = class_binding;
3916 IDENTIFIER_BINDING (name) = class_binding;
3917 return class_binding;
3920 scope = scope->level_chain;
3926 /* Return the innermost block-scope or class-scope value binding for
3927 NAME, or NULL_TREE if there is no such binding. */
3930 innermost_non_namespace_value (tree name)
3932 cxx_binding *binding;
3933 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3934 return binding ? binding->value : NULL_TREE;
3937 /* Look up NAME in the current binding level and its superiors in the
3938 namespace of variables, functions and typedefs. Return a ..._DECL
3939 node of some kind representing its definition if there is only one
3940 such declaration, or return a TREE_LIST with all the overloaded
3941 definitions if there are many, or return 0 if it is undefined.
3942 Hidden name, either friend declaration or built-in function, are
3945 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3946 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3947 Otherwise we prefer non-TYPE_DECLs.
3949 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3950 BLOCK_P is false, bindings in block scopes are ignored. */
3953 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3954 int namespaces_only, int flags)
3957 tree val = NULL_TREE;
3959 timevar_push (TV_NAME_LOOKUP);
3960 /* Conversion operators are handled specially because ordinary
3961 unqualified name lookup will not find template conversion
3963 if (IDENTIFIER_TYPENAME_P (name))
3965 struct cp_binding_level *level;
3967 for (level = current_binding_level;
3968 level && level->kind != sk_namespace;
3969 level = level->level_chain)
3974 /* A conversion operator can only be declared in a class
3976 if (level->kind != sk_class)
3979 /* Lookup the conversion operator in the class. */
3980 class_type = level->this_entity;
3981 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3983 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3989 flags |= lookup_flags (prefer_type, namespaces_only);
3991 /* First, look in non-namespace scopes. */
3993 if (current_class_type == NULL_TREE)
3996 if (block_p || !nonclass)
3997 for (iter = outer_binding (name, NULL, !nonclass);
3999 iter = outer_binding (name, iter, !nonclass))
4003 /* Skip entities we don't want. */
4004 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4007 /* If this is the kind of thing we're looking for, we're done. */
4008 if (qualify_lookup (iter->value, flags))
4009 binding = iter->value;
4010 else if ((flags & LOOKUP_PREFER_TYPES)
4011 && qualify_lookup (iter->type, flags))
4012 binding = iter->type;
4014 binding = NULL_TREE;
4018 if (hidden_name_p (binding))
4020 /* A non namespace-scope binding can only be hidden if
4021 we are in a local class, due to friend declarations.
4022 In particular, consider:
4027 void g() { B* b; } // error: B is hidden
4032 The standard says that "B" is a local class in "f"
4033 (but not nested within "A") -- but that name lookup
4034 for "B" does not find this declaration until it is
4035 declared directly with "f".
4041 If a friend declaration appears in a local class and
4042 the name specified is an unqualified name, a prior
4043 declaration is looked up without considering scopes
4044 that are outside the innermost enclosing non-class
4045 scope. For a friend class declaration, if there is no
4046 prior declaration, the class that is specified
4047 belongs to the innermost enclosing non-class scope,
4048 but if it is subsequently referenced, its name is not
4049 found by name lookup until a matching declaration is
4050 provided in the innermost enclosing nonclass scope.
4052 gcc_assert (current_class_type &&
4053 LOCAL_CLASS_P (current_class_type));
4055 /* This binding comes from a friend declaration in the local
4056 class. The standard (11.4.8) states that the lookup can
4057 only succeed if there is a non-hidden declaration in the
4058 current scope, which is not the case here. */
4059 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4066 /* Now lookup in namespace scopes. */
4068 val = unqualified_namespace_lookup (name, flags);
4070 /* If we have a single function from a using decl, pull it out. */
4071 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4072 val = OVL_FUNCTION (val);
4074 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4078 lookup_name_nonclass (tree name)
4080 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4084 lookup_function_nonclass (tree name, tree args, bool block_p)
4087 lookup_arg_dependent (name,
4088 lookup_name_real (name, 0, 1, block_p, 0,
4094 lookup_name (tree name)
4096 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4100 lookup_name_prefer_type (tree name, int prefer_type)
4102 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4103 0, LOOKUP_COMPLAIN);
4106 /* Look up NAME for type used in elaborated name specifier in
4107 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4108 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4109 name, more scopes are checked if cleanup or template parameter
4110 scope is encountered.
4112 Unlike lookup_name_real, we make sure that NAME is actually
4113 declared in the desired scope, not from inheritance, nor using
4114 directive. For using declaration, there is DR138 still waiting
4115 to be resolved. Hidden name coming from an earlier friend
4116 declaration is also returned.
4118 A TYPE_DECL best matching the NAME is returned. Catching error
4119 and issuing diagnostics are caller's responsibility. */
4122 lookup_type_scope (tree name, tag_scope scope)
4124 cxx_binding *iter = NULL;
4125 tree val = NULL_TREE;
4127 timevar_push (TV_NAME_LOOKUP);
4129 /* Look in non-namespace scope first. */
4130 if (current_binding_level->kind != sk_namespace)
4131 iter = outer_binding (name, NULL, /*class_p=*/ true);
4132 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4134 /* Check if this is the kind of thing we're looking for.
4135 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4136 base class. For ITER->VALUE, we can simply use
4137 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4140 We check ITER->TYPE before ITER->VALUE in order to handle
4141 typedef struct C {} C;
4144 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4145 && (scope != ts_current
4146 || LOCAL_BINDING_P (iter)
4147 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4149 else if ((scope != ts_current
4150 || !INHERITED_VALUE_BINDING_P (iter))
4151 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4158 /* Look in namespace scope. */
4161 iter = cxx_scope_find_binding_for_name
4162 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4166 /* If this is the kind of thing we're looking for, we're done. */
4167 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4169 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4175 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4176 and template parameter scopes. */
4179 struct cp_binding_level *b = current_binding_level;
4182 if (iter->scope == b)
4183 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4185 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4187 else if (b->kind == sk_class
4188 && scope == ts_within_enclosing_non_class)
4195 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4198 /* Similar to `lookup_name' but look only in the innermost non-class
4202 lookup_name_innermost_nonclass_level (tree name)
4204 struct cp_binding_level *b;
4207 timevar_push (TV_NAME_LOOKUP);
4208 b = innermost_nonclass_level ();
4210 if (b->kind == sk_namespace)
4212 t = IDENTIFIER_NAMESPACE_VALUE (name);
4214 /* extern "C" function() */
4215 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4218 else if (IDENTIFIER_BINDING (name)
4219 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4221 cxx_binding *binding;
4222 binding = IDENTIFIER_BINDING (name);
4225 if (binding->scope == b
4226 && !(TREE_CODE (binding->value) == VAR_DECL
4227 && DECL_DEAD_FOR_LOCAL (binding->value)))
4228 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4230 if (b->kind == sk_cleanup)
4237 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4240 /* Like lookup_name_innermost_nonclass_level, but for types. */
4243 lookup_type_current_level (tree name)
4247 timevar_push (TV_NAME_LOOKUP);
4248 gcc_assert (current_binding_level->kind != sk_namespace);
4250 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4251 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4253 struct cp_binding_level *b = current_binding_level;
4256 if (purpose_member (name, b->type_shadowed))
4257 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4258 REAL_IDENTIFIER_TYPE_VALUE (name));
4259 if (b->kind == sk_cleanup)
4266 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4269 /* [basic.lookup.koenig] */
4270 /* A nonzero return value in the functions below indicates an error. */
4281 static bool arg_assoc (struct arg_lookup*, tree);
4282 static bool arg_assoc_args (struct arg_lookup*, tree);
4283 static bool arg_assoc_type (struct arg_lookup*, tree);
4284 static bool add_function (struct arg_lookup *, tree);
4285 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4286 static bool arg_assoc_class (struct arg_lookup *, tree);
4287 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4289 /* Add a function to the lookup structure.
4290 Returns true on error. */
4293 add_function (struct arg_lookup *k, tree fn)
4295 /* We used to check here to see if the function was already in the list,
4296 but that's O(n^2), which is just too expensive for function lookup.
4297 Now we deal with the occasional duplicate in joust. In doing this, we
4298 assume that the number of duplicates will be small compared to the
4299 total number of functions being compared, which should usually be the
4302 /* We must find only functions, or exactly one non-function. */
4305 else if (fn == k->functions)
4307 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4308 k->functions = build_overload (fn, k->functions);
4311 tree f1 = OVL_CURRENT (k->functions);
4313 if (is_overloaded_fn (f1))
4315 fn = f1; f1 = f2; f2 = fn;
4317 error ("%q+D is not a function,", f1);
4318 error (" conflict with %q+D", f2);
4319 error (" in call to %qD", k->name);
4326 /* Returns true iff CURRENT has declared itself to be an associated
4327 namespace of SCOPE via a strong using-directive (or transitive chain
4328 thereof). Both are namespaces. */
4331 is_associated_namespace (tree current, tree scope)
4333 tree seen = NULL_TREE;
4334 tree todo = NULL_TREE;
4338 if (scope == current)
4340 seen = tree_cons (scope, NULL_TREE, seen);
4341 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4342 if (!purpose_member (TREE_PURPOSE (t), seen))
4343 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4346 scope = TREE_PURPOSE (todo);
4347 todo = TREE_CHAIN (todo);
4354 /* Return whether FN is a friend of an associated class of ARG. */
4357 friend_of_associated_class_p (tree arg, tree fn)
4363 else if (type_unknown_p (arg))
4366 type = TREE_TYPE (arg);
4368 /* If TYPE is a class, the class itself and all base classes are
4369 associated classes. */
4370 if (CLASS_TYPE_P (type))
4372 if (is_friend (type, fn))
4375 if (TYPE_BINFO (type))
4377 tree binfo, base_binfo;
4380 for (binfo = TYPE_BINFO (type), i = 0;
4381 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4383 if (is_friend (BINFO_TYPE (base_binfo), fn))
4388 /* If TYPE is a class member, the class of which it is a member is
4389 an associated class. */
4390 if ((CLASS_TYPE_P (type)
4391 || TREE_CODE (type) == UNION_TYPE
4392 || TREE_CODE (type) == ENUMERAL_TYPE)
4393 && TYPE_CONTEXT (type)
4394 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4395 && is_friend (TYPE_CONTEXT (type), fn))
4401 /* Add functions of a namespace to the lookup structure.
4402 Returns true on error. */
4405 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4409 if (purpose_member (scope, k->namespaces))
4411 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4413 /* Check out our super-users. */
4414 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4415 value = TREE_CHAIN (value))
4416 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4419 value = namespace_binding (k->name, scope);
4423 for (; value; value = OVL_NEXT (value))
4425 /* We don't want to find arbitrary hidden functions via argument
4426 dependent lookup. We only want to find friends of associated
4428 if (hidden_name_p (OVL_CURRENT (value)))
4432 for (args = k->args; args; args = TREE_CHAIN (args))
4433 if (friend_of_associated_class_p (TREE_VALUE (args),
4434 OVL_CURRENT (value)))
4440 if (add_function (k, OVL_CURRENT (value)))
4447 /* Adds everything associated with a template argument to the lookup
4448 structure. Returns true on error. */
4451 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4453 /* [basic.lookup.koenig]
4455 If T is a template-id, its associated namespaces and classes are
4456 ... the namespaces and classes associated with the types of the
4457 template arguments provided for template type parameters
4458 (excluding template template parameters); the namespaces in which
4459 any template template arguments are defined; and the classes in
4460 which any member templates used as template template arguments
4461 are defined. [Note: non-type template arguments do not
4462 contribute to the set of associated namespaces. ] */
4464 /* Consider first template template arguments. */
4465 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4466 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4468 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4470 tree ctx = CP_DECL_CONTEXT (arg);
4472 /* It's not a member template. */
4473 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4474 return arg_assoc_namespace (k, ctx);
4475 /* Otherwise, it must be member template. */
4477 return arg_assoc_class (k, ctx);
4479 /* It's not a template template argument, but it is a type template
4481 else if (TYPE_P (arg))
4482 return arg_assoc_type (k, arg);
4483 /* It's a non-type template argument. */
4488 /* Adds everything associated with class to the lookup structure.
4489 Returns true on error. */
4492 arg_assoc_class (struct arg_lookup *k, tree type)
4494 tree list, friends, context;
4497 /* Backend build structures, such as __builtin_va_list, aren't
4498 affected by all this. */
4499 if (!CLASS_TYPE_P (type))
4502 if (purpose_member (type, k->classes))
4504 k->classes = tree_cons (type, NULL_TREE, k->classes);
4506 context = decl_namespace_context (type);
4507 if (arg_assoc_namespace (k, context))
4510 if (TYPE_BINFO (type))
4512 /* Process baseclasses. */
4513 tree binfo, base_binfo;
4515 for (binfo = TYPE_BINFO (type), i = 0;
4516 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4517 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4521 /* Process friends. */
4522 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4523 list = TREE_CHAIN (list))
4524 if (k->name == FRIEND_NAME (list))
4525 for (friends = FRIEND_DECLS (list); friends;
4526 friends = TREE_CHAIN (friends))
4528 tree fn = TREE_VALUE (friends);
4530 /* Only interested in global functions with potentially hidden
4531 (i.e. unqualified) declarations. */
4532 if (CP_DECL_CONTEXT (fn) != context)
4534 /* Template specializations are never found by name lookup.
4535 (Templates themselves can be found, but not template
4536 specializations.) */
4537 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4539 if (add_function (k, fn))
4543 /* Process template arguments. */
4544 if (CLASSTYPE_TEMPLATE_INFO (type)
4545 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4547 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4548 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4549 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4555 /* Adds everything associated with a given type.
4556 Returns 1 on error. */
4559 arg_assoc_type (struct arg_lookup *k, tree type)
4561 /* As we do not get the type of non-type dependent expressions
4562 right, we can end up with such things without a type. */
4566 if (TYPE_PTRMEM_P (type))
4568 /* Pointer to member: associate class type and value type. */
4569 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4571 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4573 else switch (TREE_CODE (type))
4585 if (TYPE_PTRMEMFUNC_P (type))
4586 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4587 return arg_assoc_class (k, type);
4589 case REFERENCE_TYPE:
4591 return arg_assoc_type (k, TREE_TYPE (type));
4594 return arg_assoc_namespace (k, decl_namespace_context (type));
4596 /* The basetype is referenced in the first arg type, so just
4599 /* Associate the parameter types. */
4600 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4602 /* Associate the return type. */
4603 return arg_assoc_type (k, TREE_TYPE (type));
4604 case TEMPLATE_TYPE_PARM:
4605 case BOUND_TEMPLATE_TEMPLATE_PARM:
4610 gcc_assert (type == unknown_type_node);
4612 case TYPE_PACK_EXPANSION:
4613 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4614 case TYPE_ARGUMENT_PACK:
4616 tree args = ARGUMENT_PACK_ARGS (type);
4617 int i, len = TREE_VEC_LENGTH (args);
4618 for (i = 0; i < len; i++)
4619 if (arg_assoc_type (k, TREE_VEC_ELT (args, i)))
4630 /* Adds everything associated with arguments. Returns true on error. */
4633 arg_assoc_args (struct arg_lookup *k, tree args)
4635 for (; args; args = TREE_CHAIN (args))
4636 if (arg_assoc (k, TREE_VALUE (args)))
4641 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4644 arg_assoc (struct arg_lookup *k, tree n)
4646 if (n == error_mark_node)
4650 return arg_assoc_type (k, n);
4652 if (! type_unknown_p (n))
4653 return arg_assoc_type (k, TREE_TYPE (n));
4655 if (TREE_CODE (n) == ADDR_EXPR)
4656 n = TREE_OPERAND (n, 0);
4657 if (TREE_CODE (n) == COMPONENT_REF)
4658 n = TREE_OPERAND (n, 1);
4659 if (TREE_CODE (n) == OFFSET_REF)
4660 n = TREE_OPERAND (n, 1);
4661 while (TREE_CODE (n) == TREE_LIST)
4663 if (TREE_CODE (n) == BASELINK)
4664 n = BASELINK_FUNCTIONS (n);
4666 if (TREE_CODE (n) == FUNCTION_DECL)
4667 return arg_assoc_type (k, TREE_TYPE (n));
4668 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4670 /* [basic.lookup.koenig]
4672 If T is a template-id, its associated namespaces and classes
4673 are the namespace in which the template is defined; for
4674 member templates, the member template's class... */
4675 tree template = TREE_OPERAND (n, 0);
4676 tree args = TREE_OPERAND (n, 1);
4680 if (TREE_CODE (template) == COMPONENT_REF)
4681 template = TREE_OPERAND (template, 1);
4683 /* First, the template. There may actually be more than one if
4684 this is an overloaded function template. But, in that case,
4685 we only need the first; all the functions will be in the same
4687 template = OVL_CURRENT (template);
4689 ctx = CP_DECL_CONTEXT (template);
4691 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4693 if (arg_assoc_namespace (k, ctx) == 1)
4696 /* It must be a member template. */
4697 else if (arg_assoc_class (k, ctx) == 1)
4700 /* Now the arguments. */
4702 for (ix = TREE_VEC_LENGTH (args); ix--;)
4703 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4706 else if (TREE_CODE (n) == OVERLOAD)
4708 for (; n; n = OVL_CHAIN (n))
4709 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4716 /* Performs Koenig lookup depending on arguments, where fns
4717 are the functions found in normal lookup. */
4720 lookup_arg_dependent (tree name, tree fns, tree args)
4722 struct arg_lookup k;
4724 timevar_push (TV_NAME_LOOKUP);
4726 /* Remove any hidden friend functions from the list of functions
4727 found so far. They will be added back by arg_assoc_class as
4729 fns = remove_hidden_names (fns);
4734 k.classes = NULL_TREE;
4736 /* We previously performed an optimization here by setting
4737 NAMESPACES to the current namespace when it was safe. However, DR
4738 164 says that namespaces that were already searched in the first
4739 stage of template processing are searched again (potentially
4740 picking up later definitions) in the second stage. */
4741 k.namespaces = NULL_TREE;
4743 arg_assoc_args (&k, args);
4748 && TREE_CODE (fns) != VAR_DECL
4749 && !is_overloaded_fn (fns))
4751 error ("argument dependent lookup finds %q+D", fns);
4752 error (" in call to %qD", name);
4753 fns = error_mark_node;
4756 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4759 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4760 changed (i.e. there was already a directive), or the fresh
4761 TREE_LIST otherwise. */
4764 push_using_directive (tree used)
4766 tree ud = current_binding_level->using_directives;
4767 tree iter, ancestor;
4769 timevar_push (TV_NAME_LOOKUP);
4770 /* Check if we already have this. */
4771 if (purpose_member (used, ud) != NULL_TREE)
4772 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4774 ancestor = namespace_ancestor (current_decl_namespace (), used);
4775 ud = current_binding_level->using_directives;
4776 ud = tree_cons (used, ancestor, ud);
4777 current_binding_level->using_directives = ud;
4779 /* Recursively add all namespaces used. */
4780 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4781 push_using_directive (TREE_PURPOSE (iter));
4783 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4786 /* The type TYPE is being declared. If it is a class template, or a
4787 specialization of a class template, do any processing required and
4788 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4789 being declared a friend. B is the binding level at which this TYPE
4792 Returns the TYPE_DECL for TYPE, which may have been altered by this
4796 maybe_process_template_type_declaration (tree type, int is_friend,
4799 tree decl = TYPE_NAME (type);
4801 if (processing_template_parmlist)
4802 /* You can't declare a new template type in a template parameter
4803 list. But, you can declare a non-template type:
4805 template <class A*> struct S;
4807 is a forward-declaration of `A'. */
4809 else if (b->kind == sk_namespace
4810 && current_binding_level->kind != sk_namespace)
4811 /* If this new type is being injected into a containing scope,
4812 then it's not a template type. */
4816 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4818 if (processing_template_decl)
4820 /* This may change after the call to
4821 push_template_decl_real, but we want the original value. */
4822 tree name = DECL_NAME (decl);
4824 decl = push_template_decl_real (decl, is_friend);
4825 /* If the current binding level is the binding level for the
4826 template parameters (see the comment in
4827 begin_template_parm_list) and the enclosing level is a class
4828 scope, and we're not looking at a friend, push the
4829 declaration of the member class into the class scope. In the
4830 friend case, push_template_decl will already have put the
4831 friend into global scope, if appropriate. */
4832 if (TREE_CODE (type) != ENUMERAL_TYPE
4833 && !is_friend && b->kind == sk_template_parms
4834 && b->level_chain->kind == sk_class)
4836 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4838 if (!COMPLETE_TYPE_P (current_class_type))
4840 maybe_add_class_template_decl_list (current_class_type,
4841 type, /*friend_p=*/0);
4842 /* Put this UTD in the table of UTDs for the class. */
4843 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4844 CLASSTYPE_NESTED_UTDS (current_class_type) =
4845 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4847 binding_table_insert
4848 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4857 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4858 that the NAME is a class template, the tag is processed but not pushed.
4860 The pushed scope depend on the SCOPE parameter:
4861 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4863 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4864 non-template-parameter scope. This case is needed for forward
4866 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4867 TS_GLOBAL case except that names within template-parameter scopes
4868 are not pushed at all.
4870 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4873 pushtag (tree name, tree type, tag_scope scope)
4875 struct cp_binding_level *b;
4878 timevar_push (TV_NAME_LOOKUP);
4879 b = current_binding_level;
4880 while (/* Cleanup scopes are not scopes from the point of view of
4882 b->kind == sk_cleanup
4883 /* Neither are the scopes used to hold template parameters
4884 for an explicit specialization. For an ordinary template
4885 declaration, these scopes are not scopes from the point of
4886 view of the language. */
4887 || (b->kind == sk_template_parms
4888 && (b->explicit_spec_p || scope == ts_global))
4889 || (b->kind == sk_class
4890 && (scope != ts_current
4891 /* We may be defining a new type in the initializer
4892 of a static member variable. We allow this when
4893 not pedantic, and it is particularly useful for
4894 type punning via an anonymous union. */
4895 || COMPLETE_TYPE_P (b->this_entity))))
4898 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4900 /* Do C++ gratuitous typedefing. */
4901 if (IDENTIFIER_TYPE_VALUE (name) != type)
4905 tree context = TYPE_CONTEXT (type);
4909 tree cs = current_scope ();
4911 if (scope == ts_current)
4913 else if (cs != NULL_TREE && TYPE_P (cs))
4914 /* When declaring a friend class of a local class, we want
4915 to inject the newly named class into the scope
4916 containing the local class, not the namespace
4918 context = decl_function_context (get_type_decl (cs));
4921 context = current_namespace;
4923 if (b->kind == sk_class
4924 || (b->kind == sk_template_parms
4925 && b->level_chain->kind == sk_class))
4928 if (current_lang_name == lang_name_java)
4929 TYPE_FOR_JAVA (type) = 1;
4931 tdef = create_implicit_typedef (name, type);
4932 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4933 if (scope == ts_within_enclosing_non_class)
4935 /* This is a friend. Make this TYPE_DECL node hidden from
4936 ordinary name lookup. Its corresponding TEMPLATE_DECL
4937 will be marked in push_template_decl_real. */
4938 retrofit_lang_decl (tdef);
4939 DECL_ANTICIPATED (tdef) = 1;
4940 DECL_FRIEND_P (tdef) = 1;
4943 decl = maybe_process_template_type_declaration
4944 (type, scope == ts_within_enclosing_non_class, b);
4945 if (decl == error_mark_node)
4946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4949 set_identifier_type_value_with_scope (name, tdef, b);
4951 if (b->kind == sk_class)
4953 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4954 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4955 class. But if it's a member template class, we want
4956 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4958 finish_member_declaration (decl);
4960 pushdecl_class_level (decl);
4962 else if (b->kind != sk_template_parms)
4964 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4965 if (decl == error_mark_node)
4966 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4969 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4971 /* If this is a local class, keep track of it. We need this
4972 information for name-mangling, and so that it is possible to
4973 find all function definitions in a translation unit in a
4974 convenient way. (It's otherwise tricky to find a member
4975 function definition it's only pointed to from within a local
4977 if (TYPE_CONTEXT (type)
4978 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4979 VEC_safe_push (tree, gc, local_classes, type);
4981 if (b->kind == sk_class
4982 && !COMPLETE_TYPE_P (current_class_type))
4984 maybe_add_class_template_decl_list (current_class_type,
4985 type, /*friend_p=*/0);
4987 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4988 CLASSTYPE_NESTED_UTDS (current_class_type)
4989 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4991 binding_table_insert
4992 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4995 decl = TYPE_NAME (type);
4996 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
4997 TYPE_STUB_DECL (type) = decl;
4999 /* Set type visibility now if this is a forward declaration. */
5000 TREE_PUBLIC (decl) = 1;
5001 determine_visibility (decl);
5003 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5006 /* Subroutines for reverting temporarily to top-level for instantiation
5007 of templates and such. We actually need to clear out the class- and
5008 local-value slots of all identifiers, so that only the global values
5009 are at all visible. Simply setting current_binding_level to the global
5010 scope isn't enough, because more binding levels may be pushed. */
5011 struct saved_scope *scope_chain;
5013 /* If ID has not already been marked, add an appropriate binding to
5017 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5019 cxx_saved_binding *saved;
5021 if (!id || !IDENTIFIER_BINDING (id))
5024 if (IDENTIFIER_MARKED (id))
5027 IDENTIFIER_MARKED (id) = 1;
5029 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5030 saved->identifier = id;
5031 saved->binding = IDENTIFIER_BINDING (id);
5032 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5033 IDENTIFIER_BINDING (id) = NULL;
5037 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5041 timevar_push (TV_NAME_LOOKUP);
5042 for (t = names; t; t = TREE_CHAIN (t))
5046 if (TREE_CODE (t) == TREE_LIST)
5047 id = TREE_PURPOSE (t);
5051 store_binding (id, old_bindings);
5053 timevar_pop (TV_NAME_LOOKUP);
5056 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5057 objects, rather than a TREE_LIST. */
5060 store_class_bindings (VEC(cp_class_binding,gc) *names,
5061 VEC(cxx_saved_binding,gc) **old_bindings)
5064 cp_class_binding *cb;
5066 timevar_push (TV_NAME_LOOKUP);
5067 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5068 store_binding (cb->identifier, old_bindings);
5069 timevar_pop (TV_NAME_LOOKUP);
5073 push_to_top_level (void)
5075 struct saved_scope *s;
5076 struct cp_binding_level *b;
5077 cxx_saved_binding *sb;
5081 timevar_push (TV_NAME_LOOKUP);
5082 s = GGC_CNEW (struct saved_scope);
5084 b = scope_chain ? current_binding_level : 0;
5086 /* If we're in the middle of some function, save our state. */
5090 push_function_context_to (NULL_TREE);
5095 if (scope_chain && previous_class_level)
5096 store_class_bindings (previous_class_level->class_shadowed,
5099 /* Have to include the global scope, because class-scope decls
5100 aren't listed anywhere useful. */
5101 for (; b; b = b->level_chain)
5105 /* Template IDs are inserted into the global level. If they were
5106 inserted into namespace level, finish_file wouldn't find them
5107 when doing pending instantiations. Therefore, don't stop at
5108 namespace level, but continue until :: . */
5109 if (global_scope_p (b))
5112 store_bindings (b->names, &s->old_bindings);
5113 /* We also need to check class_shadowed to save class-level type
5114 bindings, since pushclass doesn't fill in b->names. */
5115 if (b->kind == sk_class)
5116 store_class_bindings (b->class_shadowed, &s->old_bindings);
5118 /* Unwind type-value slots back to top level. */
5119 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5120 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5123 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5124 IDENTIFIER_MARKED (sb->identifier) = 0;
5126 s->prev = scope_chain;
5128 s->need_pop_function_context = need_pop;
5129 s->function_decl = current_function_decl;
5130 s->skip_evaluation = skip_evaluation;
5133 current_function_decl = NULL_TREE;
5134 current_lang_base = VEC_alloc (tree, gc, 10);
5135 current_lang_name = lang_name_cplusplus;
5136 current_namespace = global_namespace;
5137 push_class_stack ();
5138 skip_evaluation = 0;
5139 timevar_pop (TV_NAME_LOOKUP);
5143 pop_from_top_level (void)
5145 struct saved_scope *s = scope_chain;
5146 cxx_saved_binding *saved;
5149 timevar_push (TV_NAME_LOOKUP);
5150 /* Clear out class-level bindings cache. */
5151 if (previous_class_level)
5152 invalidate_class_lookup_cache ();
5155 current_lang_base = 0;
5157 scope_chain = s->prev;
5158 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5160 tree id = saved->identifier;
5162 IDENTIFIER_BINDING (id) = saved->binding;
5163 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5166 /* If we were in the middle of compiling a function, restore our
5168 if (s->need_pop_function_context)
5169 pop_function_context_from (NULL_TREE);
5170 current_function_decl = s->function_decl;
5171 skip_evaluation = s->skip_evaluation;
5172 timevar_pop (TV_NAME_LOOKUP);
5175 /* Pop off extraneous binding levels left over due to syntax errors.
5177 We don't pop past namespaces, as they might be valid. */
5180 pop_everything (void)
5182 if (ENABLE_SCOPE_CHECKING)
5183 verbatim ("XXX entering pop_everything ()\n");
5184 while (!toplevel_bindings_p ())
5186 if (current_binding_level->kind == sk_class)
5187 pop_nested_class ();
5191 if (ENABLE_SCOPE_CHECKING)
5192 verbatim ("XXX leaving pop_everything ()\n");
5195 /* Emit debugging information for using declarations and directives.
5196 If input tree is overloaded fn then emit debug info for all
5200 cp_emit_debug_info_for_using (tree t, tree context)
5202 /* Don't try to emit any debug information if we have errors. */
5203 if (sorrycount || errorcount)
5206 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5207 of a builtin function. */
5208 if (TREE_CODE (t) == FUNCTION_DECL
5209 && DECL_EXTERNAL (t)
5210 && DECL_BUILT_IN (t))
5213 /* Do not supply context to imported_module_or_decl, if
5214 it is a global namespace. */
5215 if (context == global_namespace)
5216 context = NULL_TREE;
5219 t = BASELINK_FUNCTIONS (t);
5221 /* FIXME: Handle TEMPLATE_DECLs. */
5222 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5223 if (TREE_CODE (t) != TEMPLATE_DECL)
5224 (*debug_hooks->imported_module_or_decl) (t, context);
5227 #include "gt-cp-name-lookup.h"