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 push_overloaded_decl (tree, int, bool);
47 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
49 static bool qualified_lookup_using_namespace (tree, tree,
50 struct scope_binding *, int);
51 static tree lookup_type_current_level (tree);
52 static tree push_using_directive (tree);
54 /* The :: namespace. */
56 tree global_namespace;
58 /* The name of the anonymous namespace, throughout this translation
60 static GTY(()) tree anonymous_namespace_name;
62 /* Initialize anonymous_namespace_name if necessary, and return it. */
65 get_anonymous_namespace_name(void)
67 if (!anonymous_namespace_name)
69 /* The anonymous namespace has to have a unique name
70 if typeinfo objects are being compared by name. */
71 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
72 anonymous_namespace_name = get_file_function_name ("N");
74 /* The demangler expects anonymous namespaces to be called
75 something starting with '_GLOBAL__N_'. */
76 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
78 return anonymous_namespace_name;
81 /* Compute the chain index of a binding_entry given the HASH value of its
82 name and the total COUNT of chains. COUNT is assumed to be a power
85 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
87 /* A free list of "binding_entry"s awaiting for re-use. */
89 static GTY((deletable)) binding_entry free_binding_entry = NULL;
91 /* Create a binding_entry object for (NAME, TYPE). */
93 static inline binding_entry
94 binding_entry_make (tree name, tree type)
98 if (free_binding_entry)
100 entry = free_binding_entry;
101 free_binding_entry = entry->chain;
104 entry = GGC_NEW (struct binding_entry_s);
113 /* Put ENTRY back on the free list. */
116 binding_entry_free (binding_entry entry)
120 entry->chain = free_binding_entry;
121 free_binding_entry = entry;
125 /* The datatype used to implement the mapping from names to types at
127 struct binding_table_s GTY(())
129 /* Array of chains of "binding_entry"s */
130 binding_entry * GTY((length ("%h.chain_count"))) chain;
132 /* The number of chains in this table. This is the length of the
133 the member "chain" considered as an array. */
136 /* Number of "binding_entry"s in this table. */
140 /* Construct TABLE with an initial CHAIN_COUNT. */
143 binding_table_construct (binding_table table, size_t chain_count)
145 table->chain_count = chain_count;
146 table->entry_count = 0;
147 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
150 /* Make TABLE's entries ready for reuse. */
153 binding_table_free (binding_table table)
161 for (i = 0, count = table->chain_count; i < count; ++i)
163 binding_entry temp = table->chain[i];
166 binding_entry entry = temp;
168 binding_entry_free (entry);
170 table->chain[i] = NULL;
172 table->entry_count = 0;
176 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
178 static inline binding_table
179 binding_table_new (size_t chain_count)
181 binding_table table = GGC_NEW (struct binding_table_s);
183 binding_table_construct (table, chain_count);
187 /* Expand TABLE to twice its current chain_count. */
190 binding_table_expand (binding_table table)
192 const size_t old_chain_count = table->chain_count;
193 const size_t old_entry_count = table->entry_count;
194 const size_t new_chain_count = 2 * old_chain_count;
195 binding_entry *old_chains = table->chain;
198 binding_table_construct (table, new_chain_count);
199 for (i = 0; i < old_chain_count; ++i)
201 binding_entry entry = old_chains[i];
202 for (; entry != NULL; entry = old_chains[i])
204 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
205 const size_t j = ENTRY_INDEX (hash, new_chain_count);
207 old_chains[i] = entry->chain;
208 entry->chain = table->chain[j];
209 table->chain[j] = entry;
212 table->entry_count = old_entry_count;
215 /* Insert a binding for NAME to TYPE into TABLE. */
218 binding_table_insert (binding_table table, tree name, tree type)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 const size_t i = ENTRY_INDEX (hash, table->chain_count);
222 binding_entry entry = binding_entry_make (name, type);
224 entry->chain = table->chain[i];
225 table->chain[i] = entry;
226 ++table->entry_count;
228 if (3 * table->chain_count < 5 * table->entry_count)
229 binding_table_expand (table);
232 /* Return the binding_entry, if any, that maps NAME. */
235 binding_table_find (binding_table table, tree name)
237 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
238 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
240 while (entry != NULL && entry->name != name)
241 entry = entry->chain;
246 /* Apply PROC -- with DATA -- to all entries in TABLE. */
249 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
251 const size_t chain_count = table->chain_count;
254 for (i = 0; i < chain_count; ++i)
256 binding_entry entry = table->chain[i];
257 for (; entry != NULL; entry = entry->chain)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable)) cxx_binding *free_bindings;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding *binding, tree value, tree type)
278 binding->value = value;
279 binding->type = type;
280 binding->previous = NULL;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value, tree type)
288 cxx_binding *binding;
291 binding = free_bindings;
292 free_bindings = binding->previous;
295 binding = GGC_NEW (cxx_binding);
297 cxx_binding_init (binding, value, type);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding *binding)
307 binding->scope = NULL;
308 binding->previous = free_bindings;
309 free_bindings = binding;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
318 cp_class_binding *cb;
319 cxx_binding *binding;
321 if (VEC_length (cp_class_binding, scope->class_shadowed))
323 cp_class_binding *old_base;
324 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
325 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
327 /* Fixup the current bindings, as they might have moved. */
331 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
335 b = &IDENTIFIER_BINDING (cb->identifier);
336 while (*b != &old_base[i].base)
337 b = &((*b)->previous);
341 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
344 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
346 cb->identifier = name;
348 binding->scope = scope;
349 cxx_binding_init (binding, value, type);
353 /* Make DECL the innermost binding for ID. The LEVEL is the binding
354 level at which this declaration is being bound. */
357 push_binding (tree id, tree decl, cxx_scope* level)
359 cxx_binding *binding;
361 if (level != class_binding_level)
363 binding = cxx_binding_make (decl, NULL_TREE);
364 binding->scope = level;
367 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
369 /* Now, fill in the binding information. */
370 binding->previous = IDENTIFIER_BINDING (id);
371 INHERITED_VALUE_BINDING_P (binding) = 0;
372 LOCAL_BINDING_P (binding) = (level != class_binding_level);
374 /* And put it on the front of the list of bindings for ID. */
375 IDENTIFIER_BINDING (id) = binding;
378 /* Remove the binding for DECL which should be the innermost binding
382 pop_binding (tree id, tree decl)
384 cxx_binding *binding;
387 /* It's easiest to write the loops that call this function without
388 checking whether or not the entities involved have names. We
389 get here for such an entity. */
392 /* Get the innermost binding for ID. */
393 binding = IDENTIFIER_BINDING (id);
395 /* The name should be bound. */
396 gcc_assert (binding != NULL);
398 /* The DECL will be either the ordinary binding or the type
399 binding for this identifier. Remove that binding. */
400 if (binding->value == decl)
401 binding->value = NULL_TREE;
404 gcc_assert (binding->type == decl);
405 binding->type = NULL_TREE;
408 if (!binding->value && !binding->type)
410 /* We're completely done with the innermost binding for this
411 identifier. Unhook it from the list of bindings. */
412 IDENTIFIER_BINDING (id) = binding->previous;
414 /* Add it to the free list. */
415 cxx_binding_free (binding);
419 /* BINDING records an existing declaration for a name in the current scope.
420 But, DECL is another declaration for that same identifier in the
421 same scope. This is the `struct stat' hack whereby a non-typedef
422 class name or enum-name can be bound at the same level as some other
426 A class name (9.1) or enumeration name (7.2) can be hidden by the
427 name of an object, function, or enumerator declared in the same scope.
428 If a class or enumeration name and an object, function, or enumerator
429 are declared in the same scope (in any order) with the same name, the
430 class or enumeration name is hidden wherever the object, function, or
431 enumerator name is visible.
433 It's the responsibility of the caller to check that
434 inserting this name is valid here. Returns nonzero if the new binding
438 supplement_binding (cxx_binding *binding, tree decl)
440 tree bval = binding->value;
443 timevar_push (TV_NAME_LOOKUP);
444 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
445 /* The new name is the type name. */
446 binding->type = decl;
447 else if (/* BVAL is null when push_class_level_binding moves an
448 inherited type-binding out of the way to make room for a
449 new value binding. */
451 /* BVAL is error_mark_node when DECL's name has been used
452 in a non-class scope prior declaration. In that case,
453 we should have already issued a diagnostic; for graceful
454 error recovery purpose, pretend this was the intended
455 declaration for that name. */
456 || bval == error_mark_node
457 /* If BVAL is anticipated but has not yet been declared,
458 pretend it is not there at all. */
459 || (TREE_CODE (bval) == FUNCTION_DECL
460 && DECL_ANTICIPATED (bval)
461 && !DECL_HIDDEN_FRIEND_P (bval)))
462 binding->value = decl;
463 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
465 /* The old binding was a type name. It was placed in
466 VALUE field because it was thought, at the point it was
467 declared, to be the only entity with such a name. Move the
468 type name into the type slot; it is now hidden by the new
470 binding->type = bval;
471 binding->value = decl;
472 binding->value_is_inherited = false;
474 else if (TREE_CODE (bval) == TYPE_DECL
475 && TREE_CODE (decl) == TYPE_DECL
476 && DECL_NAME (decl) == DECL_NAME (bval)
477 && binding->scope->kind != sk_class
478 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
479 /* If either type involves template parameters, we must
480 wait until instantiation. */
481 || uses_template_parms (TREE_TYPE (decl))
482 || uses_template_parms (TREE_TYPE (bval))))
483 /* We have two typedef-names, both naming the same type to have
484 the same name. In general, this is OK because of:
488 In a given scope, a typedef specifier can be used to redefine
489 the name of any type declared in that scope to refer to the
490 type to which it already refers.
492 However, in class scopes, this rule does not apply due to the
493 stricter language in [class.mem] prohibiting redeclarations of
496 /* There can be two block-scope declarations of the same variable,
497 so long as they are `extern' declarations. However, there cannot
498 be two declarations of the same static data member:
502 A member shall not be declared twice in the
503 member-specification. */
504 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
505 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
506 && !DECL_CLASS_SCOPE_P (decl))
508 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
511 else if (TREE_CODE (decl) == NAMESPACE_DECL
512 && TREE_CODE (bval) == NAMESPACE_DECL
513 && DECL_NAMESPACE_ALIAS (decl)
514 && DECL_NAMESPACE_ALIAS (bval)
515 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
518 In a declarative region, a namespace-alias-definition can be
519 used to redefine a namespace-alias declared in that declarative
520 region to refer only to the namespace to which it already
525 error ("declaration of %q#D", decl);
526 error ("conflicts with previous declaration %q+#D", bval);
530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
533 /* Add DECL to the list of things declared in B. */
536 add_decl_to_level (tree decl, cxx_scope *b)
538 /* We used to record virtual tables as if they were ordinary
539 variables, but no longer do so. */
540 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
542 if (TREE_CODE (decl) == NAMESPACE_DECL
543 && !DECL_NAMESPACE_ALIAS (decl))
545 TREE_CHAIN (decl) = b->namespaces;
546 b->namespaces = decl;
550 /* We build up the list in reverse order, and reverse it later if
552 TREE_CHAIN (decl) = b->names;
556 /* If appropriate, add decl to separate list of statics. We
557 include extern variables because they might turn out to be
558 static later. It's OK for this list to contain a few false
560 if (b->kind == sk_namespace)
561 if ((TREE_CODE (decl) == VAR_DECL
562 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
563 || (TREE_CODE (decl) == FUNCTION_DECL
564 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
565 VEC_safe_push (tree, gc, b->static_decls, decl);
569 /* Record a decl-node X as belonging to the current lexical scope.
570 Check for errors (such as an incompatible declaration for the same
571 name already seen in the same scope). IS_FRIEND is true if X is
572 declared as a friend.
574 Returns either X or an old decl for the same name.
575 If an old decl is returned, it may have been smashed
576 to agree with what X says. */
579 pushdecl_maybe_friend (tree x, bool is_friend)
583 int need_new_binding;
585 timevar_push (TV_NAME_LOOKUP);
587 if (x == error_mark_node)
588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
590 need_new_binding = 1;
592 if (DECL_TEMPLATE_PARM_P (x))
593 /* Template parameters have no context; they are not X::T even
594 when declared within a class or namespace. */
598 if (current_function_decl && x != current_function_decl
599 /* A local declaration for a function doesn't constitute
601 && TREE_CODE (x) != FUNCTION_DECL
602 /* A local declaration for an `extern' variable is in the
603 scope of the current namespace, not the current
605 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
606 && !DECL_CONTEXT (x))
607 DECL_CONTEXT (x) = current_function_decl;
609 /* If this is the declaration for a namespace-scope function,
610 but the declaration itself is in a local scope, mark the
612 if (TREE_CODE (x) == FUNCTION_DECL
613 && DECL_NAMESPACE_SCOPE_P (x)
614 && current_function_decl
615 && x != current_function_decl)
616 DECL_LOCAL_FUNCTION_P (x) = 1;
619 name = DECL_NAME (x);
622 int different_binding_level = 0;
624 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
625 name = TREE_OPERAND (name, 0);
627 /* In case this decl was explicitly namespace-qualified, look it
628 up in its namespace context. */
629 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
630 t = namespace_binding (name, DECL_CONTEXT (x));
632 t = lookup_name_innermost_nonclass_level (name);
634 /* [basic.link] If there is a visible declaration of an entity
635 with linkage having the same name and type, ignoring entities
636 declared outside the innermost enclosing namespace scope, the
637 block scope declaration declares that same entity and
638 receives the linkage of the previous declaration. */
639 if (! t && current_function_decl && x != current_function_decl
640 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
641 && DECL_EXTERNAL (x))
643 /* Look in block scope. */
644 t = innermost_non_namespace_value (name);
645 /* Or in the innermost namespace. */
647 t = namespace_binding (name, DECL_CONTEXT (x));
648 /* Does it have linkage? Note that if this isn't a DECL, it's an
649 OVERLOAD, which is OK. */
650 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
653 different_binding_level = 1;
656 /* If we are declaring a function, and the result of name-lookup
657 was an OVERLOAD, look for an overloaded instance that is
658 actually the same as the function we are declaring. (If
659 there is one, we have to merge our declaration with the
660 previous declaration.) */
661 if (t && TREE_CODE (t) == OVERLOAD)
665 if (TREE_CODE (x) == FUNCTION_DECL)
666 for (match = t; match; match = OVL_NEXT (match))
668 if (decls_match (OVL_CURRENT (match), x))
672 /* Just choose one. */
676 t = OVL_CURRENT (match);
681 if (t && t != error_mark_node)
683 if (different_binding_level)
685 if (decls_match (x, t))
686 /* The standard only says that the local extern
687 inherits linkage from the previous decl; in
688 particular, default args are not shared. Add
689 the decl into a hash table to make sure only
690 the previous decl in this case is seen by the
693 struct cxx_int_tree_map *h;
696 TREE_PUBLIC (x) = TREE_PUBLIC (t);
698 if (cp_function_chain->extern_decl_map == NULL)
699 cp_function_chain->extern_decl_map
700 = htab_create_ggc (20, cxx_int_tree_map_hash,
701 cxx_int_tree_map_eq, NULL);
703 h = GGC_NEW (struct cxx_int_tree_map);
704 h->uid = DECL_UID (x);
706 loc = htab_find_slot_with_hash
707 (cp_function_chain->extern_decl_map, h,
709 *(struct cxx_int_tree_map **) loc = h;
712 else if (TREE_CODE (t) == PARM_DECL)
714 gcc_assert (DECL_CONTEXT (t));
716 /* Check for duplicate params. */
717 if (duplicate_decls (x, t, is_friend))
718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
720 else if ((DECL_EXTERN_C_FUNCTION_P (x)
721 || DECL_FUNCTION_TEMPLATE_P (x))
722 && is_overloaded_fn (t))
723 /* Don't do anything just yet. */;
724 else if (t == wchar_decl_node)
726 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
727 pedwarn ("redeclaration of %<wchar_t%> as %qT",
730 /* Throw away the redeclaration. */
731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
735 tree olddecl = duplicate_decls (x, t, is_friend);
737 /* If the redeclaration failed, we can stop at this
739 if (olddecl == error_mark_node)
740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
744 if (TREE_CODE (t) == TYPE_DECL)
745 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
749 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
751 /* A redeclaration of main, but not a duplicate of the
756 This function shall not be overloaded. */
757 error ("invalid redeclaration of %q+D", t);
759 /* We don't try to push this declaration since that
761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
766 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
767 check_default_args (x);
769 check_template_shadow (x);
771 /* If this is a function conjured up by the back end, massage it
772 so it looks friendly. */
773 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
775 retrofit_lang_decl (x);
776 SET_DECL_LANGUAGE (x, lang_c);
779 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
781 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
783 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
784 if (!namespace_bindings_p ())
785 /* We do not need to create a binding for this name;
786 push_overloaded_decl will have already done so if
788 need_new_binding = 0;
790 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
792 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
794 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
795 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
798 /* If declaring a type as a typedef, copy the type (unless we're
799 at line 0), and install this TYPE_DECL as the new type's typedef
800 name. See the extensive comment in ../c-decl.c (pushdecl). */
801 if (TREE_CODE (x) == TYPE_DECL)
803 tree type = TREE_TYPE (x);
804 if (DECL_IS_BUILTIN (x))
806 if (TYPE_NAME (type) == 0)
807 TYPE_NAME (type) = x;
809 else if (type != error_mark_node && TYPE_NAME (type) != x
810 /* We don't want to copy the type when all we're
811 doing is making a TYPE_DECL for the purposes of
813 && (!TYPE_NAME (type)
814 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
816 DECL_ORIGINAL_TYPE (x) = type;
817 type = build_variant_type_copy (type);
818 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
819 TYPE_NAME (type) = x;
820 TREE_TYPE (x) = type;
823 if (type != error_mark_node
825 && TYPE_IDENTIFIER (type))
826 set_identifier_type_value (DECL_NAME (x), x);
829 /* Multiple external decls of the same identifier ought to match.
831 We get warnings about inline functions where they are defined.
832 We get warnings about other functions from push_overloaded_decl.
834 Avoid duplicate warnings where they are used. */
835 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
839 decl = IDENTIFIER_NAMESPACE_VALUE (name);
840 if (decl && TREE_CODE (decl) == OVERLOAD)
841 decl = OVL_FUNCTION (decl);
843 if (decl && decl != error_mark_node
844 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
845 /* If different sort of thing, we already gave an error. */
846 && TREE_CODE (decl) == TREE_CODE (x)
847 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
849 pedwarn ("type mismatch with previous external decl of %q#D", x);
850 pedwarn ("previous external decl of %q+#D", decl);
854 if (TREE_CODE (x) == FUNCTION_DECL
856 && !flag_friend_injection)
858 /* This is a new declaration of a friend function, so hide
859 it from ordinary function lookup. */
860 DECL_ANTICIPATED (x) = 1;
861 DECL_HIDDEN_FRIEND_P (x) = 1;
864 /* This name is new in its binding level.
865 Install the new declaration and return it. */
866 if (namespace_bindings_p ())
868 /* Install a global value. */
870 /* If the first global decl has external linkage,
871 warn if we later see static one. */
872 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
873 TREE_PUBLIC (name) = 1;
875 /* Bind the name for the entity. */
876 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
878 && (TREE_CODE (x) == TYPE_DECL
879 || TREE_CODE (x) == VAR_DECL
880 || TREE_CODE (x) == NAMESPACE_DECL
881 || TREE_CODE (x) == CONST_DECL
882 || TREE_CODE (x) == TEMPLATE_DECL))
883 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
885 /* If new decl is `static' and an `extern' was seen previously,
887 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
888 warn_extern_redeclared_static (x, t);
892 /* Here to install a non-global value. */
893 tree oldlocal = innermost_non_namespace_value (name);
894 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
896 if (need_new_binding)
898 push_local_binding (name, x, 0);
899 /* Because push_local_binding will hook X on to the
900 current_binding_level's name list, we don't want to
901 do that again below. */
902 need_new_binding = 0;
905 /* If this is a TYPE_DECL, push it into the type value slot. */
906 if (TREE_CODE (x) == TYPE_DECL)
907 set_identifier_type_value (name, x);
909 /* Clear out any TYPE_DECL shadowed by a namespace so that
910 we won't think this is a type. The C struct hack doesn't
911 go through namespaces. */
912 if (TREE_CODE (x) == NAMESPACE_DECL)
913 set_identifier_type_value (name, NULL_TREE);
920 && TREE_CODE (oldlocal) == VAR_DECL
921 && DECL_DEAD_FOR_LOCAL (oldlocal))
922 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
924 if (oldlocal == NULL_TREE)
925 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
928 /* If this is an extern function declaration, see if we
929 have a global definition or declaration for the function. */
930 if (oldlocal == NULL_TREE
932 && oldglobal != NULL_TREE
933 && TREE_CODE (x) == FUNCTION_DECL
934 && TREE_CODE (oldglobal) == FUNCTION_DECL)
936 /* We have one. Their types must agree. */
937 if (decls_match (x, oldglobal))
941 warning (0, "extern declaration of %q#D doesn't match", x);
942 warning (0, "global declaration %q+#D", oldglobal);
945 /* If we have a local external declaration,
946 and no file-scope declaration has yet been seen,
947 then if we later have a file-scope decl it must not be static. */
948 if (oldlocal == NULL_TREE
949 && oldglobal == NULL_TREE
952 TREE_PUBLIC (name) = 1;
954 /* Warn if shadowing an argument at the top level of the body. */
955 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
956 /* Inline decls shadow nothing. */
957 && !DECL_FROM_INLINE (x)
958 && TREE_CODE (oldlocal) == PARM_DECL
959 /* Don't check the `this' parameter. */
960 && !DECL_ARTIFICIAL (oldlocal))
964 /* Don't complain if it's from an enclosing function. */
965 if (DECL_CONTEXT (oldlocal) == current_function_decl
966 && TREE_CODE (x) != PARM_DECL)
968 /* Go to where the parms should be and see if we find
970 struct cp_binding_level *b = current_binding_level->level_chain;
972 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
973 /* Skip the ctor/dtor cleanup level. */
977 if (b->kind == sk_function_parms)
979 error ("declaration of %q#D shadows a parameter", x);
984 if (warn_shadow && !err)
986 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
987 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
991 /* Maybe warn if shadowing something else. */
992 else if (warn_shadow && !DECL_EXTERNAL (x)
993 /* No shadow warnings for internally generated vars. */
994 && ! DECL_ARTIFICIAL (x)
995 /* No shadow warnings for vars made for inlining. */
996 && ! DECL_FROM_INLINE (x))
1000 if (current_class_ptr)
1001 member = lookup_member (current_class_type,
1004 /*want_type=*/false);
1008 if (member && !TREE_STATIC (member))
1010 /* Location of previous decl is not useful in this case. */
1011 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1014 else if (oldlocal != NULL_TREE
1015 && TREE_CODE (oldlocal) == VAR_DECL)
1017 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1018 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1020 else if (oldglobal != NULL_TREE
1021 && TREE_CODE (oldglobal) == VAR_DECL)
1022 /* XXX shadow warnings in outer-more namespaces */
1024 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1026 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1031 if (TREE_CODE (x) == VAR_DECL)
1032 maybe_register_incomplete_var (x);
1035 if (need_new_binding)
1036 add_decl_to_level (x,
1037 DECL_NAMESPACE_SCOPE_P (x)
1038 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1039 : current_binding_level);
1041 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1044 /* Record a decl-node X as belonging to the current lexical scope. */
1049 return pushdecl_maybe_friend (x, false);
1052 /* Enter DECL into the symbol table, if that's appropriate. Returns
1053 DECL, or a modified version thereof. */
1056 maybe_push_decl (tree decl)
1058 tree type = TREE_TYPE (decl);
1060 /* Add this decl to the current binding level, but not if it comes
1061 from another scope, e.g. a static member variable. TEM may equal
1062 DECL or it may be a previous decl of the same name. */
1063 if (decl == error_mark_node
1064 || (TREE_CODE (decl) != PARM_DECL
1065 && DECL_CONTEXT (decl) != NULL_TREE
1066 /* Definitions of namespace members outside their namespace are
1068 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1069 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1070 || TREE_CODE (type) == UNKNOWN_TYPE
1071 /* The declaration of a template specialization does not affect
1072 the functions available for overload resolution, so we do not
1074 || (TREE_CODE (decl) == FUNCTION_DECL
1075 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1078 return pushdecl (decl);
1081 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1082 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1083 doesn't really belong to this binding level, that it got here
1084 through a using-declaration. */
1087 push_local_binding (tree id, tree decl, int flags)
1089 struct cp_binding_level *b;
1091 /* Skip over any local classes. This makes sense if we call
1092 push_local_binding with a friend decl of a local class. */
1093 b = innermost_nonclass_level ();
1095 if (lookup_name_innermost_nonclass_level (id))
1097 /* Supplement the existing binding. */
1098 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1099 /* It didn't work. Something else must be bound at this
1100 level. Do not add DECL to the list of things to pop
1105 /* Create a new binding. */
1106 push_binding (id, decl, b);
1108 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1109 /* We must put the OVERLOAD into a TREE_LIST since the
1110 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1111 decls that got here through a using-declaration. */
1112 decl = build_tree_list (NULL_TREE, decl);
1114 /* And put DECL on the list of things declared by the current
1116 add_decl_to_level (decl, b);
1119 /* Check to see whether or not DECL is a variable that would have been
1120 in scope under the ARM, but is not in scope under the ANSI/ISO
1121 standard. If so, issue an error message. If name lookup would
1122 work in both cases, but return a different result, this function
1123 returns the result of ANSI/ISO lookup. Otherwise, it returns
1127 check_for_out_of_scope_variable (tree decl)
1131 /* We only care about out of scope variables. */
1132 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1135 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1136 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1137 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1138 && DECL_DEAD_FOR_LOCAL (shadowed))
1139 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1140 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1142 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1145 if (!DECL_ERROR_REPORTED (decl))
1147 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1148 warning (0, " matches this %q+D under ISO standard rules",
1150 warning (0, " matches this %q+D under old rules", decl);
1151 DECL_ERROR_REPORTED (decl) = 1;
1156 /* If we have already complained about this declaration, there's no
1157 need to do it again. */
1158 if (DECL_ERROR_REPORTED (decl))
1161 DECL_ERROR_REPORTED (decl) = 1;
1163 if (TREE_TYPE (decl) == error_mark_node)
1166 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1168 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1170 error (" cannot use obsolete binding at %q+D because "
1171 "it has a destructor", decl);
1172 return error_mark_node;
1176 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1178 pedwarn (" using obsolete binding at %q+D", decl);
1184 /* true means unconditionally make a BLOCK for the next level pushed. */
1186 static bool keep_next_level_flag;
1188 static int binding_depth = 0;
1189 static int is_class_level = 0;
1196 for (i = 0; i < depth * 2; i++)
1200 /* Return a string describing the kind of SCOPE we have. */
1202 cxx_scope_descriptor (cxx_scope *scope)
1204 /* The order of this table must match the "scope_kind"
1206 static const char* scope_kind_names[] = {
1212 "function-parameter-scope",
1215 "template-parameter-scope",
1216 "template-explicit-spec-scope"
1218 const scope_kind kind = scope->explicit_spec_p
1219 ? sk_template_spec : scope->kind;
1221 return scope_kind_names[kind];
1224 /* Output a debugging information about SCOPE when performing
1227 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1229 const char *desc = cxx_scope_descriptor (scope);
1230 if (scope->this_entity)
1231 verbatim ("%s %s(%E) %p %d\n", action, desc,
1232 scope->this_entity, (void *) scope, line);
1234 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1237 /* Return the estimated initial size of the hashtable of a NAMESPACE
1240 static inline size_t
1241 namespace_scope_ht_size (tree ns)
1243 tree name = DECL_NAME (ns);
1245 return name == std_identifier
1246 ? NAMESPACE_STD_HT_SIZE
1247 : (name == global_scope_name
1248 ? GLOBAL_SCOPE_HT_SIZE
1249 : NAMESPACE_ORDINARY_HT_SIZE);
1252 /* A chain of binding_level structures awaiting reuse. */
1254 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1256 /* Insert SCOPE as the innermost binding level. */
1259 push_binding_level (struct cp_binding_level *scope)
1261 /* Add it to the front of currently active scopes stack. */
1262 scope->level_chain = current_binding_level;
1263 current_binding_level = scope;
1264 keep_next_level_flag = false;
1266 if (ENABLE_SCOPE_CHECKING)
1268 scope->binding_depth = binding_depth;
1269 indent (binding_depth);
1270 cxx_scope_debug (scope, input_line, "push");
1276 /* Create a new KIND scope and make it the top of the active scopes stack.
1277 ENTITY is the scope of the associated C++ entity (namespace, class,
1278 function); it is NULL otherwise. */
1281 begin_scope (scope_kind kind, tree entity)
1285 /* Reuse or create a struct for this binding level. */
1286 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1288 scope = free_binding_level;
1289 memset (scope, 0, sizeof (cxx_scope));
1290 free_binding_level = scope->level_chain;
1293 scope = GGC_CNEW (cxx_scope);
1295 scope->this_entity = entity;
1296 scope->more_cleanups_ok = true;
1303 case sk_template_spec:
1304 scope->explicit_spec_p = true;
1305 kind = sk_template_parms;
1307 case sk_template_parms:
1313 case sk_function_parms:
1315 scope->keep = keep_next_level_flag;
1319 NAMESPACE_LEVEL (entity) = scope;
1320 scope->static_decls =
1321 VEC_alloc (tree, gc,
1322 DECL_NAME (entity) == std_identifier
1323 || DECL_NAME (entity) == global_scope_name
1328 /* Should not happen. */
1334 push_binding_level (scope);
1339 /* We're about to leave current scope. Pop the top of the stack of
1340 currently active scopes. Return the enclosing scope, now active. */
1345 cxx_scope *scope = current_binding_level;
1347 if (scope->kind == sk_namespace && class_binding_level)
1348 current_binding_level = class_binding_level;
1350 /* We cannot leave a scope, if there are none left. */
1351 if (NAMESPACE_LEVEL (global_namespace))
1352 gcc_assert (!global_scope_p (scope));
1354 if (ENABLE_SCOPE_CHECKING)
1356 indent (--binding_depth);
1357 cxx_scope_debug (scope, input_line, "leave");
1358 if (is_class_level != (scope == class_binding_level))
1360 indent (binding_depth);
1361 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1366 /* Move one nesting level up. */
1367 current_binding_level = scope->level_chain;
1369 /* Namespace-scopes are left most probably temporarily, not
1370 completely; they can be reopened later, e.g. in namespace-extension
1371 or any name binding activity that requires us to resume a
1372 namespace. For classes, we cache some binding levels. For other
1373 scopes, we just make the structure available for reuse. */
1374 if (scope->kind != sk_namespace
1375 && scope->kind != sk_class)
1377 scope->level_chain = free_binding_level;
1378 gcc_assert (!ENABLE_SCOPE_CHECKING
1379 || scope->binding_depth == binding_depth);
1380 free_binding_level = scope;
1383 /* Find the innermost enclosing class scope, and reset
1384 CLASS_BINDING_LEVEL appropriately. */
1385 if (scope->kind == sk_class)
1387 class_binding_level = NULL;
1388 for (scope = current_binding_level; scope; scope = scope->level_chain)
1389 if (scope->kind == sk_class)
1391 class_binding_level = scope;
1396 return current_binding_level;
1400 resume_scope (struct cp_binding_level* b)
1402 /* Resuming binding levels is meant only for namespaces,
1403 and those cannot nest into classes. */
1404 gcc_assert (!class_binding_level);
1405 /* Also, resuming a non-directly nested namespace is a no-no. */
1406 gcc_assert (b->level_chain == current_binding_level);
1407 current_binding_level = b;
1408 if (ENABLE_SCOPE_CHECKING)
1410 b->binding_depth = binding_depth;
1411 indent (binding_depth);
1412 cxx_scope_debug (b, input_line, "resume");
1418 /* Return the innermost binding level that is not for a class scope. */
1421 innermost_nonclass_level (void)
1425 b = current_binding_level;
1426 while (b->kind == sk_class)
1432 /* We're defining an object of type TYPE. If it needs a cleanup, but
1433 we're not allowed to add any more objects with cleanups to the current
1434 scope, create a new binding level. */
1437 maybe_push_cleanup_level (tree type)
1439 if (type != error_mark_node
1440 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1441 && current_binding_level->more_cleanups_ok == 0)
1443 begin_scope (sk_cleanup, NULL);
1444 current_binding_level->statement_list = push_stmt_list ();
1448 /* Nonzero if we are currently in the global binding level. */
1451 global_bindings_p (void)
1453 return global_scope_p (current_binding_level);
1456 /* True if we are currently in a toplevel binding level. This
1457 means either the global binding level or a namespace in a toplevel
1458 binding level. Since there are no non-toplevel namespace levels,
1459 this really means any namespace or template parameter level. We
1460 also include a class whose context is toplevel. */
1463 toplevel_bindings_p (void)
1465 struct cp_binding_level *b = innermost_nonclass_level ();
1467 return b->kind == sk_namespace || b->kind == sk_template_parms;
1470 /* True if this is a namespace scope, or if we are defining a class
1471 which is itself at namespace scope, or whose enclosing class is
1472 such a class, etc. */
1475 namespace_bindings_p (void)
1477 struct cp_binding_level *b = innermost_nonclass_level ();
1479 return b->kind == sk_namespace;
1482 /* True if the current level needs to have a BLOCK made. */
1487 return (current_binding_level->blocks != NULL_TREE
1488 || current_binding_level->keep
1489 || current_binding_level->kind == sk_cleanup
1490 || current_binding_level->names != NULL_TREE);
1493 /* Returns the kind of the innermost scope. */
1496 innermost_scope_kind (void)
1498 return current_binding_level->kind;
1501 /* Returns true if this scope was created to store template parameters. */
1504 template_parm_scope_p (void)
1506 return innermost_scope_kind () == sk_template_parms;
1509 /* If KEEP is true, make a BLOCK node for the next binding level,
1510 unconditionally. Otherwise, use the normal logic to decide whether
1511 or not to create a BLOCK. */
1514 keep_next_level (bool keep)
1516 keep_next_level_flag = keep;
1519 /* Return the list of declarations of the current level.
1520 Note that this list is in reverse order unless/until
1521 you nreverse it; and when you do nreverse it, you must
1522 store the result back using `storedecls' or you will lose. */
1527 return current_binding_level->names;
1530 /* For debugging. */
1531 static int no_print_functions = 0;
1532 static int no_print_builtins = 0;
1535 print_binding_level (struct cp_binding_level* lvl)
1539 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1540 if (lvl->more_cleanups_ok)
1541 fprintf (stderr, " more-cleanups-ok");
1542 if (lvl->have_cleanups)
1543 fprintf (stderr, " have-cleanups");
1544 fprintf (stderr, "\n");
1547 fprintf (stderr, " names:\t");
1548 /* We can probably fit 3 names to a line? */
1549 for (t = lvl->names; t; t = TREE_CHAIN (t))
1551 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1553 if (no_print_builtins
1554 && (TREE_CODE (t) == TYPE_DECL)
1555 && DECL_IS_BUILTIN (t))
1558 /* Function decls tend to have longer names. */
1559 if (TREE_CODE (t) == FUNCTION_DECL)
1566 fprintf (stderr, "\n\t");
1569 print_node_brief (stderr, "", t, 0);
1570 if (t == error_mark_node)
1574 fprintf (stderr, "\n");
1576 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1579 cp_class_binding *b;
1580 fprintf (stderr, " class-shadowed:");
1582 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1584 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1585 fprintf (stderr, "\n");
1587 if (lvl->type_shadowed)
1589 fprintf (stderr, " type-shadowed:");
1590 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1592 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1594 fprintf (stderr, "\n");
1599 print_other_binding_stack (struct cp_binding_level *stack)
1601 struct cp_binding_level *level;
1602 for (level = stack; !global_scope_p (level); level = level->level_chain)
1604 fprintf (stderr, "binding level %p\n", (void *) level);
1605 print_binding_level (level);
1610 print_binding_stack (void)
1612 struct cp_binding_level *b;
1613 fprintf (stderr, "current_binding_level=%p\n"
1614 "class_binding_level=%p\n"
1615 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1616 (void *) current_binding_level, (void *) class_binding_level,
1617 (void *) NAMESPACE_LEVEL (global_namespace));
1618 if (class_binding_level)
1620 for (b = class_binding_level; b; b = b->level_chain)
1621 if (b == current_binding_level)
1624 b = class_binding_level;
1626 b = current_binding_level;
1629 b = current_binding_level;
1630 print_other_binding_stack (b);
1631 fprintf (stderr, "global:\n");
1632 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1635 /* Return the type associated with id. */
1638 identifier_type_value (tree id)
1640 timevar_push (TV_NAME_LOOKUP);
1641 /* There is no type with that name, anywhere. */
1642 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1643 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1644 /* This is not the type marker, but the real thing. */
1645 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1646 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1647 /* Have to search for it. It must be on the global level, now.
1648 Ask lookup_name not to return non-types. */
1649 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1651 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1652 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1655 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1656 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1659 identifier_global_value (tree t)
1661 return IDENTIFIER_GLOBAL_VALUE (t);
1664 /* Push a definition of struct, union or enum tag named ID. into
1665 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1666 the tag ID is not already defined. */
1669 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1673 if (b->kind != sk_namespace)
1675 /* Shadow the marker, not the real thing, so that the marker
1676 gets restored later. */
1677 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1679 = tree_cons (id, old_type_value, b->type_shadowed);
1680 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1681 TREE_TYPE (b->type_shadowed) = type;
1685 cxx_binding *binding =
1686 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1689 supplement_binding (binding, decl);
1691 binding->value = decl;
1693 /* Store marker instead of real type. */
1694 type = global_type_node;
1696 SET_IDENTIFIER_TYPE_VALUE (id, type);
1699 /* As set_identifier_type_value_with_scope, but using
1700 current_binding_level. */
1703 set_identifier_type_value (tree id, tree decl)
1705 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1708 /* Return the name for the constructor (or destructor) for the
1709 specified class TYPE. When given a template, this routine doesn't
1710 lose the specialization. */
1713 constructor_name_full (tree type)
1715 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1718 /* Return the name for the constructor (or destructor) for the
1719 specified class. When given a template, return the plain
1720 unspecialized name. */
1723 constructor_name (tree type)
1726 name = constructor_name_full (type);
1727 if (IDENTIFIER_TEMPLATE (name))
1728 name = IDENTIFIER_TEMPLATE (name);
1732 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1733 which must be a class type. */
1736 constructor_name_p (tree name, tree type)
1740 gcc_assert (IS_AGGR_TYPE (type));
1745 if (TREE_CODE (name) != IDENTIFIER_NODE)
1748 ctor_name = constructor_name_full (type);
1749 if (name == ctor_name)
1751 if (IDENTIFIER_TEMPLATE (ctor_name)
1752 && name == IDENTIFIER_TEMPLATE (ctor_name))
1757 /* Counter used to create anonymous type names. */
1759 static GTY(()) int anon_cnt;
1761 /* Return an IDENTIFIER which can be used as a name for
1762 anonymous structs and unions. */
1765 make_anon_name (void)
1769 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1770 return get_identifier (buf);
1773 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1775 static inline cxx_binding *
1776 find_binding (cxx_scope *scope, cxx_binding *binding)
1778 timevar_push (TV_NAME_LOOKUP);
1780 for (; binding != NULL; binding = binding->previous)
1781 if (binding->scope == scope)
1782 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1784 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1787 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1789 static inline cxx_binding *
1790 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1792 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1795 /* Fold-in case where NAME is used only once. */
1796 if (scope == b->scope && b->previous == NULL)
1798 return find_binding (scope, b);
1803 /* Always returns a binding for name in scope. If no binding is
1804 found, make a new one. */
1806 static cxx_binding *
1807 binding_for_name (cxx_scope *scope, tree name)
1809 cxx_binding *result;
1811 result = cxx_scope_find_binding_for_name (scope, name);
1814 /* Not found, make a new one. */
1815 result = cxx_binding_make (NULL, NULL);
1816 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1817 result->scope = scope;
1818 result->is_local = false;
1819 result->value_is_inherited = false;
1820 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1824 /* Insert another USING_DECL into the current binding level, returning
1825 this declaration. If this is a redeclaration, do nothing, and
1826 return NULL_TREE if this not in namespace scope (in namespace
1827 scope, a using decl might extend any previous bindings). */
1830 push_using_decl (tree scope, tree name)
1834 timevar_push (TV_NAME_LOOKUP);
1835 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1836 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1837 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1838 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1841 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1842 namespace_bindings_p () ? decl : NULL_TREE);
1843 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1844 USING_DECL_SCOPE (decl) = scope;
1845 TREE_CHAIN (decl) = current_binding_level->usings;
1846 current_binding_level->usings = decl;
1847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1850 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1851 caller to set DECL_CONTEXT properly. */
1854 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1856 struct cp_binding_level *b;
1857 tree function_decl = current_function_decl;
1859 timevar_push (TV_NAME_LOOKUP);
1860 current_function_decl = NULL_TREE;
1861 if (level->kind == sk_class)
1863 b = class_binding_level;
1864 class_binding_level = level;
1865 pushdecl_class_level (x);
1866 class_binding_level = b;
1870 b = current_binding_level;
1871 current_binding_level = level;
1872 x = pushdecl_maybe_friend (x, is_friend);
1873 current_binding_level = b;
1875 current_function_decl = function_decl;
1876 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1879 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1880 other definitions already in place. We get around this by making
1881 the value of the identifier point to a list of all the things that
1882 want to be referenced by that name. It is then up to the users of
1883 that name to decide what to do with that list.
1885 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1886 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1888 FLAGS is a bitwise-or of the following values:
1889 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1891 PUSH_USING: DECL is being pushed as the result of a using
1894 IS_FRIEND is true if this is a friend declaration.
1896 The value returned may be a previous declaration if we guessed wrong
1897 about what language DECL should belong to (C or C++). Otherwise,
1898 it's always DECL (and never something that's not a _DECL). */
1901 push_overloaded_decl (tree decl, int flags, bool is_friend)
1903 tree name = DECL_NAME (decl);
1906 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1908 timevar_push (TV_NAME_LOOKUP);
1910 old = namespace_binding (name, DECL_CONTEXT (decl));
1912 old = lookup_name_innermost_nonclass_level (name);
1916 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1918 tree t = TREE_TYPE (old);
1919 if (IS_AGGR_TYPE (t) && warn_shadow
1920 && (! DECL_IN_SYSTEM_HEADER (decl)
1921 || ! DECL_IN_SYSTEM_HEADER (old)))
1922 warning (0, "%q#D hides constructor for %q#T", decl, t);
1925 else if (is_overloaded_fn (old))
1929 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1931 tree fn = OVL_CURRENT (tmp);
1934 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1935 && !(flags & PUSH_USING)
1936 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1937 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1938 && ! decls_match (fn, decl))
1939 error ("%q#D conflicts with previous using declaration %q#D",
1942 dup = duplicate_decls (decl, fn, is_friend);
1943 /* If DECL was a redeclaration of FN -- even an invalid
1944 one -- pass that information along to our caller. */
1945 if (dup == fn || dup == error_mark_node)
1946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1949 /* We don't overload implicit built-ins. duplicate_decls()
1950 may fail to merge the decls if the new decl is e.g. a
1951 template function. */
1952 if (TREE_CODE (old) == FUNCTION_DECL
1953 && DECL_ANTICIPATED (old)
1954 && !DECL_HIDDEN_FRIEND_P (old))
1957 else if (old == error_mark_node)
1958 /* Ignore the undefined symbol marker. */
1962 error ("previous non-function declaration %q+#D", old);
1963 error ("conflicts with function declaration %q#D", decl);
1964 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1968 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1969 /* If it's a using declaration, we always need to build an OVERLOAD,
1970 because it's the only way to remember that the declaration comes
1971 from 'using', and have the lookup behave correctly. */
1972 || (flags & PUSH_USING))
1974 if (old && TREE_CODE (old) != OVERLOAD)
1975 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1977 new_binding = ovl_cons (decl, old);
1978 if (flags & PUSH_USING)
1979 OVL_USED (new_binding) = 1;
1982 /* NAME is not ambiguous. */
1986 set_namespace_binding (name, current_namespace, new_binding);
1989 /* We only create an OVERLOAD if there was a previous binding at
1990 this level, or if decl is a template. In the former case, we
1991 need to remove the old binding and replace it with the new
1992 binding. We must also run through the NAMES on the binding
1993 level where the name was bound to update the chain. */
1995 if (TREE_CODE (new_binding) == OVERLOAD && old)
1999 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2001 d = &TREE_CHAIN (*d))
2003 || (TREE_CODE (*d) == TREE_LIST
2004 && TREE_VALUE (*d) == old))
2006 if (TREE_CODE (*d) == TREE_LIST)
2007 /* Just replace the old binding with the new. */
2008 TREE_VALUE (*d) = new_binding;
2010 /* Build a TREE_LIST to wrap the OVERLOAD. */
2011 *d = tree_cons (NULL_TREE, new_binding,
2014 /* And update the cxx_binding node. */
2015 IDENTIFIER_BINDING (name)->value = new_binding;
2016 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2019 /* We should always find a previous binding in this case. */
2023 /* Install the new binding. */
2024 push_local_binding (name, new_binding, flags);
2027 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2030 /* Check a non-member using-declaration. Return the name and scope
2031 being used, and the USING_DECL, or NULL_TREE on failure. */
2034 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2036 /* [namespace.udecl]
2037 A using-declaration for a class member shall be a
2038 member-declaration. */
2041 error ("%qT is not a namespace", scope);
2044 else if (scope == error_mark_node)
2047 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2050 A using-declaration shall not name a template-id. */
2051 error ("a using-declaration cannot specify a template-id. "
2052 "Try %<using %D%>", name);
2056 if (TREE_CODE (decl) == NAMESPACE_DECL)
2058 error ("namespace %qD not allowed in using-declaration", decl);
2062 if (TREE_CODE (decl) == SCOPE_REF)
2064 /* It's a nested name with template parameter dependent scope.
2065 This can only be using-declaration for class member. */
2066 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2070 if (is_overloaded_fn (decl))
2071 decl = get_first_fn (decl);
2073 gcc_assert (DECL_P (decl));
2075 /* Make a USING_DECL. */
2076 return push_using_decl (scope, name);
2079 /* Process local and global using-declarations. */
2082 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2083 tree *newval, tree *newtype)
2085 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2087 *newval = *newtype = NULL_TREE;
2088 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2092 if (!decls.value && !decls.type)
2094 error ("%qD not declared", name);
2098 /* Shift the old and new bindings around so we're comparing class and
2099 enumeration names to each other. */
2100 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2106 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2108 decls.type = decls.value;
2109 decls.value = NULL_TREE;
2112 /* It is impossible to overload a built-in function; any explicit
2113 declaration eliminates the built-in declaration. So, if OLDVAL
2114 is a built-in, then we can just pretend it isn't there. */
2116 && TREE_CODE (oldval) == FUNCTION_DECL
2117 && DECL_ANTICIPATED (oldval)
2118 && !DECL_HIDDEN_FRIEND_P (oldval))
2123 /* Check for using functions. */
2124 if (is_overloaded_fn (decls.value))
2128 if (oldval && !is_overloaded_fn (oldval))
2130 error ("%qD is already declared in this scope", name);
2135 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2137 tree new_fn = OVL_CURRENT (tmp);
2139 /* [namespace.udecl]
2141 If a function declaration in namespace scope or block
2142 scope has the same name and the same parameter types as a
2143 function introduced by a using declaration the program is
2145 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2147 tree old_fn = OVL_CURRENT (tmp1);
2149 if (new_fn == old_fn)
2150 /* The function already exists in the current namespace. */
2152 else if (OVL_USED (tmp1))
2153 continue; /* this is a using decl */
2154 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2155 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2157 gcc_assert (!DECL_ANTICIPATED (old_fn)
2158 || DECL_HIDDEN_FRIEND_P (old_fn));
2160 /* There was already a non-using declaration in
2161 this scope with the same parameter types. If both
2162 are the same extern "C" functions, that's ok. */
2163 if (decls_match (new_fn, old_fn))
2167 error ("%qD is already declared in this scope", name);
2173 /* If we broke out of the loop, there's no reason to add
2174 this function to the using declarations for this
2179 /* If we are adding to an existing OVERLOAD, then we no
2180 longer know the type of the set of functions. */
2181 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2182 TREE_TYPE (*newval) = unknown_type_node;
2183 /* Add this new function to the set. */
2184 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2185 /* If there is only one function, then we use its type. (A
2186 using-declaration naming a single function can be used in
2187 contexts where overload resolution cannot be
2189 if (TREE_CODE (*newval) != OVERLOAD)
2191 *newval = ovl_cons (*newval, NULL_TREE);
2192 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2194 OVL_USED (*newval) = 1;
2199 *newval = decls.value;
2200 if (oldval && !decls_match (*newval, oldval))
2201 error ("%qD is already declared in this scope", name);
2207 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2209 error ("reference to %qD is ambiguous", name);
2210 print_candidates (decls.type);
2214 *newtype = decls.type;
2215 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2216 error ("%qD is already declared in this scope", name);
2219 /* If *newval is empty, shift any class or enumeration name down. */
2223 *newtype = NULL_TREE;
2227 /* Process a using-declaration at function scope. */
2230 do_local_using_decl (tree decl, tree scope, tree name)
2232 tree oldval, oldtype, newval, newtype;
2233 tree orig_decl = decl;
2235 decl = validate_nonmember_using_decl (decl, scope, name);
2236 if (decl == NULL_TREE)
2239 if (building_stmt_tree ()
2240 && at_function_scope_p ())
2241 add_decl_expr (decl);
2243 oldval = lookup_name_innermost_nonclass_level (name);
2244 oldtype = lookup_type_current_level (name);
2246 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2250 if (is_overloaded_fn (newval))
2254 /* We only need to push declarations for those functions
2255 that were not already bound in the current level.
2256 The old value might be NULL_TREE, it might be a single
2257 function, or an OVERLOAD. */
2258 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2259 term = OVL_FUNCTION (oldval);
2262 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2264 push_overloaded_decl (OVL_CURRENT (fn),
2265 PUSH_LOCAL | PUSH_USING,
2269 push_local_binding (name, newval, PUSH_USING);
2273 push_local_binding (name, newtype, PUSH_USING);
2274 set_identifier_type_value (name, newtype);
2277 /* Emit debug info. */
2278 if (!processing_template_decl)
2279 cp_emit_debug_info_for_using (orig_decl, current_scope());
2282 /* Returns true if ROOT (a namespace, class, or function) encloses
2283 CHILD. CHILD may be either a class type or a namespace. */
2286 is_ancestor (tree root, tree child)
2288 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2289 || TREE_CODE (root) == FUNCTION_DECL
2290 || CLASS_TYPE_P (root)));
2291 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2292 || CLASS_TYPE_P (child)));
2294 /* The global namespace encloses everything. */
2295 if (root == global_namespace)
2300 /* If we've run out of scopes, stop. */
2303 /* If we've reached the ROOT, it encloses CHILD. */
2306 /* Go out one level. */
2308 child = TYPE_NAME (child);
2309 child = DECL_CONTEXT (child);
2313 /* Enter the class or namespace scope indicated by T suitable for name
2314 lookup. T can be arbitrary scope, not necessary nested inside the
2315 current scope. Returns a non-null scope to pop iff pop_scope
2316 should be called later to exit this scope. */
2321 if (TREE_CODE (t) == NAMESPACE_DECL)
2322 push_decl_namespace (t);
2323 else if (CLASS_TYPE_P (t))
2325 if (!at_class_scope_p ()
2326 || !same_type_p (current_class_type, t))
2327 push_nested_class (t);
2329 /* T is the same as the current scope. There is therefore no
2330 need to re-enter the scope. Since we are not actually
2331 pushing a new scope, our caller should not call
2339 /* Leave scope pushed by push_scope. */
2344 if (TREE_CODE (t) == NAMESPACE_DECL)
2345 pop_decl_namespace ();
2346 else if CLASS_TYPE_P (t)
2347 pop_nested_class ();
2350 /* Subroutine of push_inner_scope. */
2353 push_inner_scope_r (tree outer, tree inner)
2358 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2361 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2363 push_inner_scope_r (outer, prev);
2364 if (TREE_CODE (inner) == NAMESPACE_DECL)
2366 struct cp_binding_level *save_template_parm = 0;
2367 /* Temporary take out template parameter scopes. They are saved
2368 in reversed order in save_template_parm. */
2369 while (current_binding_level->kind == sk_template_parms)
2371 struct cp_binding_level *b = current_binding_level;
2372 current_binding_level = b->level_chain;
2373 b->level_chain = save_template_parm;
2374 save_template_parm = b;
2377 resume_scope (NAMESPACE_LEVEL (inner));
2378 current_namespace = inner;
2380 /* Restore template parameter scopes. */
2381 while (save_template_parm)
2383 struct cp_binding_level *b = save_template_parm;
2384 save_template_parm = b->level_chain;
2385 b->level_chain = current_binding_level;
2386 current_binding_level = b;
2393 /* Enter the scope INNER from current scope. INNER must be a scope
2394 nested inside current scope. This works with both name lookup and
2395 pushing name into scope. In case a template parameter scope is present,
2396 namespace is pushed under the template parameter scope according to
2397 name lookup rule in 14.6.1/6.
2399 Return the former current scope suitable for pop_inner_scope. */
2402 push_inner_scope (tree inner)
2404 tree outer = current_scope ();
2406 outer = current_namespace;
2408 push_inner_scope_r (outer, inner);
2412 /* Exit the current scope INNER back to scope OUTER. */
2415 pop_inner_scope (tree outer, tree inner)
2418 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2421 while (outer != inner)
2423 if (TREE_CODE (inner) == NAMESPACE_DECL)
2425 struct cp_binding_level *save_template_parm = 0;
2426 /* Temporary take out template parameter scopes. They are saved
2427 in reversed order in save_template_parm. */
2428 while (current_binding_level->kind == sk_template_parms)
2430 struct cp_binding_level *b = current_binding_level;
2431 current_binding_level = b->level_chain;
2432 b->level_chain = save_template_parm;
2433 save_template_parm = b;
2438 /* Restore template parameter scopes. */
2439 while (save_template_parm)
2441 struct cp_binding_level *b = save_template_parm;
2442 save_template_parm = b->level_chain;
2443 b->level_chain = current_binding_level;
2444 current_binding_level = b;
2450 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2454 /* Do a pushlevel for class declarations. */
2457 pushlevel_class (void)
2459 if (ENABLE_SCOPE_CHECKING)
2462 class_binding_level = begin_scope (sk_class, current_class_type);
2465 /* ...and a poplevel for class declarations. */
2468 poplevel_class (void)
2470 struct cp_binding_level *level = class_binding_level;
2471 cp_class_binding *cb;
2475 timevar_push (TV_NAME_LOOKUP);
2476 gcc_assert (level != 0);
2478 /* If we're leaving a toplevel class, cache its binding level. */
2479 if (current_class_depth == 1)
2480 previous_class_level = level;
2481 for (shadowed = level->type_shadowed;
2483 shadowed = TREE_CHAIN (shadowed))
2484 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2486 /* Remove the bindings for all of the class-level declarations. */
2487 if (level->class_shadowed)
2490 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2492 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2493 ggc_free (level->class_shadowed);
2494 level->class_shadowed = NULL;
2497 /* Now, pop out of the binding level which we created up in the
2498 `pushlevel_class' routine. */
2499 if (ENABLE_SCOPE_CHECKING)
2503 timevar_pop (TV_NAME_LOOKUP);
2506 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2507 appropriate. DECL is the value to which a name has just been
2508 bound. CLASS_TYPE is the class in which the lookup occurred. */
2511 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2514 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2518 if (TREE_CODE (decl) == OVERLOAD)
2519 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2522 gcc_assert (DECL_P (decl));
2523 context = context_for_name_lookup (decl);
2526 if (is_properly_derived_from (class_type, context))
2527 INHERITED_VALUE_BINDING_P (binding) = 1;
2529 INHERITED_VALUE_BINDING_P (binding) = 0;
2531 else if (binding->value == decl)
2532 /* We only encounter a TREE_LIST when there is an ambiguity in the
2533 base classes. Such an ambiguity can be overridden by a
2534 definition in this class. */
2535 INHERITED_VALUE_BINDING_P (binding) = 1;
2537 INHERITED_VALUE_BINDING_P (binding) = 0;
2540 /* Make the declaration of X appear in CLASS scope. */
2543 pushdecl_class_level (tree x)
2546 bool is_valid = true;
2548 timevar_push (TV_NAME_LOOKUP);
2549 /* Get the name of X. */
2550 if (TREE_CODE (x) == OVERLOAD)
2551 name = DECL_NAME (get_first_fn (x));
2553 name = DECL_NAME (x);
2557 is_valid = push_class_level_binding (name, x);
2558 if (TREE_CODE (x) == TYPE_DECL)
2559 set_identifier_type_value (name, x);
2561 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2563 /* If X is an anonymous aggregate, all of its members are
2564 treated as if they were members of the class containing the
2565 aggregate, for naming purposes. */
2568 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2570 location_t save_location = input_location;
2571 input_location = DECL_SOURCE_LOCATION (f);
2572 if (!pushdecl_class_level (f))
2574 input_location = save_location;
2577 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2580 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2581 scope. If the value returned is non-NULL, and the PREVIOUS field
2582 is not set, callers must set the PREVIOUS field explicitly. */
2584 static cxx_binding *
2585 get_class_binding (tree name, cxx_scope *scope)
2590 cxx_binding *binding;
2592 class_type = scope->this_entity;
2594 /* Get the type binding. */
2595 type_binding = lookup_member (class_type, name,
2596 /*protect=*/2, /*want_type=*/true);
2597 /* Get the value binding. */
2598 value_binding = lookup_member (class_type, name,
2599 /*protect=*/2, /*want_type=*/false);
2602 && (TREE_CODE (value_binding) == TYPE_DECL
2603 || DECL_CLASS_TEMPLATE_P (value_binding)
2604 || (TREE_CODE (value_binding) == TREE_LIST
2605 && TREE_TYPE (value_binding) == error_mark_node
2606 && (TREE_CODE (TREE_VALUE (value_binding))
2608 /* We found a type binding, even when looking for a non-type
2609 binding. This means that we already processed this binding
2612 else if (value_binding)
2614 if (TREE_CODE (value_binding) == TREE_LIST
2615 && TREE_TYPE (value_binding) == error_mark_node)
2616 /* NAME is ambiguous. */
2618 else if (BASELINK_P (value_binding))
2619 /* NAME is some overloaded functions. */
2620 value_binding = BASELINK_FUNCTIONS (value_binding);
2623 /* If we found either a type binding or a value binding, create a
2624 new binding object. */
2625 if (type_binding || value_binding)
2627 binding = new_class_binding (name,
2631 /* This is a class-scope binding, not a block-scope binding. */
2632 LOCAL_BINDING_P (binding) = 0;
2633 set_inherited_value_binding_p (binding, value_binding, class_type);
2641 /* Make the declaration(s) of X appear in CLASS scope under the name
2642 NAME. Returns true if the binding is valid. */
2645 push_class_level_binding (tree name, tree x)
2647 cxx_binding *binding;
2651 timevar_push (TV_NAME_LOOKUP);
2652 /* The class_binding_level will be NULL if x is a template
2653 parameter name in a member template. */
2654 if (!class_binding_level)
2655 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2657 if (name == error_mark_node)
2658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2660 /* Check for invalid member names. */
2661 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2662 /* We could have been passed a tree list if this is an ambiguous
2663 declaration. If so, pull the declaration out because
2664 check_template_shadow will not handle a TREE_LIST. */
2665 if (TREE_CODE (decl) == TREE_LIST
2666 && TREE_TYPE (decl) == error_mark_node)
2667 decl = TREE_VALUE (decl);
2669 check_template_shadow (decl);
2673 If T is the name of a class, then each of the following shall
2674 have a name different from T:
2676 -- every static data member of class T;
2678 -- every member of class T that is itself a type;
2680 -- every enumerator of every member of class T that is an
2683 -- every member of every anonymous union that is a member of
2686 (Non-static data members were also forbidden to have the same
2687 name as T until TC1.) */
2688 if ((TREE_CODE (x) == VAR_DECL
2689 || TREE_CODE (x) == CONST_DECL
2690 || (TREE_CODE (x) == TYPE_DECL
2691 && !DECL_SELF_REFERENCE_P (x))
2692 /* A data member of an anonymous union. */
2693 || (TREE_CODE (x) == FIELD_DECL
2694 && DECL_CONTEXT (x) != current_class_type))
2695 && DECL_NAME (x) == constructor_name (current_class_type))
2697 tree scope = context_for_name_lookup (x);
2698 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2700 error ("%qD has the same name as the class in which it is "
2703 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2707 /* Get the current binding for NAME in this class, if any. */
2708 binding = IDENTIFIER_BINDING (name);
2709 if (!binding || binding->scope != class_binding_level)
2711 binding = get_class_binding (name, class_binding_level);
2712 /* If a new binding was created, put it at the front of the
2713 IDENTIFIER_BINDING list. */
2716 binding->previous = IDENTIFIER_BINDING (name);
2717 IDENTIFIER_BINDING (name) = binding;
2721 /* If there is already a binding, then we may need to update the
2723 if (binding && binding->value)
2725 tree bval = binding->value;
2726 tree old_decl = NULL_TREE;
2728 if (INHERITED_VALUE_BINDING_P (binding))
2730 /* If the old binding was from a base class, and was for a
2731 tag name, slide it over to make room for the new binding.
2732 The old binding is still visible if explicitly qualified
2733 with a class-key. */
2734 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2735 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2737 old_decl = binding->type;
2738 binding->type = bval;
2739 binding->value = NULL_TREE;
2740 INHERITED_VALUE_BINDING_P (binding) = 0;
2745 /* Any inherited type declaration is hidden by the type
2746 declaration in the derived class. */
2747 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2748 binding->type = NULL_TREE;
2751 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2753 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2755 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2757 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2760 if (old_decl && binding->scope == class_binding_level)
2763 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2764 here. This function is only used to register bindings
2765 from with the class definition itself. */
2766 INHERITED_VALUE_BINDING_P (binding) = 0;
2767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2771 /* Note that we declared this value so that we can issue an error if
2772 this is an invalid redeclaration of a name already used for some
2774 note_name_declared_in_class (name, decl);
2776 /* If we didn't replace an existing binding, put the binding on the
2777 stack of bindings for the identifier, and update the shadowed
2779 if (binding && binding->scope == class_binding_level)
2780 /* Supplement the existing binding. */
2781 ok = supplement_binding (binding, decl);
2784 /* Create a new binding. */
2785 push_binding (name, decl, class_binding_level);
2789 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2792 /* Process "using SCOPE::NAME" in a class scope. Return the
2793 USING_DECL created. */
2796 do_class_using_decl (tree scope, tree name)
2798 /* The USING_DECL returned by this function. */
2800 /* The declaration (or declarations) name by this using
2801 declaration. NULL if we are in a template and cannot figure out
2802 what has been named. */
2804 /* True if SCOPE is a dependent type. */
2805 bool scope_dependent_p;
2806 /* True if SCOPE::NAME is dependent. */
2807 bool name_dependent_p;
2808 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2809 bool bases_dependent_p;
2814 if (name == error_mark_node)
2817 if (!scope || !TYPE_P (scope))
2819 error ("using-declaration for non-member at class scope");
2823 /* Make sure the name is not invalid */
2824 if (TREE_CODE (name) == BIT_NOT_EXPR)
2826 error ("%<%T::%D%> names destructor", scope, name);
2829 if (IS_AGGR_TYPE (scope) && constructor_name_p (name, scope))
2831 error ("%<%T::%D%> names constructor", scope, name);
2834 if (constructor_name_p (name, current_class_type))
2836 error ("%<%T::%D%> names constructor in %qT",
2837 scope, name, current_class_type);
2841 scope_dependent_p = dependent_type_p (scope);
2842 name_dependent_p = (scope_dependent_p
2843 || (IDENTIFIER_TYPENAME_P (name)
2844 && dependent_type_p (TREE_TYPE (name))));
2846 bases_dependent_p = false;
2847 if (processing_template_decl)
2848 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2849 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2851 if (dependent_type_p (TREE_TYPE (base_binfo)))
2853 bases_dependent_p = true;
2859 /* From [namespace.udecl]:
2861 A using-declaration used as a member-declaration shall refer to a
2862 member of a base class of the class being defined.
2864 In general, we cannot check this constraint in a template because
2865 we do not know the entire set of base classes of the current
2866 class type. However, if all of the base classes are
2867 non-dependent, then we can avoid delaying the check until
2869 if (!scope_dependent_p)
2872 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2873 if (b_kind < bk_proper_base)
2875 if (!bases_dependent_p)
2877 error_not_base_type (scope, current_class_type);
2881 else if (!name_dependent_p)
2883 decl = lookup_member (binfo, name, 0, false);
2886 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2890 /* The binfo from which the functions came does not matter. */
2891 if (BASELINK_P (decl))
2892 decl = BASELINK_FUNCTIONS (decl);
2896 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2897 USING_DECL_DECLS (value) = decl;
2898 USING_DECL_SCOPE (value) = scope;
2899 DECL_DEPENDENT_P (value) = !decl;
2905 /* Return the binding value for name in scope. */
2908 namespace_binding (tree name, tree scope)
2910 cxx_binding *binding;
2913 scope = global_namespace;
2915 /* Unnecessary for the global namespace because it can't be an alias. */
2916 scope = ORIGINAL_NAMESPACE (scope);
2918 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2920 return binding ? binding->value : NULL_TREE;
2923 /* Set the binding value for name in scope. */
2926 set_namespace_binding (tree name, tree scope, tree val)
2930 timevar_push (TV_NAME_LOOKUP);
2931 if (scope == NULL_TREE)
2932 scope = global_namespace;
2933 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2934 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2937 supplement_binding (b, val);
2938 timevar_pop (TV_NAME_LOOKUP);
2941 /* Set the context of a declaration to scope. Complain if we are not
2945 set_decl_namespace (tree decl, tree scope, bool friendp)
2949 /* Get rid of namespace aliases. */
2950 scope = ORIGINAL_NAMESPACE (scope);
2952 /* It is ok for friends to be qualified in parallel space. */
2953 if (!friendp && !is_ancestor (current_namespace, scope))
2954 error ("declaration of %qD not in a namespace surrounding %qD",
2956 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2958 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2959 if (scope == current_namespace)
2961 if (at_namespace_scope_p ())
2962 error ("explicit qualification in declaration of %qD",
2967 /* See whether this has been declared in the namespace. */
2968 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2969 if (old == error_mark_node)
2970 /* No old declaration at all. */
2972 if (!is_overloaded_fn (decl))
2973 /* Don't compare non-function decls with decls_match here, since
2974 it can't check for the correct constness at this
2975 point. pushdecl will find those errors later. */
2977 /* Since decl is a function, old should contain a function decl. */
2978 if (!is_overloaded_fn (old))
2980 fn = OVL_CURRENT (old);
2981 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2983 /* A template can be explicitly specialized in any namespace. */
2984 if (processing_explicit_instantiation)
2986 if (processing_template_decl || processing_specialization)
2987 /* We have not yet called push_template_decl to turn a
2988 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2989 match. But, we'll check later, when we construct the
2992 /* Instantiations or specializations of templates may be declared as
2993 friends in any namespace. */
2994 if (friendp && DECL_USE_TEMPLATE (decl))
2996 if (is_overloaded_fn (old))
2998 for (; old; old = OVL_NEXT (old))
2999 if (decls_match (decl, OVL_CURRENT (old)))
3002 else if (decls_match (decl, old))
3005 error ("%qD should have been declared inside %qD", decl, scope);
3008 /* Return the namespace where the current declaration is declared. */
3011 current_decl_namespace (void)
3014 /* If we have been pushed into a different namespace, use it. */
3015 if (decl_namespace_list)
3016 return TREE_PURPOSE (decl_namespace_list);
3018 if (current_class_type)
3019 result = decl_namespace_context (current_class_type);
3020 else if (current_function_decl)
3021 result = decl_namespace_context (current_function_decl);
3023 result = current_namespace;
3027 /* Process any ATTRIBUTES on a namespace definition. Currently only
3028 attribute visibility is meaningful, which is a property of the syntactic
3029 block rather than the namespace as a whole, so we don't touch the
3030 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3033 handle_namespace_attrs (tree ns, tree attributes)
3036 bool saw_vis = false;
3038 for (d = attributes; d; d = TREE_CHAIN (d))
3040 tree name = TREE_PURPOSE (d);
3041 tree args = TREE_VALUE (d);
3043 #ifdef HANDLE_PRAGMA_VISIBILITY
3044 if (is_attribute_p ("visibility", name))
3046 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3047 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3049 warning (OPT_Wattributes,
3050 "%qD attribute requires a single NTBS argument",
3055 if (!TREE_PUBLIC (ns))
3056 warning (OPT_Wattributes,
3057 "%qD attribute is meaningless since members of the "
3058 "anonymous namespace get local symbols", name);
3060 push_visibility (TREE_STRING_POINTER (x));
3066 warning (OPT_Wattributes, "%qD attribute directive ignored",
3075 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3076 select a name that is unique to this compilation unit. */
3079 push_namespace (tree name)
3083 int implicit_use = 0;
3086 timevar_push (TV_NAME_LOOKUP);
3088 /* We should not get here if the global_namespace is not yet constructed
3089 nor if NAME designates the global namespace: The global scope is
3090 constructed elsewhere. */
3091 gcc_assert (global_namespace != NULL && name != global_scope_name);
3095 name = get_anonymous_namespace_name();
3096 d = IDENTIFIER_NAMESPACE_VALUE (name);
3098 /* Reopening anonymous namespace. */
3104 /* Check whether this is an extended namespace definition. */
3105 d = IDENTIFIER_NAMESPACE_VALUE (name);
3106 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3109 if (DECL_NAMESPACE_ALIAS (d))
3111 error ("namespace alias %qD not allowed here, assuming %qD",
3112 d, DECL_NAMESPACE_ALIAS (d));
3113 d = DECL_NAMESPACE_ALIAS (d);
3120 /* Make a new namespace, binding the name to it. */
3121 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3122 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3123 /* The name of this namespace is not visible to other translation
3124 units if it is an anonymous namespace or member thereof. */
3125 if (anon || decl_anon_ns_mem_p (current_namespace))
3126 TREE_PUBLIC (d) = 0;
3128 TREE_PUBLIC (d) = 1;
3132 /* Clear DECL_NAME for the benefit of debugging back ends. */
3133 SET_DECL_ASSEMBLER_NAME (d, name);
3134 DECL_NAME (d) = NULL_TREE;
3136 begin_scope (sk_namespace, d);
3139 resume_scope (NAMESPACE_LEVEL (d));
3142 do_using_directive (d);
3143 /* Enter the name space. */
3144 current_namespace = d;
3146 timevar_pop (TV_NAME_LOOKUP);
3149 /* Pop from the scope of the current namespace. */
3152 pop_namespace (void)
3154 gcc_assert (current_namespace != global_namespace);
3155 current_namespace = CP_DECL_CONTEXT (current_namespace);
3156 /* The binding level is not popped, as it might be re-opened later. */
3160 /* Push into the scope of the namespace NS, even if it is deeply
3161 nested within another namespace. */
3164 push_nested_namespace (tree ns)
3166 if (ns == global_namespace)
3167 push_to_top_level ();
3170 push_nested_namespace (CP_DECL_CONTEXT (ns));
3171 push_namespace (DECL_NAME (ns));
3175 /* Pop back from the scope of the namespace NS, which was previously
3176 entered with push_nested_namespace. */
3179 pop_nested_namespace (tree ns)
3181 timevar_push (TV_NAME_LOOKUP);
3182 while (ns != global_namespace)
3185 ns = CP_DECL_CONTEXT (ns);
3188 pop_from_top_level ();
3189 timevar_pop (TV_NAME_LOOKUP);
3192 /* Temporarily set the namespace for the current declaration. */
3195 push_decl_namespace (tree decl)
3197 if (TREE_CODE (decl) != NAMESPACE_DECL)
3198 decl = decl_namespace_context (decl);
3199 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3200 NULL_TREE, decl_namespace_list);
3203 /* [namespace.memdef]/2 */
3206 pop_decl_namespace (void)
3208 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3211 /* Return the namespace that is the common ancestor
3212 of two given namespaces. */
3215 namespace_ancestor (tree ns1, tree ns2)
3217 timevar_push (TV_NAME_LOOKUP);
3218 if (is_ancestor (ns1, ns2))
3219 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3220 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3221 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3224 /* Process a namespace-alias declaration. */
3227 do_namespace_alias (tree alias, tree namespace)
3229 if (namespace == error_mark_node)
3232 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3234 namespace = ORIGINAL_NAMESPACE (namespace);
3236 /* Build the alias. */
3237 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3238 DECL_NAMESPACE_ALIAS (alias) = namespace;
3239 DECL_EXTERNAL (alias) = 1;
3240 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3243 /* Emit debug info for namespace alias. */
3244 (*debug_hooks->global_decl) (alias);
3247 /* Like pushdecl, only it places X in the current namespace,
3251 pushdecl_namespace_level (tree x, bool is_friend)
3253 struct cp_binding_level *b = current_binding_level;
3256 timevar_push (TV_NAME_LOOKUP);
3257 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3259 /* Now, the type_shadowed stack may screw us. Munge it so it does
3261 if (TREE_CODE (t) == TYPE_DECL)
3263 tree name = DECL_NAME (t);
3265 tree *ptr = (tree *)0;
3266 for (; !global_scope_p (b); b = b->level_chain)
3268 tree shadowed = b->type_shadowed;
3269 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3270 if (TREE_PURPOSE (shadowed) == name)
3272 ptr = &TREE_VALUE (shadowed);
3273 /* Can't break out of the loop here because sometimes
3274 a binding level will have duplicate bindings for
3275 PT names. It's gross, but I haven't time to fix it. */
3278 newval = TREE_TYPE (t);
3279 if (ptr == (tree *)0)
3281 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3282 up here if this is changed to an assertion. --KR */
3283 SET_IDENTIFIER_TYPE_VALUE (name, t);
3290 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3293 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3294 directive is not directly from the source. Also find the common
3295 ancestor and let our users know about the new namespace */
3297 add_using_namespace (tree user, tree used, bool indirect)
3300 timevar_push (TV_NAME_LOOKUP);
3301 /* Using oneself is a no-op. */
3304 timevar_pop (TV_NAME_LOOKUP);
3307 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3308 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3309 /* Check if we already have this. */
3310 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3314 /* Promote to direct usage. */
3315 TREE_INDIRECT_USING (t) = 0;
3316 timevar_pop (TV_NAME_LOOKUP);
3320 /* Add used to the user's using list. */
3321 DECL_NAMESPACE_USING (user)
3322 = tree_cons (used, namespace_ancestor (user, used),
3323 DECL_NAMESPACE_USING (user));
3325 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3327 /* Add user to the used's users list. */
3328 DECL_NAMESPACE_USERS (used)
3329 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3331 /* Recursively add all namespaces used. */
3332 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3333 /* indirect usage */
3334 add_using_namespace (user, TREE_PURPOSE (t), 1);
3336 /* Tell everyone using us about the new used namespaces. */
3337 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3338 add_using_namespace (TREE_PURPOSE (t), used, 1);
3339 timevar_pop (TV_NAME_LOOKUP);
3342 /* Process a using-declaration not appearing in class or local scope. */
3345 do_toplevel_using_decl (tree decl, tree scope, tree name)
3347 tree oldval, oldtype, newval, newtype;
3348 tree orig_decl = decl;
3349 cxx_binding *binding;
3351 decl = validate_nonmember_using_decl (decl, scope, name);
3352 if (decl == NULL_TREE)
3355 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3357 oldval = binding->value;
3358 oldtype = binding->type;
3360 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3362 /* Emit debug info. */
3363 if (!processing_template_decl)
3364 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3366 /* Copy declarations found. */
3368 binding->value = newval;
3370 binding->type = newtype;
3373 /* Process a using-directive. */
3376 do_using_directive (tree namespace)
3378 tree context = NULL_TREE;
3380 if (namespace == error_mark_node)
3383 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3385 if (building_stmt_tree ())
3386 add_stmt (build_stmt (USING_STMT, namespace));
3387 namespace = ORIGINAL_NAMESPACE (namespace);
3389 if (!toplevel_bindings_p ())
3391 push_using_directive (namespace);
3392 context = current_scope ();
3397 add_using_namespace (current_namespace, namespace, 0);
3398 if (current_namespace != global_namespace)
3399 context = current_namespace;
3402 /* Emit debugging info. */
3403 if (!processing_template_decl)
3404 (*debug_hooks->imported_module_or_decl) (namespace, context);
3407 /* Deal with a using-directive seen by the parser. Currently we only
3408 handle attributes here, since they cannot appear inside a template. */
3411 parse_using_directive (tree namespace, tree attribs)
3415 do_using_directive (namespace);
3417 for (a = attribs; a; a = TREE_CHAIN (a))
3419 tree name = TREE_PURPOSE (a);
3420 if (is_attribute_p ("strong", name))
3422 if (!toplevel_bindings_p ())
3423 error ("strong using only meaningful at namespace scope");
3424 else if (namespace != error_mark_node)
3426 if (!is_ancestor (current_namespace, namespace))
3427 error ("current namespace %qD does not enclose strongly used namespace %qD",
3428 current_namespace, namespace);
3429 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3430 = tree_cons (current_namespace, 0,
3431 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3435 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3439 /* Like pushdecl, only it places X in the global scope if appropriate.
3440 Calls cp_finish_decl to register the variable, initializing it with
3441 *INIT, if INIT is non-NULL. */
3444 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3446 timevar_push (TV_NAME_LOOKUP);
3447 push_to_top_level ();
3448 x = pushdecl_namespace_level (x, is_friend);
3450 finish_decl (x, *init, NULL_TREE);
3451 pop_from_top_level ();
3452 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3455 /* Like pushdecl, only it places X in the global scope if appropriate. */
3458 pushdecl_top_level (tree x)
3460 return pushdecl_top_level_1 (x, NULL, false);
3463 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3466 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3468 return pushdecl_top_level_1 (x, NULL, is_friend);
3471 /* Like pushdecl, only it places X in the global scope if
3472 appropriate. Calls cp_finish_decl to register the variable,
3473 initializing it with INIT. */
3476 pushdecl_top_level_and_finish (tree x, tree init)
3478 return pushdecl_top_level_1 (x, &init, false);
3481 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3482 duplicates. The first list becomes the tail of the result.
3484 The algorithm is O(n^2). We could get this down to O(n log n) by
3485 doing a sort on the addresses of the functions, if that becomes
3489 merge_functions (tree s1, tree s2)
3491 for (; s2; s2 = OVL_NEXT (s2))
3493 tree fn2 = OVL_CURRENT (s2);
3496 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3498 tree fn1 = OVL_CURRENT (fns1);
3500 /* If the function from S2 is already in S1, there is no
3501 need to add it again. For `extern "C"' functions, we
3502 might have two FUNCTION_DECLs for the same function, in
3503 different namespaces; again, we only need one of them. */
3505 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3506 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3510 /* If we exhausted all of the functions in S1, FN2 is new. */
3512 s1 = build_overload (fn2, s1);
3517 /* This should return an error not all definitions define functions.
3518 It is not an error if we find two functions with exactly the
3519 same signature, only if these are selected in overload resolution.
3520 old is the current set of bindings, new the freshly-found binding.
3521 XXX Do we want to give *all* candidates in case of ambiguity?
3522 XXX In what way should I treat extern declarations?
3523 XXX I don't want to repeat the entire duplicate_decls here */
3526 ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
3529 gcc_assert (old != NULL);
3531 /* Copy the type. */
3533 if (LOOKUP_NAMESPACES_ONLY (flags)
3534 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3537 /* Copy the value. */
3541 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3544 switch (TREE_CODE (val))
3547 /* If we expect types or namespaces, and not templates,
3548 or this is not a template class. */
3549 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3550 && !DECL_CLASS_TEMPLATE_P (val)))
3554 if (LOOKUP_NAMESPACES_ONLY (flags)
3555 || (type && (flags & LOOKUP_PREFER_TYPES)))
3558 case NAMESPACE_DECL:
3559 if (LOOKUP_TYPES_ONLY (flags))
3563 /* Ignore built-in functions that are still anticipated. */
3564 if (LOOKUP_QUALIFIERS_ONLY (flags))
3568 if (LOOKUP_QUALIFIERS_ONLY (flags))
3573 /* If val is hidden, shift down any class or enumeration name. */
3582 else if (val && val != old->value)
3584 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3585 old->value = merge_functions (old->value, val);
3588 old->value = tree_cons (NULL_TREE, old->value,
3589 build_tree_list (NULL_TREE, val));
3590 TREE_TYPE (old->value) = error_mark_node;
3596 else if (type && old->type != type)
3598 old->type = tree_cons (NULL_TREE, old->type,
3599 build_tree_list (NULL_TREE, type));
3600 TREE_TYPE (old->type) = error_mark_node;
3604 /* Return the declarations that are members of the namespace NS. */
3607 cp_namespace_decls (tree ns)
3609 return NAMESPACE_LEVEL (ns)->names;
3612 /* Combine prefer_type and namespaces_only into flags. */
3615 lookup_flags (int prefer_type, int namespaces_only)
3617 if (namespaces_only)
3618 return LOOKUP_PREFER_NAMESPACES;
3619 if (prefer_type > 1)
3620 return LOOKUP_PREFER_TYPES;
3621 if (prefer_type > 0)
3622 return LOOKUP_PREFER_BOTH;
3626 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3627 ignore it or not. Subroutine of lookup_name_real and
3628 lookup_type_scope. */
3631 qualify_lookup (tree val, int flags)
3633 if (val == NULL_TREE)
3635 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3637 if ((flags & LOOKUP_PREFER_TYPES)
3638 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3640 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3645 /* Given a lookup that returned VAL, decide if we want to ignore it or
3646 not based on DECL_ANTICIPATED. */
3649 hidden_name_p (tree val)
3652 && DECL_LANG_SPECIFIC (val)
3653 && DECL_ANTICIPATED (val))
3658 /* Remove any hidden friend functions from a possibly overloaded set
3662 remove_hidden_names (tree fns)
3667 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3669 else if (TREE_CODE (fns) == OVERLOAD)
3673 for (o = fns; o; o = OVL_NEXT (o))
3674 if (hidden_name_p (OVL_CURRENT (o)))
3680 for (o = fns; o; o = OVL_NEXT (o))
3681 if (!hidden_name_p (OVL_CURRENT (o)))
3682 n = build_overload (OVL_CURRENT (o), n);
3690 /* Unscoped lookup of a global: iterate over current namespaces,
3691 considering using-directives. */
3694 unqualified_namespace_lookup (tree name, int flags)
3696 tree initial = current_decl_namespace ();
3697 tree scope = initial;
3699 struct cp_binding_level *level;
3700 tree val = NULL_TREE;
3702 timevar_push (TV_NAME_LOOKUP);
3704 for (; !val; scope = CP_DECL_CONTEXT (scope))
3706 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3708 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3711 ambiguous_decl (&binding, b, flags);
3713 /* Add all _DECLs seen through local using-directives. */
3714 for (level = current_binding_level;
3715 level->kind != sk_namespace;
3716 level = level->level_chain)
3717 if (!lookup_using_namespace (name, &binding, level->using_directives,
3719 /* Give up because of error. */
3720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3722 /* Add all _DECLs seen through global using-directives. */
3723 /* XXX local and global using lists should work equally. */
3727 if (!lookup_using_namespace (name, &binding,
3728 DECL_NAMESPACE_USING (siter),
3730 /* Give up because of error. */
3731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3732 if (siter == scope) break;
3733 siter = CP_DECL_CONTEXT (siter);
3736 val = binding.value;
3737 if (scope == global_namespace)
3740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3743 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3744 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3747 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3748 declaration found. If no suitable declaration can be found,
3749 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3750 neither a class-type nor a namespace a diagnostic is issued. */
3753 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3758 if (TREE_CODE (scope) == NAMESPACE_DECL)
3760 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3762 flags |= LOOKUP_COMPLAIN;
3764 flags |= LOOKUP_PREFER_TYPES;
3765 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3768 else if (is_aggr_type (scope, complain))
3769 t = lookup_member (scope, name, 2, is_type_p);
3772 return error_mark_node;
3776 /* Subroutine of unqualified_namespace_lookup:
3777 Add the bindings of NAME in used namespaces to VAL.
3778 We are currently looking for names in namespace SCOPE, so we
3779 look through USINGS for using-directives of namespaces
3780 which have SCOPE as a common ancestor with the current scope.
3781 Returns false on errors. */
3784 lookup_using_namespace (tree name, struct scope_binding *val,
3785 tree usings, tree scope, int flags)
3788 timevar_push (TV_NAME_LOOKUP);
3789 /* Iterate over all used namespaces in current, searching for using
3790 directives of scope. */
3791 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3792 if (TREE_VALUE (iter) == scope)
3794 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3796 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3797 /* Resolve ambiguities. */
3799 ambiguous_decl (val, val1, flags);
3801 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3805 Accepts the NAME to lookup and its qualifying SCOPE.
3806 Returns the name/type pair found into the cxx_binding *RESULT,
3807 or false on error. */
3810 qualified_lookup_using_namespace (tree name, tree scope,
3811 struct scope_binding *result, int flags)
3813 /* Maintain a list of namespaces visited... */
3814 tree seen = NULL_TREE;
3815 /* ... and a list of namespace yet to see. */
3816 tree todo = NULL_TREE;
3817 tree todo_maybe = NULL_TREE;
3819 timevar_push (TV_NAME_LOOKUP);
3820 /* Look through namespace aliases. */
3821 scope = ORIGINAL_NAMESPACE (scope);
3822 while (scope && result->value != error_mark_node)
3824 cxx_binding *binding =
3825 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3826 seen = tree_cons (scope, NULL_TREE, seen);
3828 ambiguous_decl (result, binding, flags);
3830 /* Consider strong using directives always, and non-strong ones
3831 if we haven't found a binding yet. ??? Shouldn't we consider
3832 non-strong ones if the initial RESULT is non-NULL, but the
3833 binding in the given namespace is? */
3834 for (usings = DECL_NAMESPACE_USING (scope); usings;
3835 usings = TREE_CHAIN (usings))
3836 /* If this was a real directive, and we have not seen it. */
3837 if (!TREE_INDIRECT_USING (usings))
3839 /* Try to avoid queuing the same namespace more than once,
3840 the exception being when a namespace was already
3841 enqueued for todo_maybe and then a strong using is
3842 found for it. We could try to remove it from
3843 todo_maybe, but it's probably not worth the effort. */
3844 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3845 && !purpose_member (TREE_PURPOSE (usings), seen)
3846 && !purpose_member (TREE_PURPOSE (usings), todo))
3847 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3848 else if ((!result->value && !result->type)
3849 && !purpose_member (TREE_PURPOSE (usings), seen)
3850 && !purpose_member (TREE_PURPOSE (usings), todo)
3851 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3852 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3857 scope = TREE_PURPOSE (todo);
3858 todo = TREE_CHAIN (todo);
3861 && (!result->value && !result->type))
3863 scope = TREE_PURPOSE (todo_maybe);
3864 todo = TREE_CHAIN (todo_maybe);
3865 todo_maybe = NULL_TREE;
3868 scope = NULL_TREE; /* If there never was a todo list. */
3870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3873 /* Return the innermost non-namespace binding for NAME from a scope
3874 containing BINDING, or, if BINDING is NULL, the current scope. If
3875 CLASS_P is false, then class bindings are ignored. */
3878 outer_binding (tree name,
3879 cxx_binding *binding,
3884 cxx_scope *outer_scope;
3888 scope = binding->scope->level_chain;
3889 outer = binding->previous;
3893 scope = current_binding_level;
3894 outer = IDENTIFIER_BINDING (name);
3896 outer_scope = outer ? outer->scope : NULL;
3898 /* Because we create class bindings lazily, we might be missing a
3899 class binding for NAME. If there are any class binding levels
3900 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3901 declared, we must lookup NAME in those class scopes. */
3903 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3905 if (scope->kind == sk_class)
3907 cxx_binding *class_binding;
3909 class_binding = get_class_binding (name, scope);
3912 /* Thread this new class-scope binding onto the
3913 IDENTIFIER_BINDING list so that future lookups
3915 class_binding->previous = outer;
3917 binding->previous = class_binding;
3919 IDENTIFIER_BINDING (name) = class_binding;
3920 return class_binding;
3923 scope = scope->level_chain;
3929 /* Return the innermost block-scope or class-scope value binding for
3930 NAME, or NULL_TREE if there is no such binding. */
3933 innermost_non_namespace_value (tree name)
3935 cxx_binding *binding;
3936 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3937 return binding ? binding->value : NULL_TREE;
3940 /* Look up NAME in the current binding level and its superiors in the
3941 namespace of variables, functions and typedefs. Return a ..._DECL
3942 node of some kind representing its definition if there is only one
3943 such declaration, or return a TREE_LIST with all the overloaded
3944 definitions if there are many, or return 0 if it is undefined.
3945 Hidden name, either friend declaration or built-in function, are
3948 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3949 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3950 Otherwise we prefer non-TYPE_DECLs.
3952 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3953 BLOCK_P is false, bindings in block scopes are ignored. */
3956 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3957 int namespaces_only, int flags)
3960 tree val = NULL_TREE;
3962 timevar_push (TV_NAME_LOOKUP);
3963 /* Conversion operators are handled specially because ordinary
3964 unqualified name lookup will not find template conversion
3966 if (IDENTIFIER_TYPENAME_P (name))
3968 struct cp_binding_level *level;
3970 for (level = current_binding_level;
3971 level && level->kind != sk_namespace;
3972 level = level->level_chain)
3977 /* A conversion operator can only be declared in a class
3979 if (level->kind != sk_class)
3982 /* Lookup the conversion operator in the class. */
3983 class_type = level->this_entity;
3984 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3986 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3989 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3992 flags |= lookup_flags (prefer_type, namespaces_only);
3994 /* First, look in non-namespace scopes. */
3996 if (current_class_type == NULL_TREE)
3999 if (block_p || !nonclass)
4000 for (iter = outer_binding (name, NULL, !nonclass);
4002 iter = outer_binding (name, iter, !nonclass))
4006 /* Skip entities we don't want. */
4007 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4010 /* If this is the kind of thing we're looking for, we're done. */
4011 if (qualify_lookup (iter->value, flags))
4012 binding = iter->value;
4013 else if ((flags & LOOKUP_PREFER_TYPES)
4014 && qualify_lookup (iter->type, flags))
4015 binding = iter->type;
4017 binding = NULL_TREE;
4021 if (hidden_name_p (binding))
4023 /* A non namespace-scope binding can only be hidden if
4024 we are in a local class, due to friend declarations.
4025 In particular, consider:
4030 void g() { B* b; } // error: B is hidden
4035 The standard says that "B" is a local class in "f"
4036 (but not nested within "A") -- but that name lookup
4037 for "B" does not find this declaration until it is
4038 declared directly with "f".
4044 If a friend declaration appears in a local class and
4045 the name specified is an unqualified name, a prior
4046 declaration is looked up without considering scopes
4047 that are outside the innermost enclosing non-class
4048 scope. For a friend class declaration, if there is no
4049 prior declaration, the class that is specified
4050 belongs to the innermost enclosing non-class scope,
4051 but if it is subsequently referenced, its name is not
4052 found by name lookup until a matching declaration is
4053 provided in the innermost enclosing nonclass scope.
4055 gcc_assert (current_class_type &&
4056 LOCAL_CLASS_P (current_class_type));
4058 /* This binding comes from a friend declaration in the local
4059 class. The standard (11.4.8) states that the lookup can
4060 only succeed if there is a non-hidden declaration in the
4061 current scope, which is not the case here. */
4062 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4069 /* Now lookup in namespace scopes. */
4071 val = unqualified_namespace_lookup (name, flags);
4073 /* If we have a single function from a using decl, pull it out. */
4074 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4075 val = OVL_FUNCTION (val);
4077 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4081 lookup_name_nonclass (tree name)
4083 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4087 lookup_function_nonclass (tree name, tree args, bool block_p)
4090 lookup_arg_dependent (name,
4091 lookup_name_real (name, 0, 1, block_p, 0,
4097 lookup_name (tree name)
4099 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4103 lookup_name_prefer_type (tree name, int prefer_type)
4105 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4106 0, LOOKUP_COMPLAIN);
4109 /* Look up NAME for type used in elaborated name specifier in
4110 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4111 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4112 name, more scopes are checked if cleanup or template parameter
4113 scope is encountered.
4115 Unlike lookup_name_real, we make sure that NAME is actually
4116 declared in the desired scope, not from inheritance, nor using
4117 directive. For using declaration, there is DR138 still waiting
4118 to be resolved. Hidden name coming from an earlier friend
4119 declaration is also returned.
4121 A TYPE_DECL best matching the NAME is returned. Catching error
4122 and issuing diagnostics are caller's responsibility. */
4125 lookup_type_scope (tree name, tag_scope scope)
4127 cxx_binding *iter = NULL;
4128 tree val = NULL_TREE;
4130 timevar_push (TV_NAME_LOOKUP);
4132 /* Look in non-namespace scope first. */
4133 if (current_binding_level->kind != sk_namespace)
4134 iter = outer_binding (name, NULL, /*class_p=*/ true);
4135 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4137 /* Check if this is the kind of thing we're looking for.
4138 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4139 base class. For ITER->VALUE, we can simply use
4140 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4143 We check ITER->TYPE before ITER->VALUE in order to handle
4144 typedef struct C {} C;
4147 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4148 && (scope != ts_current
4149 || LOCAL_BINDING_P (iter)
4150 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4152 else if ((scope != ts_current
4153 || !INHERITED_VALUE_BINDING_P (iter))
4154 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4161 /* Look in namespace scope. */
4164 iter = cxx_scope_find_binding_for_name
4165 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4169 /* If this is the kind of thing we're looking for, we're done. */
4170 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4172 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4178 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4179 and template parameter scopes. */
4182 struct cp_binding_level *b = current_binding_level;
4185 if (iter->scope == b)
4186 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4188 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4190 else if (b->kind == sk_class
4191 && scope == ts_within_enclosing_non_class)
4198 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4201 /* Similar to `lookup_name' but look only in the innermost non-class
4205 lookup_name_innermost_nonclass_level (tree name)
4207 struct cp_binding_level *b;
4210 timevar_push (TV_NAME_LOOKUP);
4211 b = innermost_nonclass_level ();
4213 if (b->kind == sk_namespace)
4215 t = IDENTIFIER_NAMESPACE_VALUE (name);
4217 /* extern "C" function() */
4218 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4221 else if (IDENTIFIER_BINDING (name)
4222 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4224 cxx_binding *binding;
4225 binding = IDENTIFIER_BINDING (name);
4228 if (binding->scope == b
4229 && !(TREE_CODE (binding->value) == VAR_DECL
4230 && DECL_DEAD_FOR_LOCAL (binding->value)))
4231 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4233 if (b->kind == sk_cleanup)
4240 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4243 /* Like lookup_name_innermost_nonclass_level, but for types. */
4246 lookup_type_current_level (tree name)
4250 timevar_push (TV_NAME_LOOKUP);
4251 gcc_assert (current_binding_level->kind != sk_namespace);
4253 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4254 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4256 struct cp_binding_level *b = current_binding_level;
4259 if (purpose_member (name, b->type_shadowed))
4260 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4261 REAL_IDENTIFIER_TYPE_VALUE (name));
4262 if (b->kind == sk_cleanup)
4269 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4272 /* [basic.lookup.koenig] */
4273 /* A nonzero return value in the functions below indicates an error. */
4284 static bool arg_assoc (struct arg_lookup*, tree);
4285 static bool arg_assoc_args (struct arg_lookup*, tree);
4286 static bool arg_assoc_type (struct arg_lookup*, tree);
4287 static bool add_function (struct arg_lookup *, tree);
4288 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4289 static bool arg_assoc_class (struct arg_lookup *, tree);
4290 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4292 /* Add a function to the lookup structure.
4293 Returns true on error. */
4296 add_function (struct arg_lookup *k, tree fn)
4298 /* We used to check here to see if the function was already in the list,
4299 but that's O(n^2), which is just too expensive for function lookup.
4300 Now we deal with the occasional duplicate in joust. In doing this, we
4301 assume that the number of duplicates will be small compared to the
4302 total number of functions being compared, which should usually be the
4305 /* We must find only functions, or exactly one non-function. */
4308 else if (fn == k->functions)
4310 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4311 k->functions = build_overload (fn, k->functions);
4314 tree f1 = OVL_CURRENT (k->functions);
4316 if (is_overloaded_fn (f1))
4318 fn = f1; f1 = f2; f2 = fn;
4320 error ("%q+D is not a function,", f1);
4321 error (" conflict with %q+D", f2);
4322 error (" in call to %qD", k->name);
4329 /* Returns true iff CURRENT has declared itself to be an associated
4330 namespace of SCOPE via a strong using-directive (or transitive chain
4331 thereof). Both are namespaces. */
4334 is_associated_namespace (tree current, tree scope)
4336 tree seen = NULL_TREE;
4337 tree todo = NULL_TREE;
4341 if (scope == current)
4343 seen = tree_cons (scope, NULL_TREE, seen);
4344 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4345 if (!purpose_member (TREE_PURPOSE (t), seen))
4346 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4349 scope = TREE_PURPOSE (todo);
4350 todo = TREE_CHAIN (todo);
4357 /* Return whether FN is a friend of an associated class of ARG. */
4360 friend_of_associated_class_p (tree arg, tree fn)
4366 else if (type_unknown_p (arg))
4369 type = TREE_TYPE (arg);
4371 /* If TYPE is a class, the class itself and all base classes are
4372 associated classes. */
4373 if (CLASS_TYPE_P (type))
4375 if (is_friend (type, fn))
4378 if (TYPE_BINFO (type))
4380 tree binfo, base_binfo;
4383 for (binfo = TYPE_BINFO (type), i = 0;
4384 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4386 if (is_friend (BINFO_TYPE (base_binfo), fn))
4391 /* If TYPE is a class member, the class of which it is a member is
4392 an associated class. */
4393 if ((CLASS_TYPE_P (type)
4394 || TREE_CODE (type) == UNION_TYPE
4395 || TREE_CODE (type) == ENUMERAL_TYPE)
4396 && TYPE_CONTEXT (type)
4397 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4398 && is_friend (TYPE_CONTEXT (type), fn))
4404 /* Add functions of a namespace to the lookup structure.
4405 Returns true on error. */
4408 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4412 if (purpose_member (scope, k->namespaces))
4414 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4416 /* Check out our super-users. */
4417 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4418 value = TREE_CHAIN (value))
4419 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4422 value = namespace_binding (k->name, scope);
4426 for (; value; value = OVL_NEXT (value))
4428 /* We don't want to find arbitrary hidden functions via argument
4429 dependent lookup. We only want to find friends of associated
4431 if (hidden_name_p (OVL_CURRENT (value)))
4435 for (args = k->args; args; args = TREE_CHAIN (args))
4436 if (friend_of_associated_class_p (TREE_VALUE (args),
4437 OVL_CURRENT (value)))
4443 if (add_function (k, OVL_CURRENT (value)))
4450 /* Adds everything associated with a template argument to the lookup
4451 structure. Returns true on error. */
4454 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4456 /* [basic.lookup.koenig]
4458 If T is a template-id, its associated namespaces and classes are
4459 ... the namespaces and classes associated with the types of the
4460 template arguments provided for template type parameters
4461 (excluding template template parameters); the namespaces in which
4462 any template template arguments are defined; and the classes in
4463 which any member templates used as template template arguments
4464 are defined. [Note: non-type template arguments do not
4465 contribute to the set of associated namespaces. ] */
4467 /* Consider first template template arguments. */
4468 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4469 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4471 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4473 tree ctx = CP_DECL_CONTEXT (arg);
4475 /* It's not a member template. */
4476 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4477 return arg_assoc_namespace (k, ctx);
4478 /* Otherwise, it must be member template. */
4480 return arg_assoc_class (k, ctx);
4482 /* It's an argument pack; handle it recursively. */
4483 else if (ARGUMENT_PACK_P (arg))
4485 tree args = ARGUMENT_PACK_ARGS (arg);
4486 int i, len = TREE_VEC_LENGTH (args);
4487 for (i = 0; i < len; ++i)
4488 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4493 /* It's not a template template argument, but it is a type template
4495 else if (TYPE_P (arg))
4496 return arg_assoc_type (k, arg);
4497 /* It's a non-type template argument. */
4502 /* Adds everything associated with class to the lookup structure.
4503 Returns true on error. */
4506 arg_assoc_class (struct arg_lookup *k, tree type)
4508 tree list, friends, context;
4511 /* Backend build structures, such as __builtin_va_list, aren't
4512 affected by all this. */
4513 if (!CLASS_TYPE_P (type))
4516 if (purpose_member (type, k->classes))
4518 k->classes = tree_cons (type, NULL_TREE, k->classes);
4520 context = decl_namespace_context (type);
4521 if (arg_assoc_namespace (k, context))
4524 if (TYPE_BINFO (type))
4526 /* Process baseclasses. */
4527 tree binfo, base_binfo;
4529 for (binfo = TYPE_BINFO (type), i = 0;
4530 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4531 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4535 /* Process friends. */
4536 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4537 list = TREE_CHAIN (list))
4538 if (k->name == FRIEND_NAME (list))
4539 for (friends = FRIEND_DECLS (list); friends;
4540 friends = TREE_CHAIN (friends))
4542 tree fn = TREE_VALUE (friends);
4544 /* Only interested in global functions with potentially hidden
4545 (i.e. unqualified) declarations. */
4546 if (CP_DECL_CONTEXT (fn) != context)
4548 /* Template specializations are never found by name lookup.
4549 (Templates themselves can be found, but not template
4550 specializations.) */
4551 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4553 if (add_function (k, fn))
4557 /* Process template arguments. */
4558 if (CLASSTYPE_TEMPLATE_INFO (type)
4559 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4561 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4562 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4563 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4569 /* Adds everything associated with a given type.
4570 Returns 1 on error. */
4573 arg_assoc_type (struct arg_lookup *k, tree type)
4575 /* As we do not get the type of non-type dependent expressions
4576 right, we can end up with such things without a type. */
4580 if (TYPE_PTRMEM_P (type))
4582 /* Pointer to member: associate class type and value type. */
4583 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4585 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4587 else switch (TREE_CODE (type))
4599 if (TYPE_PTRMEMFUNC_P (type))
4600 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4601 return arg_assoc_class (k, type);
4603 case REFERENCE_TYPE:
4605 return arg_assoc_type (k, TREE_TYPE (type));
4608 return arg_assoc_namespace (k, decl_namespace_context (type));
4610 /* The basetype is referenced in the first arg type, so just
4613 /* Associate the parameter types. */
4614 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4616 /* Associate the return type. */
4617 return arg_assoc_type (k, TREE_TYPE (type));
4618 case TEMPLATE_TYPE_PARM:
4619 case BOUND_TEMPLATE_TEMPLATE_PARM:
4624 gcc_assert (type == unknown_type_node);
4626 case TYPE_PACK_EXPANSION:
4627 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4635 /* Adds everything associated with arguments. Returns true on error. */
4638 arg_assoc_args (struct arg_lookup *k, tree args)
4640 for (; args; args = TREE_CHAIN (args))
4641 if (arg_assoc (k, TREE_VALUE (args)))
4646 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4649 arg_assoc (struct arg_lookup *k, tree n)
4651 if (n == error_mark_node)
4655 return arg_assoc_type (k, n);
4657 if (! type_unknown_p (n))
4658 return arg_assoc_type (k, TREE_TYPE (n));
4660 if (TREE_CODE (n) == ADDR_EXPR)
4661 n = TREE_OPERAND (n, 0);
4662 if (TREE_CODE (n) == COMPONENT_REF)
4663 n = TREE_OPERAND (n, 1);
4664 if (TREE_CODE (n) == OFFSET_REF)
4665 n = TREE_OPERAND (n, 1);
4666 while (TREE_CODE (n) == TREE_LIST)
4668 if (TREE_CODE (n) == BASELINK)
4669 n = BASELINK_FUNCTIONS (n);
4671 if (TREE_CODE (n) == FUNCTION_DECL)
4672 return arg_assoc_type (k, TREE_TYPE (n));
4673 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4675 /* [basic.lookup.koenig]
4677 If T is a template-id, its associated namespaces and classes
4678 are the namespace in which the template is defined; for
4679 member templates, the member template's class... */
4680 tree template = TREE_OPERAND (n, 0);
4681 tree args = TREE_OPERAND (n, 1);
4685 if (TREE_CODE (template) == COMPONENT_REF)
4686 template = TREE_OPERAND (template, 1);
4688 /* First, the template. There may actually be more than one if
4689 this is an overloaded function template. But, in that case,
4690 we only need the first; all the functions will be in the same
4692 template = OVL_CURRENT (template);
4694 ctx = CP_DECL_CONTEXT (template);
4696 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4698 if (arg_assoc_namespace (k, ctx) == 1)
4701 /* It must be a member template. */
4702 else if (arg_assoc_class (k, ctx) == 1)
4705 /* Now the arguments. */
4707 for (ix = TREE_VEC_LENGTH (args); ix--;)
4708 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4711 else if (TREE_CODE (n) == OVERLOAD)
4713 for (; n; n = OVL_CHAIN (n))
4714 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4721 /* Performs Koenig lookup depending on arguments, where fns
4722 are the functions found in normal lookup. */
4725 lookup_arg_dependent (tree name, tree fns, tree args)
4727 struct arg_lookup k;
4729 timevar_push (TV_NAME_LOOKUP);
4731 /* Remove any hidden friend functions from the list of functions
4732 found so far. They will be added back by arg_assoc_class as
4734 fns = remove_hidden_names (fns);
4739 k.classes = NULL_TREE;
4741 /* We previously performed an optimization here by setting
4742 NAMESPACES to the current namespace when it was safe. However, DR
4743 164 says that namespaces that were already searched in the first
4744 stage of template processing are searched again (potentially
4745 picking up later definitions) in the second stage. */
4746 k.namespaces = NULL_TREE;
4748 arg_assoc_args (&k, args);
4753 && TREE_CODE (fns) != VAR_DECL
4754 && !is_overloaded_fn (fns))
4756 error ("argument dependent lookup finds %q+D", fns);
4757 error (" in call to %qD", name);
4758 fns = error_mark_node;
4761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4764 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4765 changed (i.e. there was already a directive), or the fresh
4766 TREE_LIST otherwise. */
4769 push_using_directive (tree used)
4771 tree ud = current_binding_level->using_directives;
4772 tree iter, ancestor;
4774 timevar_push (TV_NAME_LOOKUP);
4775 /* Check if we already have this. */
4776 if (purpose_member (used, ud) != NULL_TREE)
4777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4779 ancestor = namespace_ancestor (current_decl_namespace (), used);
4780 ud = current_binding_level->using_directives;
4781 ud = tree_cons (used, ancestor, ud);
4782 current_binding_level->using_directives = ud;
4784 /* Recursively add all namespaces used. */
4785 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4786 push_using_directive (TREE_PURPOSE (iter));
4788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4791 /* The type TYPE is being declared. If it is a class template, or a
4792 specialization of a class template, do any processing required and
4793 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4794 being declared a friend. B is the binding level at which this TYPE
4797 Returns the TYPE_DECL for TYPE, which may have been altered by this
4801 maybe_process_template_type_declaration (tree type, int is_friend,
4804 tree decl = TYPE_NAME (type);
4806 if (processing_template_parmlist)
4807 /* You can't declare a new template type in a template parameter
4808 list. But, you can declare a non-template type:
4810 template <class A*> struct S;
4812 is a forward-declaration of `A'. */
4814 else if (b->kind == sk_namespace
4815 && current_binding_level->kind != sk_namespace)
4816 /* If this new type is being injected into a containing scope,
4817 then it's not a template type. */
4821 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4823 if (processing_template_decl)
4825 /* This may change after the call to
4826 push_template_decl_real, but we want the original value. */
4827 tree name = DECL_NAME (decl);
4829 decl = push_template_decl_real (decl, is_friend);
4830 /* If the current binding level is the binding level for the
4831 template parameters (see the comment in
4832 begin_template_parm_list) and the enclosing level is a class
4833 scope, and we're not looking at a friend, push the
4834 declaration of the member class into the class scope. In the
4835 friend case, push_template_decl will already have put the
4836 friend into global scope, if appropriate. */
4837 if (TREE_CODE (type) != ENUMERAL_TYPE
4838 && !is_friend && b->kind == sk_template_parms
4839 && b->level_chain->kind == sk_class)
4841 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4843 if (!COMPLETE_TYPE_P (current_class_type))
4845 maybe_add_class_template_decl_list (current_class_type,
4846 type, /*friend_p=*/0);
4847 /* Put this UTD in the table of UTDs for the class. */
4848 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4849 CLASSTYPE_NESTED_UTDS (current_class_type) =
4850 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4852 binding_table_insert
4853 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4862 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4863 that the NAME is a class template, the tag is processed but not pushed.
4865 The pushed scope depend on the SCOPE parameter:
4866 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4868 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4869 non-template-parameter scope. This case is needed for forward
4871 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4872 TS_GLOBAL case except that names within template-parameter scopes
4873 are not pushed at all.
4875 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4878 pushtag (tree name, tree type, tag_scope scope)
4880 struct cp_binding_level *b;
4883 timevar_push (TV_NAME_LOOKUP);
4884 b = current_binding_level;
4885 while (/* Cleanup scopes are not scopes from the point of view of
4887 b->kind == sk_cleanup
4888 /* Neither are the scopes used to hold template parameters
4889 for an explicit specialization. For an ordinary template
4890 declaration, these scopes are not scopes from the point of
4891 view of the language. */
4892 || (b->kind == sk_template_parms
4893 && (b->explicit_spec_p || scope == ts_global))
4894 || (b->kind == sk_class
4895 && (scope != ts_current
4896 /* We may be defining a new type in the initializer
4897 of a static member variable. We allow this when
4898 not pedantic, and it is particularly useful for
4899 type punning via an anonymous union. */
4900 || COMPLETE_TYPE_P (b->this_entity))))
4903 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4905 /* Do C++ gratuitous typedefing. */
4906 if (IDENTIFIER_TYPE_VALUE (name) != type)
4910 tree context = TYPE_CONTEXT (type);
4914 tree cs = current_scope ();
4916 if (scope == ts_current)
4918 else if (cs != NULL_TREE && TYPE_P (cs))
4919 /* When declaring a friend class of a local class, we want
4920 to inject the newly named class into the scope
4921 containing the local class, not the namespace
4923 context = decl_function_context (get_type_decl (cs));
4926 context = current_namespace;
4928 if (b->kind == sk_class
4929 || (b->kind == sk_template_parms
4930 && b->level_chain->kind == sk_class))
4933 if (current_lang_name == lang_name_java)
4934 TYPE_FOR_JAVA (type) = 1;
4936 tdef = create_implicit_typedef (name, type);
4937 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4938 if (scope == ts_within_enclosing_non_class)
4940 /* This is a friend. Make this TYPE_DECL node hidden from
4941 ordinary name lookup. Its corresponding TEMPLATE_DECL
4942 will be marked in push_template_decl_real. */
4943 retrofit_lang_decl (tdef);
4944 DECL_ANTICIPATED (tdef) = 1;
4945 DECL_FRIEND_P (tdef) = 1;
4948 decl = maybe_process_template_type_declaration
4949 (type, scope == ts_within_enclosing_non_class, b);
4950 if (decl == error_mark_node)
4951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4953 if (b->kind == sk_class)
4955 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4956 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4957 class. But if it's a member template class, we want
4958 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4960 finish_member_declaration (decl);
4962 pushdecl_class_level (decl);
4964 else if (b->kind != sk_template_parms)
4966 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4967 if (decl == error_mark_node)
4968 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4972 set_identifier_type_value_with_scope (name, tdef, b);
4974 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4976 /* If this is a local class, keep track of it. We need this
4977 information for name-mangling, and so that it is possible to
4978 find all function definitions in a translation unit in a
4979 convenient way. (It's otherwise tricky to find a member
4980 function definition it's only pointed to from within a local
4982 if (TYPE_CONTEXT (type)
4983 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4984 VEC_safe_push (tree, gc, local_classes, type);
4986 if (b->kind == sk_class
4987 && !COMPLETE_TYPE_P (current_class_type))
4989 maybe_add_class_template_decl_list (current_class_type,
4990 type, /*friend_p=*/0);
4992 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4993 CLASSTYPE_NESTED_UTDS (current_class_type)
4994 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4996 binding_table_insert
4997 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5000 decl = TYPE_NAME (type);
5001 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5002 TYPE_STUB_DECL (type) = decl;
5004 /* Set type visibility now if this is a forward declaration. */
5005 TREE_PUBLIC (decl) = 1;
5006 determine_visibility (decl);
5008 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5011 /* Subroutines for reverting temporarily to top-level for instantiation
5012 of templates and such. We actually need to clear out the class- and
5013 local-value slots of all identifiers, so that only the global values
5014 are at all visible. Simply setting current_binding_level to the global
5015 scope isn't enough, because more binding levels may be pushed. */
5016 struct saved_scope *scope_chain;
5018 /* If ID has not already been marked, add an appropriate binding to
5022 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5024 cxx_saved_binding *saved;
5026 if (!id || !IDENTIFIER_BINDING (id))
5029 if (IDENTIFIER_MARKED (id))
5032 IDENTIFIER_MARKED (id) = 1;
5034 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5035 saved->identifier = id;
5036 saved->binding = IDENTIFIER_BINDING (id);
5037 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5038 IDENTIFIER_BINDING (id) = NULL;
5042 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5046 timevar_push (TV_NAME_LOOKUP);
5047 for (t = names; t; t = TREE_CHAIN (t))
5051 if (TREE_CODE (t) == TREE_LIST)
5052 id = TREE_PURPOSE (t);
5056 store_binding (id, old_bindings);
5058 timevar_pop (TV_NAME_LOOKUP);
5061 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5062 objects, rather than a TREE_LIST. */
5065 store_class_bindings (VEC(cp_class_binding,gc) *names,
5066 VEC(cxx_saved_binding,gc) **old_bindings)
5069 cp_class_binding *cb;
5071 timevar_push (TV_NAME_LOOKUP);
5072 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5073 store_binding (cb->identifier, old_bindings);
5074 timevar_pop (TV_NAME_LOOKUP);
5078 push_to_top_level (void)
5080 struct saved_scope *s;
5081 struct cp_binding_level *b;
5082 cxx_saved_binding *sb;
5086 timevar_push (TV_NAME_LOOKUP);
5087 s = GGC_CNEW (struct saved_scope);
5089 b = scope_chain ? current_binding_level : 0;
5091 /* If we're in the middle of some function, save our state. */
5095 push_function_context_to (NULL_TREE);
5100 if (scope_chain && previous_class_level)
5101 store_class_bindings (previous_class_level->class_shadowed,
5104 /* Have to include the global scope, because class-scope decls
5105 aren't listed anywhere useful. */
5106 for (; b; b = b->level_chain)
5110 /* Template IDs are inserted into the global level. If they were
5111 inserted into namespace level, finish_file wouldn't find them
5112 when doing pending instantiations. Therefore, don't stop at
5113 namespace level, but continue until :: . */
5114 if (global_scope_p (b))
5117 store_bindings (b->names, &s->old_bindings);
5118 /* We also need to check class_shadowed to save class-level type
5119 bindings, since pushclass doesn't fill in b->names. */
5120 if (b->kind == sk_class)
5121 store_class_bindings (b->class_shadowed, &s->old_bindings);
5123 /* Unwind type-value slots back to top level. */
5124 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5125 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5128 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5129 IDENTIFIER_MARKED (sb->identifier) = 0;
5131 s->prev = scope_chain;
5133 s->need_pop_function_context = need_pop;
5134 s->function_decl = current_function_decl;
5135 s->skip_evaluation = skip_evaluation;
5138 current_function_decl = NULL_TREE;
5139 current_lang_base = VEC_alloc (tree, gc, 10);
5140 current_lang_name = lang_name_cplusplus;
5141 current_namespace = global_namespace;
5142 push_class_stack ();
5143 skip_evaluation = 0;
5144 timevar_pop (TV_NAME_LOOKUP);
5148 pop_from_top_level (void)
5150 struct saved_scope *s = scope_chain;
5151 cxx_saved_binding *saved;
5154 timevar_push (TV_NAME_LOOKUP);
5155 /* Clear out class-level bindings cache. */
5156 if (previous_class_level)
5157 invalidate_class_lookup_cache ();
5160 current_lang_base = 0;
5162 scope_chain = s->prev;
5163 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5165 tree id = saved->identifier;
5167 IDENTIFIER_BINDING (id) = saved->binding;
5168 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5171 /* If we were in the middle of compiling a function, restore our
5173 if (s->need_pop_function_context)
5174 pop_function_context_from (NULL_TREE);
5175 current_function_decl = s->function_decl;
5176 skip_evaluation = s->skip_evaluation;
5177 timevar_pop (TV_NAME_LOOKUP);
5180 /* Pop off extraneous binding levels left over due to syntax errors.
5182 We don't pop past namespaces, as they might be valid. */
5185 pop_everything (void)
5187 if (ENABLE_SCOPE_CHECKING)
5188 verbatim ("XXX entering pop_everything ()\n");
5189 while (!toplevel_bindings_p ())
5191 if (current_binding_level->kind == sk_class)
5192 pop_nested_class ();
5196 if (ENABLE_SCOPE_CHECKING)
5197 verbatim ("XXX leaving pop_everything ()\n");
5200 /* Emit debugging information for using declarations and directives.
5201 If input tree is overloaded fn then emit debug info for all
5205 cp_emit_debug_info_for_using (tree t, tree context)
5207 /* Don't try to emit any debug information if we have errors. */
5208 if (sorrycount || errorcount)
5211 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5212 of a builtin function. */
5213 if (TREE_CODE (t) == FUNCTION_DECL
5214 && DECL_EXTERNAL (t)
5215 && DECL_BUILT_IN (t))
5218 /* Do not supply context to imported_module_or_decl, if
5219 it is a global namespace. */
5220 if (context == global_namespace)
5221 context = NULL_TREE;
5224 t = BASELINK_FUNCTIONS (t);
5226 /* FIXME: Handle TEMPLATE_DECLs. */
5227 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5228 if (TREE_CODE (t) != TEMPLATE_DECL)
5229 (*debug_hooks->imported_module_or_decl) (t, context);
5232 #include "gt-cp-name-lookup.h"