1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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);
53 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name (void)
68 if (!anonymous_namespace_name)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 anonymous_namespace_name = get_file_function_name ("N");
74 return anonymous_namespace_name;
77 /* Compute the chain index of a binding_entry given the HASH value of its
78 name and the total COUNT of chains. COUNT is assumed to be a power
81 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
83 /* A free list of "binding_entry"s awaiting for re-use. */
85 static GTY((deletable)) binding_entry free_binding_entry = NULL;
87 /* Create a binding_entry object for (NAME, TYPE). */
89 static inline binding_entry
90 binding_entry_make (tree name, tree type)
94 if (free_binding_entry)
96 entry = free_binding_entry;
97 free_binding_entry = entry->chain;
100 entry = GGC_NEW (struct binding_entry_s);
109 /* Put ENTRY back on the free list. */
112 binding_entry_free (binding_entry entry)
116 entry->chain = free_binding_entry;
117 free_binding_entry = entry;
121 /* The datatype used to implement the mapping from names to types at
123 struct GTY(()) binding_table_s {
124 /* Array of chains of "binding_entry"s */
125 binding_entry * GTY((length ("%h.chain_count"))) chain;
127 /* The number of chains in this table. This is the length of the
128 member "chain" considered as an array. */
131 /* Number of "binding_entry"s in this table. */
135 /* Construct TABLE with an initial CHAIN_COUNT. */
138 binding_table_construct (binding_table table, size_t chain_count)
140 table->chain_count = chain_count;
141 table->entry_count = 0;
142 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
145 /* Make TABLE's entries ready for reuse. */
148 binding_table_free (binding_table table)
156 for (i = 0, count = table->chain_count; i < count; ++i)
158 binding_entry temp = table->chain[i];
161 binding_entry entry = temp;
163 binding_entry_free (entry);
165 table->chain[i] = NULL;
167 table->entry_count = 0;
171 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
173 static inline binding_table
174 binding_table_new (size_t chain_count)
176 binding_table table = GGC_NEW (struct binding_table_s);
178 binding_table_construct (table, chain_count);
182 /* Expand TABLE to twice its current chain_count. */
185 binding_table_expand (binding_table table)
187 const size_t old_chain_count = table->chain_count;
188 const size_t old_entry_count = table->entry_count;
189 const size_t new_chain_count = 2 * old_chain_count;
190 binding_entry *old_chains = table->chain;
193 binding_table_construct (table, new_chain_count);
194 for (i = 0; i < old_chain_count; ++i)
196 binding_entry entry = old_chains[i];
197 for (; entry != NULL; entry = old_chains[i])
199 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
200 const size_t j = ENTRY_INDEX (hash, new_chain_count);
202 old_chains[i] = entry->chain;
203 entry->chain = table->chain[j];
204 table->chain[j] = entry;
207 table->entry_count = old_entry_count;
210 /* Insert a binding for NAME to TYPE into TABLE. */
213 binding_table_insert (binding_table table, tree name, tree type)
215 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
216 const size_t i = ENTRY_INDEX (hash, table->chain_count);
217 binding_entry entry = binding_entry_make (name, type);
219 entry->chain = table->chain[i];
220 table->chain[i] = entry;
221 ++table->entry_count;
223 if (3 * table->chain_count < 5 * table->entry_count)
224 binding_table_expand (table);
227 /* Return the binding_entry, if any, that maps NAME. */
230 binding_table_find (binding_table table, tree name)
232 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
233 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
235 while (entry != NULL && entry->name != name)
236 entry = entry->chain;
241 /* Apply PROC -- with DATA -- to all entries in TABLE. */
244 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
246 const size_t chain_count = table->chain_count;
249 for (i = 0; i < chain_count; ++i)
251 binding_entry entry = table->chain[i];
252 for (; entry != NULL; entry = entry->chain)
257 #ifndef ENABLE_SCOPE_CHECKING
258 # define ENABLE_SCOPE_CHECKING 0
260 # define ENABLE_SCOPE_CHECKING 1
263 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
265 static GTY((deletable)) cxx_binding *free_bindings;
267 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
271 cxx_binding_init (cxx_binding *binding, tree value, tree type)
273 binding->value = value;
274 binding->type = type;
275 binding->previous = NULL;
278 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
281 cxx_binding_make (tree value, tree type)
283 cxx_binding *binding;
286 binding = free_bindings;
287 free_bindings = binding->previous;
290 binding = GGC_NEW (cxx_binding);
292 cxx_binding_init (binding, value, type);
297 /* Put BINDING back on the free list. */
300 cxx_binding_free (cxx_binding *binding)
302 binding->scope = NULL;
303 binding->previous = free_bindings;
304 free_bindings = binding;
307 /* Create a new binding for NAME (with the indicated VALUE and TYPE
308 bindings) in the class scope indicated by SCOPE. */
311 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
313 cp_class_binding *cb;
314 cxx_binding *binding;
316 if (VEC_length (cp_class_binding, scope->class_shadowed))
318 cp_class_binding *old_base;
319 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
320 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
322 /* Fixup the current bindings, as they might have moved. */
326 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
330 b = &IDENTIFIER_BINDING (cb->identifier);
331 while (*b != &old_base[i].base)
332 b = &((*b)->previous);
336 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
339 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
341 cb->identifier = name;
343 binding->scope = scope;
344 cxx_binding_init (binding, value, type);
348 /* Make DECL the innermost binding for ID. The LEVEL is the binding
349 level at which this declaration is being bound. */
352 push_binding (tree id, tree decl, cxx_scope* level)
354 cxx_binding *binding;
356 if (level != class_binding_level)
358 binding = cxx_binding_make (decl, NULL_TREE);
359 binding->scope = level;
362 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
364 /* Now, fill in the binding information. */
365 binding->previous = IDENTIFIER_BINDING (id);
366 INHERITED_VALUE_BINDING_P (binding) = 0;
367 LOCAL_BINDING_P (binding) = (level != class_binding_level);
369 /* And put it on the front of the list of bindings for ID. */
370 IDENTIFIER_BINDING (id) = binding;
373 /* Remove the binding for DECL which should be the innermost binding
377 pop_binding (tree id, tree decl)
379 cxx_binding *binding;
382 /* It's easiest to write the loops that call this function without
383 checking whether or not the entities involved have names. We
384 get here for such an entity. */
387 /* Get the innermost binding for ID. */
388 binding = IDENTIFIER_BINDING (id);
390 /* The name should be bound. */
391 gcc_assert (binding != NULL);
393 /* The DECL will be either the ordinary binding or the type
394 binding for this identifier. Remove that binding. */
395 if (binding->value == decl)
396 binding->value = NULL_TREE;
399 gcc_assert (binding->type == decl);
400 binding->type = NULL_TREE;
403 if (!binding->value && !binding->type)
405 /* We're completely done with the innermost binding for this
406 identifier. Unhook it from the list of bindings. */
407 IDENTIFIER_BINDING (id) = binding->previous;
409 /* Add it to the free list. */
410 cxx_binding_free (binding);
414 /* BINDING records an existing declaration for a name in the current scope.
415 But, DECL is another declaration for that same identifier in the
416 same scope. This is the `struct stat' hack whereby a non-typedef
417 class name or enum-name can be bound at the same level as some other
421 A class name (9.1) or enumeration name (7.2) can be hidden by the
422 name of an object, function, or enumerator declared in the same scope.
423 If a class or enumeration name and an object, function, or enumerator
424 are declared in the same scope (in any order) with the same name, the
425 class or enumeration name is hidden wherever the object, function, or
426 enumerator name is visible.
428 It's the responsibility of the caller to check that
429 inserting this name is valid here. Returns nonzero if the new binding
433 supplement_binding (cxx_binding *binding, tree decl)
435 tree bval = binding->value;
438 timevar_push (TV_NAME_LOOKUP);
439 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
440 /* The new name is the type name. */
441 binding->type = decl;
442 else if (/* BVAL is null when push_class_level_binding moves an
443 inherited type-binding out of the way to make room for a
444 new value binding. */
446 /* BVAL is error_mark_node when DECL's name has been used
447 in a non-class scope prior declaration. In that case,
448 we should have already issued a diagnostic; for graceful
449 error recovery purpose, pretend this was the intended
450 declaration for that name. */
451 || bval == error_mark_node
452 /* If BVAL is anticipated but has not yet been declared,
453 pretend it is not there at all. */
454 || (TREE_CODE (bval) == FUNCTION_DECL
455 && DECL_ANTICIPATED (bval)
456 && !DECL_HIDDEN_FRIEND_P (bval)))
457 binding->value = decl;
458 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
460 /* The old binding was a type name. It was placed in
461 VALUE field because it was thought, at the point it was
462 declared, to be the only entity with such a name. Move the
463 type name into the type slot; it is now hidden by the new
465 binding->type = bval;
466 binding->value = decl;
467 binding->value_is_inherited = false;
469 else if (TREE_CODE (bval) == TYPE_DECL
470 && TREE_CODE (decl) == TYPE_DECL
471 && DECL_NAME (decl) == DECL_NAME (bval)
472 && binding->scope->kind != sk_class
473 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
474 /* If either type involves template parameters, we must
475 wait until instantiation. */
476 || uses_template_parms (TREE_TYPE (decl))
477 || uses_template_parms (TREE_TYPE (bval))))
478 /* We have two typedef-names, both naming the same type to have
479 the same name. In general, this is OK because of:
483 In a given scope, a typedef specifier can be used to redefine
484 the name of any type declared in that scope to refer to the
485 type to which it already refers.
487 However, in class scopes, this rule does not apply due to the
488 stricter language in [class.mem] prohibiting redeclarations of
491 /* There can be two block-scope declarations of the same variable,
492 so long as they are `extern' declarations. However, there cannot
493 be two declarations of the same static data member:
497 A member shall not be declared twice in the
498 member-specification. */
499 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
500 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
501 && !DECL_CLASS_SCOPE_P (decl))
503 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
506 else if (TREE_CODE (decl) == NAMESPACE_DECL
507 && TREE_CODE (bval) == NAMESPACE_DECL
508 && DECL_NAMESPACE_ALIAS (decl)
509 && DECL_NAMESPACE_ALIAS (bval)
510 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
513 In a declarative region, a namespace-alias-definition can be
514 used to redefine a namespace-alias declared in that declarative
515 region to refer only to the namespace to which it already
520 error ("declaration of %q#D", decl);
521 error ("conflicts with previous declaration %q+#D", bval);
525 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
528 /* Add DECL to the list of things declared in B. */
531 add_decl_to_level (tree decl, cxx_scope *b)
533 /* We used to record virtual tables as if they were ordinary
534 variables, but no longer do so. */
535 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
537 if (TREE_CODE (decl) == NAMESPACE_DECL
538 && !DECL_NAMESPACE_ALIAS (decl))
540 TREE_CHAIN (decl) = b->namespaces;
541 b->namespaces = decl;
545 /* We build up the list in reverse order, and reverse it later if
547 TREE_CHAIN (decl) = b->names;
551 /* If appropriate, add decl to separate list of statics. We
552 include extern variables because they might turn out to be
553 static later. It's OK for this list to contain a few false
555 if (b->kind == sk_namespace)
556 if ((TREE_CODE (decl) == VAR_DECL
557 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
558 || (TREE_CODE (decl) == FUNCTION_DECL
559 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
560 VEC_safe_push (tree, gc, b->static_decls, decl);
564 /* Record a decl-node X as belonging to the current lexical scope.
565 Check for errors (such as an incompatible declaration for the same
566 name already seen in the same scope). IS_FRIEND is true if X is
567 declared as a friend.
569 Returns either X or an old decl for the same name.
570 If an old decl is returned, it may have been smashed
571 to agree with what X says. */
574 pushdecl_maybe_friend (tree x, bool is_friend)
578 int need_new_binding;
580 timevar_push (TV_NAME_LOOKUP);
582 if (x == error_mark_node)
583 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
585 need_new_binding = 1;
587 if (DECL_TEMPLATE_PARM_P (x))
588 /* Template parameters have no context; they are not X::T even
589 when declared within a class or namespace. */
593 if (current_function_decl && x != current_function_decl
594 /* A local declaration for a function doesn't constitute
596 && TREE_CODE (x) != FUNCTION_DECL
597 /* A local declaration for an `extern' variable is in the
598 scope of the current namespace, not the current
600 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
601 /* When parsing the parameter list of a function declarator,
602 don't set DECL_CONTEXT to an enclosing function. When we
603 push the PARM_DECLs in order to process the function body,
604 current_binding_level->this_entity will be set. */
605 && !(TREE_CODE (x) == PARM_DECL
606 && current_binding_level->kind == sk_function_parms
607 && current_binding_level->this_entity == NULL)
608 && !DECL_CONTEXT (x))
609 DECL_CONTEXT (x) = current_function_decl;
611 /* If this is the declaration for a namespace-scope function,
612 but the declaration itself is in a local scope, mark the
614 if (TREE_CODE (x) == FUNCTION_DECL
615 && DECL_NAMESPACE_SCOPE_P (x)
616 && current_function_decl
617 && x != current_function_decl)
618 DECL_LOCAL_FUNCTION_P (x) = 1;
621 name = DECL_NAME (x);
624 int different_binding_level = 0;
626 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
627 name = TREE_OPERAND (name, 0);
629 /* In case this decl was explicitly namespace-qualified, look it
630 up in its namespace context. */
631 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
632 t = namespace_binding (name, DECL_CONTEXT (x));
634 t = lookup_name_innermost_nonclass_level (name);
636 /* [basic.link] If there is a visible declaration of an entity
637 with linkage having the same name and type, ignoring entities
638 declared outside the innermost enclosing namespace scope, the
639 block scope declaration declares that same entity and
640 receives the linkage of the previous declaration. */
641 if (! t && current_function_decl && x != current_function_decl
642 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
643 && DECL_EXTERNAL (x))
645 /* Look in block scope. */
646 t = innermost_non_namespace_value (name);
647 /* Or in the innermost namespace. */
649 t = namespace_binding (name, DECL_CONTEXT (x));
650 /* Does it have linkage? Note that if this isn't a DECL, it's an
651 OVERLOAD, which is OK. */
652 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
655 different_binding_level = 1;
658 /* If we are declaring a function, and the result of name-lookup
659 was an OVERLOAD, look for an overloaded instance that is
660 actually the same as the function we are declaring. (If
661 there is one, we have to merge our declaration with the
662 previous declaration.) */
663 if (t && TREE_CODE (t) == OVERLOAD)
667 if (TREE_CODE (x) == FUNCTION_DECL)
668 for (match = t; match; match = OVL_NEXT (match))
670 if (decls_match (OVL_CURRENT (match), x))
674 /* Just choose one. */
678 t = OVL_CURRENT (match);
683 if (t && t != error_mark_node)
685 if (different_binding_level)
687 if (decls_match (x, t))
688 /* The standard only says that the local extern
689 inherits linkage from the previous decl; in
690 particular, default args are not shared. Add
691 the decl into a hash table to make sure only
692 the previous decl in this case is seen by the
695 struct cxx_int_tree_map *h;
698 TREE_PUBLIC (x) = TREE_PUBLIC (t);
700 if (cp_function_chain->extern_decl_map == NULL)
701 cp_function_chain->extern_decl_map
702 = htab_create_ggc (20, cxx_int_tree_map_hash,
703 cxx_int_tree_map_eq, NULL);
705 h = GGC_NEW (struct cxx_int_tree_map);
706 h->uid = DECL_UID (x);
708 loc = htab_find_slot_with_hash
709 (cp_function_chain->extern_decl_map, h,
711 *(struct cxx_int_tree_map **) loc = h;
714 else if (TREE_CODE (t) == PARM_DECL)
716 /* Check for duplicate params. */
717 tree d = duplicate_decls (x, t, is_friend);
719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
721 else if ((DECL_EXTERN_C_FUNCTION_P (x)
722 || DECL_FUNCTION_TEMPLATE_P (x))
723 && is_overloaded_fn (t))
724 /* Don't do anything just yet. */;
725 else if (t == wchar_decl_node)
727 if (! DECL_IN_SYSTEM_HEADER (x))
728 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
731 /* Throw away the redeclaration. */
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
736 tree olddecl = duplicate_decls (x, t, is_friend);
738 /* If the redeclaration failed, we can stop at this
740 if (olddecl == error_mark_node)
741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
745 if (TREE_CODE (t) == TYPE_DECL)
746 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
750 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
752 /* A redeclaration of main, but not a duplicate of the
757 This function shall not be overloaded. */
758 error ("invalid redeclaration of %q+D", t);
760 /* We don't try to push this declaration since that
762 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
767 /* If x has C linkage-specification, (extern "C"),
768 lookup its binding, in case it's already bound to an object.
769 The lookup is done in all namespaces.
770 If we find an existing binding, make sure it has the same
771 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
772 if ((TREE_CODE (x) == FUNCTION_DECL)
773 && DECL_EXTERN_C_P (x)
774 /* We should ignore declarations happening in system headers. */
775 && !DECL_ARTIFICIAL (x)
776 && !DECL_IN_SYSTEM_HEADER (x))
778 cxx_binding *function_binding =
779 lookup_extern_c_fun_binding_in_all_ns (x);
780 tree previous = (function_binding
781 ? function_binding->value
784 && !DECL_ARTIFICIAL (previous)
785 && !DECL_IN_SYSTEM_HEADER (previous)
786 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
788 tree previous = function_binding->value;
790 /* In case either x or previous is declared to throw an exception,
791 make sure both exception specifications are equal. */
792 if (decls_match (x, previous))
794 tree x_exception_spec = NULL_TREE;
795 tree previous_exception_spec = NULL_TREE;
798 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
799 previous_exception_spec =
800 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
801 if (!comp_except_specs (previous_exception_spec,
805 pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
807 pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
809 pedwarn (input_location, 0, "due to different exception specifications");
810 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
815 pedwarn (input_location, 0,
816 "declaration of %q#D with C language linkage", x);
817 pedwarn (input_location, 0,
818 "conflicts with previous declaration %q+#D",
824 check_template_shadow (x);
826 /* If this is a function conjured up by the back end, massage it
827 so it looks friendly. */
828 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
830 retrofit_lang_decl (x);
831 SET_DECL_LANGUAGE (x, lang_c);
835 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
837 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
838 if (!namespace_bindings_p ())
839 /* We do not need to create a binding for this name;
840 push_overloaded_decl will have already done so if
842 need_new_binding = 0;
844 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
846 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
848 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
851 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
852 check_default_args (x);
854 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
857 /* If declaring a type as a typedef, copy the type (unless we're
858 at line 0), and install this TYPE_DECL as the new type's typedef
859 name. See the extensive comment of set_underlying_type (). */
860 if (TREE_CODE (x) == TYPE_DECL)
862 tree type = TREE_TYPE (x);
864 if (DECL_IS_BUILTIN (x)
865 || (TREE_TYPE (x) != error_mark_node
866 && TYPE_NAME (type) != x
867 /* We don't want to copy the type when all we're
868 doing is making a TYPE_DECL for the purposes of
870 && (!TYPE_NAME (type)
871 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
872 set_underlying_type (x);
874 if (type != error_mark_node
876 && TYPE_IDENTIFIER (type))
877 set_identifier_type_value (DECL_NAME (x), x);
880 /* Multiple external decls of the same identifier ought to match.
882 We get warnings about inline functions where they are defined.
883 We get warnings about other functions from push_overloaded_decl.
885 Avoid duplicate warnings where they are used. */
886 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
890 decl = IDENTIFIER_NAMESPACE_VALUE (name);
891 if (decl && TREE_CODE (decl) == OVERLOAD)
892 decl = OVL_FUNCTION (decl);
894 if (decl && decl != error_mark_node
895 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
896 /* If different sort of thing, we already gave an error. */
897 && TREE_CODE (decl) == TREE_CODE (x)
898 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
900 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
901 permerror (input_location, "previous external decl of %q+#D", decl);
905 if (TREE_CODE (x) == FUNCTION_DECL
907 && !flag_friend_injection)
909 /* This is a new declaration of a friend function, so hide
910 it from ordinary function lookup. */
911 DECL_ANTICIPATED (x) = 1;
912 DECL_HIDDEN_FRIEND_P (x) = 1;
915 /* This name is new in its binding level.
916 Install the new declaration and return it. */
917 if (namespace_bindings_p ())
919 /* Install a global value. */
921 /* If the first global decl has external linkage,
922 warn if we later see static one. */
923 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
924 TREE_PUBLIC (name) = 1;
926 /* Bind the name for the entity. */
927 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
929 && (TREE_CODE (x) == TYPE_DECL
930 || TREE_CODE (x) == VAR_DECL
931 || TREE_CODE (x) == NAMESPACE_DECL
932 || TREE_CODE (x) == CONST_DECL
933 || TREE_CODE (x) == TEMPLATE_DECL))
934 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
936 /* If new decl is `static' and an `extern' was seen previously,
938 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
939 warn_extern_redeclared_static (x, t);
943 /* Here to install a non-global value. */
944 tree oldlocal = innermost_non_namespace_value (name);
945 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
947 if (need_new_binding)
949 push_local_binding (name, x, 0);
950 /* Because push_local_binding will hook X on to the
951 current_binding_level's name list, we don't want to
952 do that again below. */
953 need_new_binding = 0;
956 /* If this is a TYPE_DECL, push it into the type value slot. */
957 if (TREE_CODE (x) == TYPE_DECL)
958 set_identifier_type_value (name, x);
960 /* Clear out any TYPE_DECL shadowed by a namespace so that
961 we won't think this is a type. The C struct hack doesn't
962 go through namespaces. */
963 if (TREE_CODE (x) == NAMESPACE_DECL)
964 set_identifier_type_value (name, NULL_TREE);
971 && TREE_CODE (oldlocal) == VAR_DECL
972 && DECL_DEAD_FOR_LOCAL (oldlocal))
973 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
975 if (oldlocal == NULL_TREE)
976 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
979 /* If this is an extern function declaration, see if we
980 have a global definition or declaration for the function. */
981 if (oldlocal == NULL_TREE
983 && oldglobal != NULL_TREE
984 && TREE_CODE (x) == FUNCTION_DECL
985 && TREE_CODE (oldglobal) == FUNCTION_DECL)
987 /* We have one. Their types must agree. */
988 if (decls_match (x, oldglobal))
992 warning (0, "extern declaration of %q#D doesn't match", x);
993 warning (0, "global declaration %q+#D", oldglobal);
996 /* If we have a local external declaration,
997 and no file-scope declaration has yet been seen,
998 then if we later have a file-scope decl it must not be static. */
999 if (oldlocal == NULL_TREE
1000 && oldglobal == NULL_TREE
1001 && DECL_EXTERNAL (x)
1003 TREE_PUBLIC (name) = 1;
1005 /* Don't complain about the parms we push and then pop
1006 while tentatively parsing a function declarator. */
1007 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1010 /* Warn if shadowing an argument at the top level of the body. */
1011 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1012 /* Inline decls shadow nothing. */
1013 && !DECL_FROM_INLINE (x)
1014 && TREE_CODE (oldlocal) == PARM_DECL
1015 /* Don't check the `this' parameter. */
1016 && !DECL_ARTIFICIAL (oldlocal))
1020 /* Don't complain if it's from an enclosing function. */
1021 if (DECL_CONTEXT (oldlocal) == current_function_decl
1022 && TREE_CODE (x) != PARM_DECL)
1024 /* Go to where the parms should be and see if we find
1026 struct cp_binding_level *b = current_binding_level->level_chain;
1028 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1029 /* Skip the ctor/dtor cleanup level. */
1033 if (b->kind == sk_function_parms)
1035 error ("declaration of %q#D shadows a parameter", x);
1040 if (warn_shadow && !err)
1042 warning_at (input_location, OPT_Wshadow,
1043 "declaration of %q#D shadows a parameter", x);
1044 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1045 "shadowed declaration is here");
1049 /* Maybe warn if shadowing something else. */
1050 else if (warn_shadow && !DECL_EXTERNAL (x)
1051 /* No shadow warnings for internally generated vars. */
1052 && ! DECL_ARTIFICIAL (x)
1053 /* No shadow warnings for vars made for inlining. */
1054 && ! DECL_FROM_INLINE (x))
1058 if (current_class_ptr)
1059 member = lookup_member (current_class_type,
1062 /*want_type=*/false);
1066 if (member && !TREE_STATIC (member))
1068 /* Location of previous decl is not useful in this case. */
1069 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1072 else if (oldlocal != NULL_TREE
1073 && TREE_CODE (oldlocal) == VAR_DECL)
1075 warning_at (input_location, OPT_Wshadow,
1076 "declaration of %qD shadows a previous local", x);
1077 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1078 "shadowed declaration is here");
1080 else if (oldglobal != NULL_TREE
1081 && TREE_CODE (oldglobal) == VAR_DECL)
1082 /* XXX shadow warnings in outer-more namespaces */
1084 warning_at (input_location, OPT_Wshadow,
1085 "declaration of %qD shadows a global declaration", x);
1086 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1087 "shadowed declaration is here");
1092 if (TREE_CODE (x) == VAR_DECL)
1093 maybe_register_incomplete_var (x);
1096 if (need_new_binding)
1097 add_decl_to_level (x,
1098 DECL_NAMESPACE_SCOPE_P (x)
1099 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1100 : current_binding_level);
1102 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1105 /* Record a decl-node X as belonging to the current lexical scope. */
1110 return pushdecl_maybe_friend (x, false);
1113 /* Enter DECL into the symbol table, if that's appropriate. Returns
1114 DECL, or a modified version thereof. */
1117 maybe_push_decl (tree decl)
1119 tree type = TREE_TYPE (decl);
1121 /* Add this decl to the current binding level, but not if it comes
1122 from another scope, e.g. a static member variable. TEM may equal
1123 DECL or it may be a previous decl of the same name. */
1124 if (decl == error_mark_node
1125 || (TREE_CODE (decl) != PARM_DECL
1126 && DECL_CONTEXT (decl) != NULL_TREE
1127 /* Definitions of namespace members outside their namespace are
1129 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1130 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1131 || TREE_CODE (type) == UNKNOWN_TYPE
1132 /* The declaration of a template specialization does not affect
1133 the functions available for overload resolution, so we do not
1135 || (TREE_CODE (decl) == FUNCTION_DECL
1136 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1139 return pushdecl (decl);
1142 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1143 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1144 doesn't really belong to this binding level, that it got here
1145 through a using-declaration. */
1148 push_local_binding (tree id, tree decl, int flags)
1150 struct cp_binding_level *b;
1152 /* Skip over any local classes. This makes sense if we call
1153 push_local_binding with a friend decl of a local class. */
1154 b = innermost_nonclass_level ();
1156 if (lookup_name_innermost_nonclass_level (id))
1158 /* Supplement the existing binding. */
1159 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1160 /* It didn't work. Something else must be bound at this
1161 level. Do not add DECL to the list of things to pop
1166 /* Create a new binding. */
1167 push_binding (id, decl, b);
1169 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1170 /* We must put the OVERLOAD into a TREE_LIST since the
1171 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1172 decls that got here through a using-declaration. */
1173 decl = build_tree_list (NULL_TREE, decl);
1175 /* And put DECL on the list of things declared by the current
1177 add_decl_to_level (decl, b);
1180 /* Check to see whether or not DECL is a variable that would have been
1181 in scope under the ARM, but is not in scope under the ANSI/ISO
1182 standard. If so, issue an error message. If name lookup would
1183 work in both cases, but return a different result, this function
1184 returns the result of ANSI/ISO lookup. Otherwise, it returns
1188 check_for_out_of_scope_variable (tree decl)
1192 /* We only care about out of scope variables. */
1193 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1196 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1197 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1198 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1199 && DECL_DEAD_FOR_LOCAL (shadowed))
1200 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1201 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1203 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1206 if (!DECL_ERROR_REPORTED (decl))
1208 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1209 warning (0, " matches this %q+D under ISO standard rules",
1211 warning (0, " matches this %q+D under old rules", decl);
1212 DECL_ERROR_REPORTED (decl) = 1;
1217 /* If we have already complained about this declaration, there's no
1218 need to do it again. */
1219 if (DECL_ERROR_REPORTED (decl))
1222 DECL_ERROR_REPORTED (decl) = 1;
1224 if (TREE_TYPE (decl) == error_mark_node)
1227 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1229 error ("name lookup of %qD changed for ISO %<for%> scoping",
1231 error (" cannot use obsolete binding at %q+D because "
1232 "it has a destructor", decl);
1233 return error_mark_node;
1237 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1239 if (flag_permissive)
1240 permerror (input_location, " using obsolete binding at %q+D", decl);
1246 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1255 /* true means unconditionally make a BLOCK for the next level pushed. */
1257 static bool keep_next_level_flag;
1259 static int binding_depth = 0;
1266 for (i = 0; i < depth * 2; i++)
1270 /* Return a string describing the kind of SCOPE we have. */
1272 cxx_scope_descriptor (cxx_scope *scope)
1274 /* The order of this table must match the "scope_kind"
1276 static const char* scope_kind_names[] = {
1282 "function-parameter-scope",
1285 "template-parameter-scope",
1286 "template-explicit-spec-scope"
1288 const scope_kind kind = scope->explicit_spec_p
1289 ? sk_template_spec : scope->kind;
1291 return scope_kind_names[kind];
1294 /* Output a debugging information about SCOPE when performing
1297 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1299 const char *desc = cxx_scope_descriptor (scope);
1300 if (scope->this_entity)
1301 verbatim ("%s %s(%E) %p %d\n", action, desc,
1302 scope->this_entity, (void *) scope, line);
1304 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1307 /* Return the estimated initial size of the hashtable of a NAMESPACE
1310 static inline size_t
1311 namespace_scope_ht_size (tree ns)
1313 tree name = DECL_NAME (ns);
1315 return name == std_identifier
1316 ? NAMESPACE_STD_HT_SIZE
1317 : (name == global_scope_name
1318 ? GLOBAL_SCOPE_HT_SIZE
1319 : NAMESPACE_ORDINARY_HT_SIZE);
1322 /* A chain of binding_level structures awaiting reuse. */
1324 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1326 /* Insert SCOPE as the innermost binding level. */
1329 push_binding_level (struct cp_binding_level *scope)
1331 /* Add it to the front of currently active scopes stack. */
1332 scope->level_chain = current_binding_level;
1333 current_binding_level = scope;
1334 keep_next_level_flag = false;
1336 if (ENABLE_SCOPE_CHECKING)
1338 scope->binding_depth = binding_depth;
1339 indent (binding_depth);
1340 cxx_scope_debug (scope, input_line, "push");
1345 /* Create a new KIND scope and make it the top of the active scopes stack.
1346 ENTITY is the scope of the associated C++ entity (namespace, class,
1347 function, C++0x enumeration); it is NULL otherwise. */
1350 begin_scope (scope_kind kind, tree entity)
1354 /* Reuse or create a struct for this binding level. */
1355 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1357 scope = free_binding_level;
1358 memset (scope, 0, sizeof (cxx_scope));
1359 free_binding_level = scope->level_chain;
1362 scope = GGC_CNEW (cxx_scope);
1364 scope->this_entity = entity;
1365 scope->more_cleanups_ok = true;
1372 case sk_template_spec:
1373 scope->explicit_spec_p = true;
1374 kind = sk_template_parms;
1376 case sk_template_parms:
1382 case sk_scoped_enum:
1383 case sk_function_parms:
1385 scope->keep = keep_next_level_flag;
1389 NAMESPACE_LEVEL (entity) = scope;
1390 scope->static_decls =
1391 VEC_alloc (tree, gc,
1392 DECL_NAME (entity) == std_identifier
1393 || DECL_NAME (entity) == global_scope_name
1398 /* Should not happen. */
1404 push_binding_level (scope);
1409 /* We're about to leave current scope. Pop the top of the stack of
1410 currently active scopes. Return the enclosing scope, now active. */
1415 cxx_scope *scope = current_binding_level;
1417 if (scope->kind == sk_namespace && class_binding_level)
1418 current_binding_level = class_binding_level;
1420 /* We cannot leave a scope, if there are none left. */
1421 if (NAMESPACE_LEVEL (global_namespace))
1422 gcc_assert (!global_scope_p (scope));
1424 if (ENABLE_SCOPE_CHECKING)
1426 indent (--binding_depth);
1427 cxx_scope_debug (scope, input_line, "leave");
1430 /* Move one nesting level up. */
1431 current_binding_level = scope->level_chain;
1433 /* Namespace-scopes are left most probably temporarily, not
1434 completely; they can be reopened later, e.g. in namespace-extension
1435 or any name binding activity that requires us to resume a
1436 namespace. For classes, we cache some binding levels. For other
1437 scopes, we just make the structure available for reuse. */
1438 if (scope->kind != sk_namespace
1439 && scope->kind != sk_class)
1441 scope->level_chain = free_binding_level;
1442 gcc_assert (!ENABLE_SCOPE_CHECKING
1443 || scope->binding_depth == binding_depth);
1444 free_binding_level = scope;
1447 /* Find the innermost enclosing class scope, and reset
1448 CLASS_BINDING_LEVEL appropriately. */
1449 if (scope->kind == sk_class)
1451 class_binding_level = NULL;
1452 for (scope = current_binding_level; scope; scope = scope->level_chain)
1453 if (scope->kind == sk_class)
1455 class_binding_level = scope;
1460 return current_binding_level;
1464 resume_scope (struct cp_binding_level* b)
1466 /* Resuming binding levels is meant only for namespaces,
1467 and those cannot nest into classes. */
1468 gcc_assert (!class_binding_level);
1469 /* Also, resuming a non-directly nested namespace is a no-no. */
1470 gcc_assert (b->level_chain == current_binding_level);
1471 current_binding_level = b;
1472 if (ENABLE_SCOPE_CHECKING)
1474 b->binding_depth = binding_depth;
1475 indent (binding_depth);
1476 cxx_scope_debug (b, input_line, "resume");
1481 /* Return the innermost binding level that is not for a class scope. */
1484 innermost_nonclass_level (void)
1488 b = current_binding_level;
1489 while (b->kind == sk_class)
1495 /* We're defining an object of type TYPE. If it needs a cleanup, but
1496 we're not allowed to add any more objects with cleanups to the current
1497 scope, create a new binding level. */
1500 maybe_push_cleanup_level (tree type)
1502 if (type != error_mark_node
1503 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1504 && current_binding_level->more_cleanups_ok == 0)
1506 begin_scope (sk_cleanup, NULL);
1507 current_binding_level->statement_list = push_stmt_list ();
1511 /* Nonzero if we are currently in the global binding level. */
1514 global_bindings_p (void)
1516 return global_scope_p (current_binding_level);
1519 /* True if we are currently in a toplevel binding level. This
1520 means either the global binding level or a namespace in a toplevel
1521 binding level. Since there are no non-toplevel namespace levels,
1522 this really means any namespace or template parameter level. We
1523 also include a class whose context is toplevel. */
1526 toplevel_bindings_p (void)
1528 struct cp_binding_level *b = innermost_nonclass_level ();
1530 return b->kind == sk_namespace || b->kind == sk_template_parms;
1533 /* True if this is a namespace scope, or if we are defining a class
1534 which is itself at namespace scope, or whose enclosing class is
1535 such a class, etc. */
1538 namespace_bindings_p (void)
1540 struct cp_binding_level *b = innermost_nonclass_level ();
1542 return b->kind == sk_namespace;
1545 /* True if the current level needs to have a BLOCK made. */
1550 return (current_binding_level->blocks != NULL_TREE
1551 || current_binding_level->keep
1552 || current_binding_level->kind == sk_cleanup
1553 || current_binding_level->names != NULL_TREE
1554 || current_binding_level->using_directives);
1557 /* Returns the kind of the innermost scope. */
1560 innermost_scope_kind (void)
1562 return current_binding_level->kind;
1565 /* Returns true if this scope was created to store template parameters. */
1568 template_parm_scope_p (void)
1570 return innermost_scope_kind () == sk_template_parms;
1573 /* If KEEP is true, make a BLOCK node for the next binding level,
1574 unconditionally. Otherwise, use the normal logic to decide whether
1575 or not to create a BLOCK. */
1578 keep_next_level (bool keep)
1580 keep_next_level_flag = keep;
1583 /* Return the list of declarations of the current level.
1584 Note that this list is in reverse order unless/until
1585 you nreverse it; and when you do nreverse it, you must
1586 store the result back using `storedecls' or you will lose. */
1591 return current_binding_level->names;
1594 /* For debugging. */
1595 static int no_print_functions = 0;
1596 static int no_print_builtins = 0;
1599 print_binding_level (struct cp_binding_level* lvl)
1603 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1604 if (lvl->more_cleanups_ok)
1605 fprintf (stderr, " more-cleanups-ok");
1606 if (lvl->have_cleanups)
1607 fprintf (stderr, " have-cleanups");
1608 fprintf (stderr, "\n");
1611 fprintf (stderr, " names:\t");
1612 /* We can probably fit 3 names to a line? */
1613 for (t = lvl->names; t; t = TREE_CHAIN (t))
1615 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1617 if (no_print_builtins
1618 && (TREE_CODE (t) == TYPE_DECL)
1619 && DECL_IS_BUILTIN (t))
1622 /* Function decls tend to have longer names. */
1623 if (TREE_CODE (t) == FUNCTION_DECL)
1630 fprintf (stderr, "\n\t");
1633 print_node_brief (stderr, "", t, 0);
1634 if (t == error_mark_node)
1638 fprintf (stderr, "\n");
1640 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1643 cp_class_binding *b;
1644 fprintf (stderr, " class-shadowed:");
1646 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1648 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1649 fprintf (stderr, "\n");
1651 if (lvl->type_shadowed)
1653 fprintf (stderr, " type-shadowed:");
1654 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1656 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1658 fprintf (stderr, "\n");
1663 print_other_binding_stack (struct cp_binding_level *stack)
1665 struct cp_binding_level *level;
1666 for (level = stack; !global_scope_p (level); level = level->level_chain)
1668 fprintf (stderr, "binding level %p\n", (void *) level);
1669 print_binding_level (level);
1674 print_binding_stack (void)
1676 struct cp_binding_level *b;
1677 fprintf (stderr, "current_binding_level=%p\n"
1678 "class_binding_level=%p\n"
1679 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1680 (void *) current_binding_level, (void *) class_binding_level,
1681 (void *) NAMESPACE_LEVEL (global_namespace));
1682 if (class_binding_level)
1684 for (b = class_binding_level; b; b = b->level_chain)
1685 if (b == current_binding_level)
1688 b = class_binding_level;
1690 b = current_binding_level;
1693 b = current_binding_level;
1694 print_other_binding_stack (b);
1695 fprintf (stderr, "global:\n");
1696 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1699 /* Return the type associated with id. */
1702 identifier_type_value (tree id)
1704 timevar_push (TV_NAME_LOOKUP);
1705 /* There is no type with that name, anywhere. */
1706 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1707 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1708 /* This is not the type marker, but the real thing. */
1709 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1710 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1711 /* Have to search for it. It must be on the global level, now.
1712 Ask lookup_name not to return non-types. */
1713 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1719 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1720 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1723 identifier_global_value (tree t)
1725 return IDENTIFIER_GLOBAL_VALUE (t);
1728 /* Push a definition of struct, union or enum tag named ID. into
1729 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1730 the tag ID is not already defined. */
1733 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1737 if (b->kind != sk_namespace)
1739 /* Shadow the marker, not the real thing, so that the marker
1740 gets restored later. */
1741 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1743 = tree_cons (id, old_type_value, b->type_shadowed);
1744 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1745 TREE_TYPE (b->type_shadowed) = type;
1749 cxx_binding *binding =
1750 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1753 supplement_binding (binding, decl);
1755 binding->value = decl;
1757 /* Store marker instead of real type. */
1758 type = global_type_node;
1760 SET_IDENTIFIER_TYPE_VALUE (id, type);
1763 /* As set_identifier_type_value_with_scope, but using
1764 current_binding_level. */
1767 set_identifier_type_value (tree id, tree decl)
1769 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1772 /* Return the name for the constructor (or destructor) for the
1773 specified class TYPE. When given a template, this routine doesn't
1774 lose the specialization. */
1777 constructor_name_full (tree type)
1779 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1782 /* Return the name for the constructor (or destructor) for the
1783 specified class. When given a template, return the plain
1784 unspecialized name. */
1787 constructor_name (tree type)
1790 name = constructor_name_full (type);
1791 if (IDENTIFIER_TEMPLATE (name))
1792 name = IDENTIFIER_TEMPLATE (name);
1796 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1797 which must be a class type. */
1800 constructor_name_p (tree name, tree type)
1804 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1809 if (TREE_CODE (name) != IDENTIFIER_NODE)
1812 ctor_name = constructor_name_full (type);
1813 if (name == ctor_name)
1815 if (IDENTIFIER_TEMPLATE (ctor_name)
1816 && name == IDENTIFIER_TEMPLATE (ctor_name))
1821 /* Counter used to create anonymous type names. */
1823 static GTY(()) int anon_cnt;
1825 /* Return an IDENTIFIER which can be used as a name for
1826 anonymous structs and unions. */
1829 make_anon_name (void)
1833 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1834 return get_identifier (buf);
1837 /* This code is practically identical to that for creating
1838 anonymous names, but is just used for lambdas instead. This is necessary
1839 because anonymous names are recognized and cannot be passed to template
1841 /* FIXME is this still necessary? */
1843 static GTY(()) int lambda_cnt = 0;
1846 make_lambda_name (void)
1850 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1851 return get_identifier (buf);
1854 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1856 static inline cxx_binding *
1857 find_binding (cxx_scope *scope, cxx_binding *binding)
1859 timevar_push (TV_NAME_LOOKUP);
1861 for (; binding != NULL; binding = binding->previous)
1862 if (binding->scope == scope)
1863 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1865 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1868 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1870 static inline cxx_binding *
1871 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1873 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1876 /* Fold-in case where NAME is used only once. */
1877 if (scope == b->scope && b->previous == NULL)
1879 return find_binding (scope, b);
1884 /* Always returns a binding for name in scope. If no binding is
1885 found, make a new one. */
1887 static cxx_binding *
1888 binding_for_name (cxx_scope *scope, tree name)
1890 cxx_binding *result;
1892 result = cxx_scope_find_binding_for_name (scope, name);
1895 /* Not found, make a new one. */
1896 result = cxx_binding_make (NULL, NULL);
1897 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1898 result->scope = scope;
1899 result->is_local = false;
1900 result->value_is_inherited = false;
1901 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1905 /* Walk through the bindings associated to the name of FUNCTION,
1906 and return the first binding that declares a function with a
1907 "C" linkage specification, a.k.a 'extern "C"'.
1908 This function looks for the binding, regardless of which scope it
1909 has been defined in. It basically looks in all the known scopes.
1910 Note that this function does not lookup for bindings of builtin functions
1911 or for functions declared in system headers. */
1913 lookup_extern_c_fun_binding_in_all_ns (tree function)
1918 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1920 name = DECL_NAME (function);
1921 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1923 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1925 iter = iter->previous)
1928 && TREE_CODE (iter->value) == FUNCTION_DECL
1929 && DECL_EXTERN_C_P (iter->value)
1930 && !DECL_ARTIFICIAL (iter->value))
1938 /* Insert another USING_DECL into the current binding level, returning
1939 this declaration. If this is a redeclaration, do nothing, and
1940 return NULL_TREE if this not in namespace scope (in namespace
1941 scope, a using decl might extend any previous bindings). */
1944 push_using_decl (tree scope, tree name)
1948 timevar_push (TV_NAME_LOOKUP);
1949 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1950 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1951 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1952 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1955 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1956 namespace_bindings_p () ? decl : NULL_TREE);
1957 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1958 USING_DECL_SCOPE (decl) = scope;
1959 TREE_CHAIN (decl) = current_binding_level->usings;
1960 current_binding_level->usings = decl;
1961 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1964 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1965 caller to set DECL_CONTEXT properly. */
1968 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1970 struct cp_binding_level *b;
1971 tree function_decl = current_function_decl;
1973 timevar_push (TV_NAME_LOOKUP);
1974 current_function_decl = NULL_TREE;
1975 if (level->kind == sk_class)
1977 b = class_binding_level;
1978 class_binding_level = level;
1979 pushdecl_class_level (x);
1980 class_binding_level = b;
1984 b = current_binding_level;
1985 current_binding_level = level;
1986 x = pushdecl_maybe_friend (x, is_friend);
1987 current_binding_level = b;
1989 current_function_decl = function_decl;
1990 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1993 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1994 other definitions already in place. We get around this by making
1995 the value of the identifier point to a list of all the things that
1996 want to be referenced by that name. It is then up to the users of
1997 that name to decide what to do with that list.
1999 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2000 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2002 FLAGS is a bitwise-or of the following values:
2003 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2005 PUSH_USING: DECL is being pushed as the result of a using
2008 IS_FRIEND is true if this is a friend declaration.
2010 The value returned may be a previous declaration if we guessed wrong
2011 about what language DECL should belong to (C or C++). Otherwise,
2012 it's always DECL (and never something that's not a _DECL). */
2015 push_overloaded_decl (tree decl, int flags, bool is_friend)
2017 tree name = DECL_NAME (decl);
2020 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2022 timevar_push (TV_NAME_LOOKUP);
2024 old = namespace_binding (name, DECL_CONTEXT (decl));
2026 old = lookup_name_innermost_nonclass_level (name);
2030 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2032 tree t = TREE_TYPE (old);
2033 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2034 && (! DECL_IN_SYSTEM_HEADER (decl)
2035 || ! DECL_IN_SYSTEM_HEADER (old)))
2036 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2039 else if (is_overloaded_fn (old))
2043 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2045 tree fn = OVL_CURRENT (tmp);
2048 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2049 && !(flags & PUSH_USING)
2050 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2051 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2052 && ! decls_match (fn, decl))
2053 error ("%q#D conflicts with previous using declaration %q#D",
2056 dup = duplicate_decls (decl, fn, is_friend);
2057 /* If DECL was a redeclaration of FN -- even an invalid
2058 one -- pass that information along to our caller. */
2059 if (dup == fn || dup == error_mark_node)
2060 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2063 /* We don't overload implicit built-ins. duplicate_decls()
2064 may fail to merge the decls if the new decl is e.g. a
2065 template function. */
2066 if (TREE_CODE (old) == FUNCTION_DECL
2067 && DECL_ANTICIPATED (old)
2068 && !DECL_HIDDEN_FRIEND_P (old))
2071 else if (old == error_mark_node)
2072 /* Ignore the undefined symbol marker. */
2076 error ("previous non-function declaration %q+#D", old);
2077 error ("conflicts with function declaration %q#D", decl);
2078 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2082 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2083 /* If it's a using declaration, we always need to build an OVERLOAD,
2084 because it's the only way to remember that the declaration comes
2085 from 'using', and have the lookup behave correctly. */
2086 || (flags & PUSH_USING))
2088 if (old && TREE_CODE (old) != OVERLOAD)
2089 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2091 new_binding = ovl_cons (decl, old);
2092 if (flags & PUSH_USING)
2093 OVL_USED (new_binding) = 1;
2096 /* NAME is not ambiguous. */
2100 set_namespace_binding (name, current_namespace, new_binding);
2103 /* We only create an OVERLOAD if there was a previous binding at
2104 this level, or if decl is a template. In the former case, we
2105 need to remove the old binding and replace it with the new
2106 binding. We must also run through the NAMES on the binding
2107 level where the name was bound to update the chain. */
2109 if (TREE_CODE (new_binding) == OVERLOAD && old)
2113 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2115 d = &TREE_CHAIN (*d))
2117 || (TREE_CODE (*d) == TREE_LIST
2118 && TREE_VALUE (*d) == old))
2120 if (TREE_CODE (*d) == TREE_LIST)
2121 /* Just replace the old binding with the new. */
2122 TREE_VALUE (*d) = new_binding;
2124 /* Build a TREE_LIST to wrap the OVERLOAD. */
2125 *d = tree_cons (NULL_TREE, new_binding,
2128 /* And update the cxx_binding node. */
2129 IDENTIFIER_BINDING (name)->value = new_binding;
2130 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2133 /* We should always find a previous binding in this case. */
2137 /* Install the new binding. */
2138 push_local_binding (name, new_binding, flags);
2141 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2144 /* Check a non-member using-declaration. Return the name and scope
2145 being used, and the USING_DECL, or NULL_TREE on failure. */
2148 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2150 /* [namespace.udecl]
2151 A using-declaration for a class member shall be a
2152 member-declaration. */
2155 error ("%qT is not a namespace", scope);
2158 else if (scope == error_mark_node)
2161 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2164 A using-declaration shall not name a template-id. */
2165 error ("a using-declaration cannot specify a template-id. "
2166 "Try %<using %D%>", name);
2170 if (TREE_CODE (decl) == NAMESPACE_DECL)
2172 error ("namespace %qD not allowed in using-declaration", decl);
2176 if (TREE_CODE (decl) == SCOPE_REF)
2178 /* It's a nested name with template parameter dependent scope.
2179 This can only be using-declaration for class member. */
2180 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2184 if (is_overloaded_fn (decl))
2185 decl = get_first_fn (decl);
2187 gcc_assert (DECL_P (decl));
2189 /* Make a USING_DECL. */
2190 return push_using_decl (scope, name);
2193 /* Process local and global using-declarations. */
2196 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2197 tree *newval, tree *newtype)
2199 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2201 *newval = *newtype = NULL_TREE;
2202 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2206 if (!decls.value && !decls.type)
2208 error ("%qD not declared", name);
2212 /* Shift the old and new bindings around so we're comparing class and
2213 enumeration names to each other. */
2214 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2220 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2222 decls.type = decls.value;
2223 decls.value = NULL_TREE;
2226 /* It is impossible to overload a built-in function; any explicit
2227 declaration eliminates the built-in declaration. So, if OLDVAL
2228 is a built-in, then we can just pretend it isn't there. */
2230 && TREE_CODE (oldval) == FUNCTION_DECL
2231 && DECL_ANTICIPATED (oldval)
2232 && !DECL_HIDDEN_FRIEND_P (oldval))
2237 /* Check for using functions. */
2238 if (is_overloaded_fn (decls.value))
2242 if (oldval && !is_overloaded_fn (oldval))
2244 error ("%qD is already declared in this scope", name);
2249 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2251 tree new_fn = OVL_CURRENT (tmp);
2253 /* [namespace.udecl]
2255 If a function declaration in namespace scope or block
2256 scope has the same name and the same parameter types as a
2257 function introduced by a using declaration the program is
2259 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2261 tree old_fn = OVL_CURRENT (tmp1);
2263 if (new_fn == old_fn)
2264 /* The function already exists in the current namespace. */
2266 else if (OVL_USED (tmp1))
2267 continue; /* this is a using decl */
2268 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2269 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2271 gcc_assert (!DECL_ANTICIPATED (old_fn)
2272 || DECL_HIDDEN_FRIEND_P (old_fn));
2274 /* There was already a non-using declaration in
2275 this scope with the same parameter types. If both
2276 are the same extern "C" functions, that's ok. */
2277 if (decls_match (new_fn, old_fn))
2281 error ("%qD is already declared in this scope", name);
2287 /* If we broke out of the loop, there's no reason to add
2288 this function to the using declarations for this
2293 /* If we are adding to an existing OVERLOAD, then we no
2294 longer know the type of the set of functions. */
2295 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2296 TREE_TYPE (*newval) = unknown_type_node;
2297 /* Add this new function to the set. */
2298 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2299 /* If there is only one function, then we use its type. (A
2300 using-declaration naming a single function can be used in
2301 contexts where overload resolution cannot be
2303 if (TREE_CODE (*newval) != OVERLOAD)
2305 *newval = ovl_cons (*newval, NULL_TREE);
2306 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2308 OVL_USED (*newval) = 1;
2313 *newval = decls.value;
2314 if (oldval && !decls_match (*newval, oldval))
2315 error ("%qD is already declared in this scope", name);
2321 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2323 error ("reference to %qD is ambiguous", name);
2324 print_candidates (decls.type);
2328 *newtype = decls.type;
2329 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2330 error ("%qD is already declared in this scope", name);
2333 /* If *newval is empty, shift any class or enumeration name down. */
2337 *newtype = NULL_TREE;
2341 /* Process a using-declaration at function scope. */
2344 do_local_using_decl (tree decl, tree scope, tree name)
2346 tree oldval, oldtype, newval, newtype;
2347 tree orig_decl = decl;
2349 decl = validate_nonmember_using_decl (decl, scope, name);
2350 if (decl == NULL_TREE)
2353 if (building_stmt_tree ()
2354 && at_function_scope_p ())
2355 add_decl_expr (decl);
2357 oldval = lookup_name_innermost_nonclass_level (name);
2358 oldtype = lookup_type_current_level (name);
2360 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2364 if (is_overloaded_fn (newval))
2368 /* We only need to push declarations for those functions
2369 that were not already bound in the current level.
2370 The old value might be NULL_TREE, it might be a single
2371 function, or an OVERLOAD. */
2372 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2373 term = OVL_FUNCTION (oldval);
2376 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2378 push_overloaded_decl (OVL_CURRENT (fn),
2379 PUSH_LOCAL | PUSH_USING,
2383 push_local_binding (name, newval, PUSH_USING);
2387 push_local_binding (name, newtype, PUSH_USING);
2388 set_identifier_type_value (name, newtype);
2391 /* Emit debug info. */
2392 if (!processing_template_decl)
2393 cp_emit_debug_info_for_using (orig_decl, current_scope());
2396 /* Returns true if ROOT (a namespace, class, or function) encloses
2397 CHILD. CHILD may be either a class type or a namespace. */
2400 is_ancestor (tree root, tree child)
2402 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2403 || TREE_CODE (root) == FUNCTION_DECL
2404 || CLASS_TYPE_P (root)));
2405 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2406 || CLASS_TYPE_P (child)));
2408 /* The global namespace encloses everything. */
2409 if (root == global_namespace)
2414 /* If we've run out of scopes, stop. */
2417 /* If we've reached the ROOT, it encloses CHILD. */
2420 /* Go out one level. */
2422 child = TYPE_NAME (child);
2423 child = DECL_CONTEXT (child);
2427 /* Enter the class or namespace scope indicated by T suitable for name
2428 lookup. T can be arbitrary scope, not necessary nested inside the
2429 current scope. Returns a non-null scope to pop iff pop_scope
2430 should be called later to exit this scope. */
2435 if (TREE_CODE (t) == NAMESPACE_DECL)
2436 push_decl_namespace (t);
2437 else if (CLASS_TYPE_P (t))
2439 if (!at_class_scope_p ()
2440 || !same_type_p (current_class_type, t))
2441 push_nested_class (t);
2443 /* T is the same as the current scope. There is therefore no
2444 need to re-enter the scope. Since we are not actually
2445 pushing a new scope, our caller should not call
2453 /* Leave scope pushed by push_scope. */
2458 if (TREE_CODE (t) == NAMESPACE_DECL)
2459 pop_decl_namespace ();
2460 else if CLASS_TYPE_P (t)
2461 pop_nested_class ();
2464 /* Subroutine of push_inner_scope. */
2467 push_inner_scope_r (tree outer, tree inner)
2472 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2475 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2477 push_inner_scope_r (outer, prev);
2478 if (TREE_CODE (inner) == NAMESPACE_DECL)
2480 struct cp_binding_level *save_template_parm = 0;
2481 /* Temporary take out template parameter scopes. They are saved
2482 in reversed order in save_template_parm. */
2483 while (current_binding_level->kind == sk_template_parms)
2485 struct cp_binding_level *b = current_binding_level;
2486 current_binding_level = b->level_chain;
2487 b->level_chain = save_template_parm;
2488 save_template_parm = b;
2491 resume_scope (NAMESPACE_LEVEL (inner));
2492 current_namespace = inner;
2494 /* Restore template parameter scopes. */
2495 while (save_template_parm)
2497 struct cp_binding_level *b = save_template_parm;
2498 save_template_parm = b->level_chain;
2499 b->level_chain = current_binding_level;
2500 current_binding_level = b;
2507 /* Enter the scope INNER from current scope. INNER must be a scope
2508 nested inside current scope. This works with both name lookup and
2509 pushing name into scope. In case a template parameter scope is present,
2510 namespace is pushed under the template parameter scope according to
2511 name lookup rule in 14.6.1/6.
2513 Return the former current scope suitable for pop_inner_scope. */
2516 push_inner_scope (tree inner)
2518 tree outer = current_scope ();
2520 outer = current_namespace;
2522 push_inner_scope_r (outer, inner);
2526 /* Exit the current scope INNER back to scope OUTER. */
2529 pop_inner_scope (tree outer, tree inner)
2532 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2535 while (outer != inner)
2537 if (TREE_CODE (inner) == NAMESPACE_DECL)
2539 struct cp_binding_level *save_template_parm = 0;
2540 /* Temporary take out template parameter scopes. They are saved
2541 in reversed order in save_template_parm. */
2542 while (current_binding_level->kind == sk_template_parms)
2544 struct cp_binding_level *b = current_binding_level;
2545 current_binding_level = b->level_chain;
2546 b->level_chain = save_template_parm;
2547 save_template_parm = b;
2552 /* Restore template parameter scopes. */
2553 while (save_template_parm)
2555 struct cp_binding_level *b = save_template_parm;
2556 save_template_parm = b->level_chain;
2557 b->level_chain = current_binding_level;
2558 current_binding_level = b;
2564 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2568 /* Do a pushlevel for class declarations. */
2571 pushlevel_class (void)
2573 class_binding_level = begin_scope (sk_class, current_class_type);
2576 /* ...and a poplevel for class declarations. */
2579 poplevel_class (void)
2581 struct cp_binding_level *level = class_binding_level;
2582 cp_class_binding *cb;
2586 timevar_push (TV_NAME_LOOKUP);
2587 gcc_assert (level != 0);
2589 /* If we're leaving a toplevel class, cache its binding level. */
2590 if (current_class_depth == 1)
2591 previous_class_level = level;
2592 for (shadowed = level->type_shadowed;
2594 shadowed = TREE_CHAIN (shadowed))
2595 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2597 /* Remove the bindings for all of the class-level declarations. */
2598 if (level->class_shadowed)
2601 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2603 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2604 ggc_free (level->class_shadowed);
2605 level->class_shadowed = NULL;
2608 /* Now, pop out of the binding level which we created up in the
2609 `pushlevel_class' routine. */
2610 gcc_assert (current_binding_level == level);
2612 timevar_pop (TV_NAME_LOOKUP);
2615 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2616 appropriate. DECL is the value to which a name has just been
2617 bound. CLASS_TYPE is the class in which the lookup occurred. */
2620 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2623 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2627 if (TREE_CODE (decl) == OVERLOAD)
2628 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2631 gcc_assert (DECL_P (decl));
2632 context = context_for_name_lookup (decl);
2635 if (is_properly_derived_from (class_type, context))
2636 INHERITED_VALUE_BINDING_P (binding) = 1;
2638 INHERITED_VALUE_BINDING_P (binding) = 0;
2640 else if (binding->value == decl)
2641 /* We only encounter a TREE_LIST when there is an ambiguity in the
2642 base classes. Such an ambiguity can be overridden by a
2643 definition in this class. */
2644 INHERITED_VALUE_BINDING_P (binding) = 1;
2646 INHERITED_VALUE_BINDING_P (binding) = 0;
2649 /* Make the declaration of X appear in CLASS scope. */
2652 pushdecl_class_level (tree x)
2655 bool is_valid = true;
2657 /* Do nothing if we're adding to an outer lambda closure type,
2658 outer_binding will add it later if it's needed. */
2659 if (current_class_type != class_binding_level->this_entity)
2662 timevar_push (TV_NAME_LOOKUP);
2663 /* Get the name of X. */
2664 if (TREE_CODE (x) == OVERLOAD)
2665 name = DECL_NAME (get_first_fn (x));
2667 name = DECL_NAME (x);
2671 is_valid = push_class_level_binding (name, x);
2672 if (TREE_CODE (x) == TYPE_DECL)
2673 set_identifier_type_value (name, x);
2675 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2677 /* If X is an anonymous aggregate, all of its members are
2678 treated as if they were members of the class containing the
2679 aggregate, for naming purposes. */
2682 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2684 location_t save_location = input_location;
2685 input_location = DECL_SOURCE_LOCATION (f);
2686 if (!pushdecl_class_level (f))
2688 input_location = save_location;
2691 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2694 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2695 scope. If the value returned is non-NULL, and the PREVIOUS field
2696 is not set, callers must set the PREVIOUS field explicitly. */
2698 static cxx_binding *
2699 get_class_binding (tree name, cxx_scope *scope)
2704 cxx_binding *binding;
2706 class_type = scope->this_entity;
2708 /* Get the type binding. */
2709 type_binding = lookup_member (class_type, name,
2710 /*protect=*/2, /*want_type=*/true);
2711 /* Get the value binding. */
2712 value_binding = lookup_member (class_type, name,
2713 /*protect=*/2, /*want_type=*/false);
2716 && (TREE_CODE (value_binding) == TYPE_DECL
2717 || DECL_CLASS_TEMPLATE_P (value_binding)
2718 || (TREE_CODE (value_binding) == TREE_LIST
2719 && TREE_TYPE (value_binding) == error_mark_node
2720 && (TREE_CODE (TREE_VALUE (value_binding))
2722 /* We found a type binding, even when looking for a non-type
2723 binding. This means that we already processed this binding
2726 else if (value_binding)
2728 if (TREE_CODE (value_binding) == TREE_LIST
2729 && TREE_TYPE (value_binding) == error_mark_node)
2730 /* NAME is ambiguous. */
2732 else if (BASELINK_P (value_binding))
2733 /* NAME is some overloaded functions. */
2734 value_binding = BASELINK_FUNCTIONS (value_binding);
2737 /* If we found either a type binding or a value binding, create a
2738 new binding object. */
2739 if (type_binding || value_binding)
2741 binding = new_class_binding (name,
2745 /* This is a class-scope binding, not a block-scope binding. */
2746 LOCAL_BINDING_P (binding) = 0;
2747 set_inherited_value_binding_p (binding, value_binding, class_type);
2755 /* Make the declaration(s) of X appear in CLASS scope under the name
2756 NAME. Returns true if the binding is valid. */
2759 push_class_level_binding (tree name, tree x)
2761 cxx_binding *binding;
2765 timevar_push (TV_NAME_LOOKUP);
2766 /* The class_binding_level will be NULL if x is a template
2767 parameter name in a member template. */
2768 if (!class_binding_level)
2769 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2771 if (name == error_mark_node)
2772 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2774 /* Check for invalid member names. */
2775 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2776 /* Check that we're pushing into the right binding level. */
2777 gcc_assert (current_class_type == class_binding_level->this_entity);
2779 /* We could have been passed a tree list if this is an ambiguous
2780 declaration. If so, pull the declaration out because
2781 check_template_shadow will not handle a TREE_LIST. */
2782 if (TREE_CODE (decl) == TREE_LIST
2783 && TREE_TYPE (decl) == error_mark_node)
2784 decl = TREE_VALUE (decl);
2786 if (!check_template_shadow (decl))
2787 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2791 If T is the name of a class, then each of the following shall
2792 have a name different from T:
2794 -- every static data member of class T;
2796 -- every member of class T that is itself a type;
2798 -- every enumerator of every member of class T that is an
2801 -- every member of every anonymous union that is a member of
2804 (Non-static data members were also forbidden to have the same
2805 name as T until TC1.) */
2806 if ((TREE_CODE (x) == VAR_DECL
2807 || TREE_CODE (x) == CONST_DECL
2808 || (TREE_CODE (x) == TYPE_DECL
2809 && !DECL_SELF_REFERENCE_P (x))
2810 /* A data member of an anonymous union. */
2811 || (TREE_CODE (x) == FIELD_DECL
2812 && DECL_CONTEXT (x) != current_class_type))
2813 && DECL_NAME (x) == constructor_name (current_class_type))
2815 tree scope = context_for_name_lookup (x);
2816 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2818 error ("%qD has the same name as the class in which it is "
2821 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2825 /* Get the current binding for NAME in this class, if any. */
2826 binding = IDENTIFIER_BINDING (name);
2827 if (!binding || binding->scope != class_binding_level)
2829 binding = get_class_binding (name, class_binding_level);
2830 /* If a new binding was created, put it at the front of the
2831 IDENTIFIER_BINDING list. */
2834 binding->previous = IDENTIFIER_BINDING (name);
2835 IDENTIFIER_BINDING (name) = binding;
2839 /* If there is already a binding, then we may need to update the
2841 if (binding && binding->value)
2843 tree bval = binding->value;
2844 tree old_decl = NULL_TREE;
2846 if (INHERITED_VALUE_BINDING_P (binding))
2848 /* If the old binding was from a base class, and was for a
2849 tag name, slide it over to make room for the new binding.
2850 The old binding is still visible if explicitly qualified
2851 with a class-key. */
2852 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2853 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2855 old_decl = binding->type;
2856 binding->type = bval;
2857 binding->value = NULL_TREE;
2858 INHERITED_VALUE_BINDING_P (binding) = 0;
2863 /* Any inherited type declaration is hidden by the type
2864 declaration in the derived class. */
2865 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2866 binding->type = NULL_TREE;
2869 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2871 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2872 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2873 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2875 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2876 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2878 if (old_decl && binding->scope == class_binding_level)
2881 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2882 here. This function is only used to register bindings
2883 from with the class definition itself. */
2884 INHERITED_VALUE_BINDING_P (binding) = 0;
2885 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2889 /* Note that we declared this value so that we can issue an error if
2890 this is an invalid redeclaration of a name already used for some
2892 note_name_declared_in_class (name, decl);
2894 /* If we didn't replace an existing binding, put the binding on the
2895 stack of bindings for the identifier, and update the shadowed
2897 if (binding && binding->scope == class_binding_level)
2898 /* Supplement the existing binding. */
2899 ok = supplement_binding (binding, decl);
2902 /* Create a new binding. */
2903 push_binding (name, decl, class_binding_level);
2907 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2910 /* Process "using SCOPE::NAME" in a class scope. Return the
2911 USING_DECL created. */
2914 do_class_using_decl (tree scope, tree name)
2916 /* The USING_DECL returned by this function. */
2918 /* The declaration (or declarations) name by this using
2919 declaration. NULL if we are in a template and cannot figure out
2920 what has been named. */
2922 /* True if SCOPE is a dependent type. */
2923 bool scope_dependent_p;
2924 /* True if SCOPE::NAME is dependent. */
2925 bool name_dependent_p;
2926 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2927 bool bases_dependent_p;
2932 if (name == error_mark_node)
2935 if (!scope || !TYPE_P (scope))
2937 error ("using-declaration for non-member at class scope");
2941 /* Make sure the name is not invalid */
2942 if (TREE_CODE (name) == BIT_NOT_EXPR)
2944 error ("%<%T::%D%> names destructor", scope, name);
2947 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2949 error ("%<%T::%D%> names constructor", scope, name);
2952 if (constructor_name_p (name, current_class_type))
2954 error ("%<%T::%D%> names constructor in %qT",
2955 scope, name, current_class_type);
2959 scope_dependent_p = dependent_type_p (scope);
2960 name_dependent_p = (scope_dependent_p
2961 || (IDENTIFIER_TYPENAME_P (name)
2962 && dependent_type_p (TREE_TYPE (name))));
2964 bases_dependent_p = false;
2965 if (processing_template_decl)
2966 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2967 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2969 if (dependent_type_p (TREE_TYPE (base_binfo)))
2971 bases_dependent_p = true;
2977 /* From [namespace.udecl]:
2979 A using-declaration used as a member-declaration shall refer to a
2980 member of a base class of the class being defined.
2982 In general, we cannot check this constraint in a template because
2983 we do not know the entire set of base classes of the current
2984 class type. However, if all of the base classes are
2985 non-dependent, then we can avoid delaying the check until
2987 if (!scope_dependent_p)
2990 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2991 if (b_kind < bk_proper_base)
2993 if (!bases_dependent_p)
2995 error_not_base_type (scope, current_class_type);
2999 else if (!name_dependent_p)
3001 decl = lookup_member (binfo, name, 0, false);
3004 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3008 /* The binfo from which the functions came does not matter. */
3009 if (BASELINK_P (decl))
3010 decl = BASELINK_FUNCTIONS (decl);
3014 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3015 USING_DECL_DECLS (value) = decl;
3016 USING_DECL_SCOPE (value) = scope;
3017 DECL_DEPENDENT_P (value) = !decl;
3023 /* Return the binding value for name in scope. */
3026 namespace_binding (tree name, tree scope)
3028 cxx_binding *binding;
3031 scope = global_namespace;
3033 /* Unnecessary for the global namespace because it can't be an alias. */
3034 scope = ORIGINAL_NAMESPACE (scope);
3036 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3038 return binding ? binding->value : NULL_TREE;
3041 /* Set the binding value for name in scope. */
3044 set_namespace_binding (tree name, tree scope, tree val)
3048 timevar_push (TV_NAME_LOOKUP);
3049 if (scope == NULL_TREE)
3050 scope = global_namespace;
3051 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3052 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3055 supplement_binding (b, val);
3056 timevar_pop (TV_NAME_LOOKUP);
3059 /* Set the context of a declaration to scope. Complain if we are not
3063 set_decl_namespace (tree decl, tree scope, bool friendp)
3067 /* Get rid of namespace aliases. */
3068 scope = ORIGINAL_NAMESPACE (scope);
3070 /* It is ok for friends to be qualified in parallel space. */
3071 if (!friendp && !is_ancestor (current_namespace, scope))
3072 error ("declaration of %qD not in a namespace surrounding %qD",
3074 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3076 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3077 if (scope == current_namespace)
3079 if (at_namespace_scope_p ())
3080 error ("explicit qualification in declaration of %qD",
3085 /* See whether this has been declared in the namespace. */
3086 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3087 if (old == error_mark_node)
3088 /* No old declaration at all. */
3090 if (!is_overloaded_fn (decl))
3091 /* Don't compare non-function decls with decls_match here, since
3092 it can't check for the correct constness at this
3093 point. pushdecl will find those errors later. */
3095 /* Since decl is a function, old should contain a function decl. */
3096 if (!is_overloaded_fn (old))
3098 fn = OVL_CURRENT (old);
3099 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3101 /* A template can be explicitly specialized in any namespace. */
3102 if (processing_explicit_instantiation)
3104 if (processing_template_decl || processing_specialization)
3105 /* We have not yet called push_template_decl to turn a
3106 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3107 match. But, we'll check later, when we construct the
3110 /* Instantiations or specializations of templates may be declared as
3111 friends in any namespace. */
3112 if (friendp && DECL_USE_TEMPLATE (decl))
3114 if (is_overloaded_fn (old))
3116 for (; old; old = OVL_NEXT (old))
3117 if (decls_match (decl, OVL_CURRENT (old)))
3120 else if (decls_match (decl, old))
3123 error ("%qD should have been declared inside %qD", decl, scope);
3126 /* Return the namespace where the current declaration is declared. */
3129 current_decl_namespace (void)
3132 /* If we have been pushed into a different namespace, use it. */
3133 if (decl_namespace_list)
3134 return TREE_PURPOSE (decl_namespace_list);
3136 if (current_class_type)
3137 result = decl_namespace_context (current_class_type);
3138 else if (current_function_decl)
3139 result = decl_namespace_context (current_function_decl);
3141 result = current_namespace;
3145 /* Process any ATTRIBUTES on a namespace definition. Currently only
3146 attribute visibility is meaningful, which is a property of the syntactic
3147 block rather than the namespace as a whole, so we don't touch the
3148 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3151 handle_namespace_attrs (tree ns, tree attributes)
3154 bool saw_vis = false;
3156 for (d = attributes; d; d = TREE_CHAIN (d))
3158 tree name = TREE_PURPOSE (d);
3159 tree args = TREE_VALUE (d);
3161 #ifdef HANDLE_PRAGMA_VISIBILITY
3162 if (is_attribute_p ("visibility", name))
3164 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3165 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3167 warning (OPT_Wattributes,
3168 "%qD attribute requires a single NTBS argument",
3173 if (!TREE_PUBLIC (ns))
3174 warning (OPT_Wattributes,
3175 "%qD attribute is meaningless since members of the "
3176 "anonymous namespace get local symbols", name);
3178 push_visibility (TREE_STRING_POINTER (x));
3184 warning (OPT_Wattributes, "%qD attribute directive ignored",
3193 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3194 select a name that is unique to this compilation unit. */
3197 push_namespace (tree name)
3201 int implicit_use = 0;
3204 timevar_push (TV_NAME_LOOKUP);
3206 /* We should not get here if the global_namespace is not yet constructed
3207 nor if NAME designates the global namespace: The global scope is
3208 constructed elsewhere. */
3209 gcc_assert (global_namespace != NULL && name != global_scope_name);
3213 name = get_anonymous_namespace_name();
3214 d = IDENTIFIER_NAMESPACE_VALUE (name);
3216 /* Reopening anonymous namespace. */
3222 /* Check whether this is an extended namespace definition. */
3223 d = IDENTIFIER_NAMESPACE_VALUE (name);
3224 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3227 if (DECL_NAMESPACE_ALIAS (d))
3229 error ("namespace alias %qD not allowed here, assuming %qD",
3230 d, DECL_NAMESPACE_ALIAS (d));
3231 d = DECL_NAMESPACE_ALIAS (d);
3238 /* Make a new namespace, binding the name to it. */
3239 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3240 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3241 /* The name of this namespace is not visible to other translation
3242 units if it is an anonymous namespace or member thereof. */
3243 if (anon || decl_anon_ns_mem_p (current_namespace))
3244 TREE_PUBLIC (d) = 0;
3246 TREE_PUBLIC (d) = 1;
3250 /* Clear DECL_NAME for the benefit of debugging back ends. */
3251 SET_DECL_ASSEMBLER_NAME (d, name);
3252 DECL_NAME (d) = NULL_TREE;
3254 begin_scope (sk_namespace, d);
3257 resume_scope (NAMESPACE_LEVEL (d));
3260 do_using_directive (d);
3261 /* Enter the name space. */
3262 current_namespace = d;
3264 timevar_pop (TV_NAME_LOOKUP);
3267 /* Pop from the scope of the current namespace. */
3270 pop_namespace (void)
3272 gcc_assert (current_namespace != global_namespace);
3273 current_namespace = CP_DECL_CONTEXT (current_namespace);
3274 /* The binding level is not popped, as it might be re-opened later. */
3278 /* Push into the scope of the namespace NS, even if it is deeply
3279 nested within another namespace. */
3282 push_nested_namespace (tree ns)
3284 if (ns == global_namespace)
3285 push_to_top_level ();
3288 push_nested_namespace (CP_DECL_CONTEXT (ns));
3289 push_namespace (DECL_NAME (ns));
3293 /* Pop back from the scope of the namespace NS, which was previously
3294 entered with push_nested_namespace. */
3297 pop_nested_namespace (tree ns)
3299 timevar_push (TV_NAME_LOOKUP);
3300 while (ns != global_namespace)
3303 ns = CP_DECL_CONTEXT (ns);
3306 pop_from_top_level ();
3307 timevar_pop (TV_NAME_LOOKUP);
3310 /* Temporarily set the namespace for the current declaration. */
3313 push_decl_namespace (tree decl)
3315 if (TREE_CODE (decl) != NAMESPACE_DECL)
3316 decl = decl_namespace_context (decl);
3317 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3318 NULL_TREE, decl_namespace_list);
3321 /* [namespace.memdef]/2 */
3324 pop_decl_namespace (void)
3326 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3329 /* Return the namespace that is the common ancestor
3330 of two given namespaces. */
3333 namespace_ancestor (tree ns1, tree ns2)
3335 timevar_push (TV_NAME_LOOKUP);
3336 if (is_ancestor (ns1, ns2))
3337 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3338 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3339 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3342 /* Process a namespace-alias declaration. */
3345 do_namespace_alias (tree alias, tree name_space)
3347 if (name_space == error_mark_node)
3350 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3352 name_space = ORIGINAL_NAMESPACE (name_space);
3354 /* Build the alias. */
3355 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3356 DECL_NAMESPACE_ALIAS (alias) = name_space;
3357 DECL_EXTERNAL (alias) = 1;
3358 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3361 /* Emit debug info for namespace alias. */
3362 if (!building_stmt_tree ())
3363 (*debug_hooks->global_decl) (alias);
3366 /* Like pushdecl, only it places X in the current namespace,
3370 pushdecl_namespace_level (tree x, bool is_friend)
3372 struct cp_binding_level *b = current_binding_level;
3375 timevar_push (TV_NAME_LOOKUP);
3376 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3378 /* Now, the type_shadowed stack may screw us. Munge it so it does
3380 if (TREE_CODE (t) == TYPE_DECL)
3382 tree name = DECL_NAME (t);
3384 tree *ptr = (tree *)0;
3385 for (; !global_scope_p (b); b = b->level_chain)
3387 tree shadowed = b->type_shadowed;
3388 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3389 if (TREE_PURPOSE (shadowed) == name)
3391 ptr = &TREE_VALUE (shadowed);
3392 /* Can't break out of the loop here because sometimes
3393 a binding level will have duplicate bindings for
3394 PT names. It's gross, but I haven't time to fix it. */
3397 newval = TREE_TYPE (t);
3398 if (ptr == (tree *)0)
3400 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3401 up here if this is changed to an assertion. --KR */
3402 SET_IDENTIFIER_TYPE_VALUE (name, t);
3409 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3412 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3413 directive is not directly from the source. Also find the common
3414 ancestor and let our users know about the new namespace */
3416 add_using_namespace (tree user, tree used, bool indirect)
3419 timevar_push (TV_NAME_LOOKUP);
3420 /* Using oneself is a no-op. */
3423 timevar_pop (TV_NAME_LOOKUP);
3426 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3427 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3428 /* Check if we already have this. */
3429 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3433 /* Promote to direct usage. */
3434 TREE_INDIRECT_USING (t) = 0;
3435 timevar_pop (TV_NAME_LOOKUP);
3439 /* Add used to the user's using list. */
3440 DECL_NAMESPACE_USING (user)
3441 = tree_cons (used, namespace_ancestor (user, used),
3442 DECL_NAMESPACE_USING (user));
3444 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3446 /* Add user to the used's users list. */
3447 DECL_NAMESPACE_USERS (used)
3448 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3450 /* Recursively add all namespaces used. */
3451 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3452 /* indirect usage */
3453 add_using_namespace (user, TREE_PURPOSE (t), 1);
3455 /* Tell everyone using us about the new used namespaces. */
3456 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3457 add_using_namespace (TREE_PURPOSE (t), used, 1);
3458 timevar_pop (TV_NAME_LOOKUP);
3461 /* Process a using-declaration not appearing in class or local scope. */
3464 do_toplevel_using_decl (tree decl, tree scope, tree name)
3466 tree oldval, oldtype, newval, newtype;
3467 tree orig_decl = decl;
3468 cxx_binding *binding;
3470 decl = validate_nonmember_using_decl (decl, scope, name);
3471 if (decl == NULL_TREE)
3474 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3476 oldval = binding->value;
3477 oldtype = binding->type;
3479 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3481 /* Emit debug info. */
3482 if (!processing_template_decl)
3483 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3485 /* Copy declarations found. */
3487 binding->value = newval;
3489 binding->type = newtype;
3492 /* Process a using-directive. */
3495 do_using_directive (tree name_space)
3497 tree context = NULL_TREE;
3499 if (name_space == error_mark_node)
3502 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3504 if (building_stmt_tree ())
3505 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3506 name_space = ORIGINAL_NAMESPACE (name_space);
3508 if (!toplevel_bindings_p ())
3510 push_using_directive (name_space);
3515 add_using_namespace (current_namespace, name_space, 0);
3516 if (current_namespace != global_namespace)
3517 context = current_namespace;
3519 /* Emit debugging info. */
3520 if (!processing_template_decl)
3521 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3526 /* Deal with a using-directive seen by the parser. Currently we only
3527 handle attributes here, since they cannot appear inside a template. */
3530 parse_using_directive (tree name_space, tree attribs)
3534 do_using_directive (name_space);
3536 for (a = attribs; a; a = TREE_CHAIN (a))
3538 tree name = TREE_PURPOSE (a);
3539 if (is_attribute_p ("strong", name))
3541 if (!toplevel_bindings_p ())
3542 error ("strong using only meaningful at namespace scope");
3543 else if (name_space != error_mark_node)
3545 if (!is_ancestor (current_namespace, name_space))
3546 error ("current namespace %qD does not enclose strongly used namespace %qD",
3547 current_namespace, name_space);
3548 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3549 = tree_cons (current_namespace, 0,
3550 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3554 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3558 /* Like pushdecl, only it places X in the global scope if appropriate.
3559 Calls cp_finish_decl to register the variable, initializing it with
3560 *INIT, if INIT is non-NULL. */
3563 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3565 timevar_push (TV_NAME_LOOKUP);
3566 push_to_top_level ();
3567 x = pushdecl_namespace_level (x, is_friend);
3569 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3570 pop_from_top_level ();
3571 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3574 /* Like pushdecl, only it places X in the global scope if appropriate. */
3577 pushdecl_top_level (tree x)
3579 return pushdecl_top_level_1 (x, NULL, false);
3582 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3585 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3587 return pushdecl_top_level_1 (x, NULL, is_friend);
3590 /* Like pushdecl, only it places X in the global scope if
3591 appropriate. Calls cp_finish_decl to register the variable,
3592 initializing it with INIT. */
3595 pushdecl_top_level_and_finish (tree x, tree init)
3597 return pushdecl_top_level_1 (x, &init, false);
3600 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3601 duplicates. The first list becomes the tail of the result.
3603 The algorithm is O(n^2). We could get this down to O(n log n) by
3604 doing a sort on the addresses of the functions, if that becomes
3608 merge_functions (tree s1, tree s2)
3610 for (; s2; s2 = OVL_NEXT (s2))
3612 tree fn2 = OVL_CURRENT (s2);
3615 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3617 tree fn1 = OVL_CURRENT (fns1);
3619 /* If the function from S2 is already in S1, there is no
3620 need to add it again. For `extern "C"' functions, we
3621 might have two FUNCTION_DECLs for the same function, in
3622 different namespaces, but let's leave them in in case
3623 they have different default arguments. */
3628 /* If we exhausted all of the functions in S1, FN2 is new. */
3630 s1 = build_overload (fn2, s1);
3635 /* This should return an error not all definitions define functions.
3636 It is not an error if we find two functions with exactly the
3637 same signature, only if these are selected in overload resolution.
3638 old is the current set of bindings, new_binding the freshly-found binding.
3639 XXX Do we want to give *all* candidates in case of ambiguity?
3640 XXX In what way should I treat extern declarations?
3641 XXX I don't want to repeat the entire duplicate_decls here */
3644 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3647 gcc_assert (old != NULL);
3649 /* Copy the type. */
3650 type = new_binding->type;
3651 if (LOOKUP_NAMESPACES_ONLY (flags)
3652 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3655 /* Copy the value. */
3656 val = new_binding->value;
3659 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3662 switch (TREE_CODE (val))
3665 /* If we expect types or namespaces, and not templates,
3666 or this is not a template class. */
3667 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3668 && !DECL_CLASS_TEMPLATE_P (val)))
3672 if (LOOKUP_NAMESPACES_ONLY (flags)
3673 || (type && (flags & LOOKUP_PREFER_TYPES)))
3676 case NAMESPACE_DECL:
3677 if (LOOKUP_TYPES_ONLY (flags))
3681 /* Ignore built-in functions that are still anticipated. */
3682 if (LOOKUP_QUALIFIERS_ONLY (flags))
3686 if (LOOKUP_QUALIFIERS_ONLY (flags))
3691 /* If val is hidden, shift down any class or enumeration name. */
3700 else if (val && val != old->value)
3702 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3703 old->value = merge_functions (old->value, val);
3706 old->value = tree_cons (NULL_TREE, old->value,
3707 build_tree_list (NULL_TREE, val));
3708 TREE_TYPE (old->value) = error_mark_node;
3714 else if (type && old->type != type)
3716 old->type = tree_cons (NULL_TREE, old->type,
3717 build_tree_list (NULL_TREE, type));
3718 TREE_TYPE (old->type) = error_mark_node;
3722 /* Return the declarations that are members of the namespace NS. */
3725 cp_namespace_decls (tree ns)
3727 return NAMESPACE_LEVEL (ns)->names;
3730 /* Combine prefer_type and namespaces_only into flags. */
3733 lookup_flags (int prefer_type, int namespaces_only)
3735 if (namespaces_only)
3736 return LOOKUP_PREFER_NAMESPACES;
3737 if (prefer_type > 1)
3738 return LOOKUP_PREFER_TYPES;
3739 if (prefer_type > 0)
3740 return LOOKUP_PREFER_BOTH;
3744 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3745 ignore it or not. Subroutine of lookup_name_real and
3746 lookup_type_scope. */
3749 qualify_lookup (tree val, int flags)
3751 if (val == NULL_TREE)
3753 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3755 if ((flags & LOOKUP_PREFER_TYPES)
3756 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3758 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3760 /* In unevaluated context, look past normal capture fields. */
3761 if (cp_unevaluated_operand && TREE_CODE (val) == FIELD_DECL
3762 && DECL_NORMAL_CAPTURE_P (val))
3767 /* Given a lookup that returned VAL, decide if we want to ignore it or
3768 not based on DECL_ANTICIPATED. */
3771 hidden_name_p (tree val)
3774 && DECL_LANG_SPECIFIC (val)
3775 && DECL_ANTICIPATED (val))
3780 /* Remove any hidden friend functions from a possibly overloaded set
3784 remove_hidden_names (tree fns)
3789 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3791 else if (TREE_CODE (fns) == OVERLOAD)
3795 for (o = fns; o; o = OVL_NEXT (o))
3796 if (hidden_name_p (OVL_CURRENT (o)))
3802 for (o = fns; o; o = OVL_NEXT (o))
3803 if (!hidden_name_p (OVL_CURRENT (o)))
3804 n = build_overload (OVL_CURRENT (o), n);
3812 /* Unscoped lookup of a global: iterate over current namespaces,
3813 considering using-directives. */
3816 unqualified_namespace_lookup (tree name, int flags)
3818 tree initial = current_decl_namespace ();
3819 tree scope = initial;
3821 struct cp_binding_level *level;
3822 tree val = NULL_TREE;
3824 timevar_push (TV_NAME_LOOKUP);
3826 for (; !val; scope = CP_DECL_CONTEXT (scope))
3828 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3830 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3833 ambiguous_decl (&binding, b, flags);
3835 /* Add all _DECLs seen through local using-directives. */
3836 for (level = current_binding_level;
3837 level->kind != sk_namespace;
3838 level = level->level_chain)
3839 if (!lookup_using_namespace (name, &binding, level->using_directives,
3841 /* Give up because of error. */
3842 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3844 /* Add all _DECLs seen through global using-directives. */
3845 /* XXX local and global using lists should work equally. */
3849 if (!lookup_using_namespace (name, &binding,
3850 DECL_NAMESPACE_USING (siter),
3852 /* Give up because of error. */
3853 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3854 if (siter == scope) break;
3855 siter = CP_DECL_CONTEXT (siter);
3858 val = binding.value;
3859 if (scope == global_namespace)
3862 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3865 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3866 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3869 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3870 declaration found. If no suitable declaration can be found,
3871 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3872 neither a class-type nor a namespace a diagnostic is issued. */
3875 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3880 if (TREE_CODE (scope) == NAMESPACE_DECL)
3882 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3884 flags |= LOOKUP_COMPLAIN;
3886 flags |= LOOKUP_PREFER_TYPES;
3887 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3890 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3891 t = lookup_enumerator (scope, name);
3892 else if (is_class_type (scope, complain))
3893 t = lookup_member (scope, name, 2, is_type_p);
3896 return error_mark_node;
3900 /* Subroutine of unqualified_namespace_lookup:
3901 Add the bindings of NAME in used namespaces to VAL.
3902 We are currently looking for names in namespace SCOPE, so we
3903 look through USINGS for using-directives of namespaces
3904 which have SCOPE as a common ancestor with the current scope.
3905 Returns false on errors. */
3908 lookup_using_namespace (tree name, struct scope_binding *val,
3909 tree usings, tree scope, int flags)
3912 timevar_push (TV_NAME_LOOKUP);
3913 /* Iterate over all used namespaces in current, searching for using
3914 directives of scope. */
3915 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3916 if (TREE_VALUE (iter) == scope)
3918 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3920 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3921 /* Resolve ambiguities. */
3923 ambiguous_decl (val, val1, flags);
3925 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3929 Accepts the NAME to lookup and its qualifying SCOPE.
3930 Returns the name/type pair found into the cxx_binding *RESULT,
3931 or false on error. */
3934 qualified_lookup_using_namespace (tree name, tree scope,
3935 struct scope_binding *result, int flags)
3937 /* Maintain a list of namespaces visited... */
3938 tree seen = NULL_TREE;
3939 /* ... and a list of namespace yet to see. */
3940 tree todo = NULL_TREE;
3941 tree todo_maybe = NULL_TREE;
3942 tree *todo_weak = &todo_maybe;
3944 timevar_push (TV_NAME_LOOKUP);
3945 /* Look through namespace aliases. */
3946 scope = ORIGINAL_NAMESPACE (scope);
3947 while (scope && result->value != error_mark_node)
3949 cxx_binding *binding =
3950 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3951 seen = tree_cons (scope, NULL_TREE, seen);
3953 ambiguous_decl (result, binding, flags);
3955 /* Consider strong using directives always, and non-strong ones
3956 if we haven't found a binding yet. */
3957 for (usings = DECL_NAMESPACE_USING (scope); usings;
3958 usings = TREE_CHAIN (usings))
3959 /* If this was a real directive, and we have not seen it. */
3960 if (!TREE_INDIRECT_USING (usings))
3962 /* Try to avoid queuing the same namespace more than once,
3963 the exception being when a namespace was already
3964 enqueued for todo_maybe and then a strong using is
3965 found for it. We could try to remove it from
3966 todo_maybe, but it's probably not worth the effort. */
3967 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3968 && !purpose_member (TREE_PURPOSE (usings), seen)
3969 && !purpose_member (TREE_PURPOSE (usings), todo))
3970 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3972 && !purpose_member (TREE_PURPOSE (usings), seen)
3973 && !purpose_member (TREE_PURPOSE (usings), todo)
3974 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3975 *todo_weak = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3980 scope = TREE_PURPOSE (todo);
3981 todo = TREE_CHAIN (todo);
3984 && (!result->value && !result->type))
3986 scope = TREE_PURPOSE (todo_maybe);
3987 todo = TREE_CHAIN (todo_maybe);
3988 todo_maybe = NULL_TREE;
3992 scope = NULL_TREE; /* If there never was a todo list. */
3994 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3997 /* Subroutine of outer_binding.
3998 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
4002 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4007 if (!binding || !scope)
4010 binding_value = binding->value ? binding->value : binding->type;
4013 && scope->this_entity
4014 && get_template_info (scope->this_entity)
4015 && parameter_of_template_p (binding_value,
4016 TI_TEMPLATE (get_template_info \
4017 (scope->this_entity))));
4020 /* Return the innermost non-namespace binding for NAME from a scope
4021 containing BINDING, or, if BINDING is NULL, the current scope.
4022 Please note that for a given template, the template parameters are
4023 considered to be in the scope containing the current scope.
4024 If CLASS_P is false, then class bindings are ignored. */
4027 outer_binding (tree name,
4028 cxx_binding *binding,
4033 cxx_scope *outer_scope;
4037 scope = binding->scope->level_chain;
4038 outer = binding->previous;
4042 scope = current_binding_level;
4043 outer = IDENTIFIER_BINDING (name);
4045 outer_scope = outer ? outer->scope : NULL;
4047 /* Because we create class bindings lazily, we might be missing a
4048 class binding for NAME. If there are any class binding levels
4049 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4050 declared, we must lookup NAME in those class scopes. */
4052 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4054 if (scope->kind == sk_class)
4056 cxx_binding *class_binding;
4058 class_binding = get_class_binding (name, scope);
4061 /* Thread this new class-scope binding onto the
4062 IDENTIFIER_BINDING list so that future lookups
4064 class_binding->previous = outer;
4066 binding->previous = class_binding;
4068 IDENTIFIER_BINDING (name) = class_binding;
4069 return class_binding;
4072 /* If we are in a member template, the template parms of the member
4073 template are considered to be inside the scope of the containing
4074 class, but within G++ the class bindings are all pushed between the
4075 template parms and the function body. So if the outer binding is
4076 a template parm for the current scope, return it now rather than
4077 look for a class binding. */
4078 if (outer_scope && outer_scope->kind == sk_template_parms
4079 && binding_to_template_parms_of_scope_p (outer, scope))
4082 scope = scope->level_chain;
4088 /* Return the innermost block-scope or class-scope value binding for
4089 NAME, or NULL_TREE if there is no such binding. */
4092 innermost_non_namespace_value (tree name)
4094 cxx_binding *binding;
4095 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4096 return binding ? binding->value : NULL_TREE;
4099 /* Look up NAME in the current binding level and its superiors in the
4100 namespace of variables, functions and typedefs. Return a ..._DECL
4101 node of some kind representing its definition if there is only one
4102 such declaration, or return a TREE_LIST with all the overloaded
4103 definitions if there are many, or return 0 if it is undefined.
4104 Hidden name, either friend declaration or built-in function, are
4107 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4108 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4109 Otherwise we prefer non-TYPE_DECLs.
4111 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4112 BLOCK_P is false, bindings in block scopes are ignored. */
4115 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4116 int namespaces_only, int flags)
4119 tree val = NULL_TREE;
4121 timevar_push (TV_NAME_LOOKUP);
4122 /* Conversion operators are handled specially because ordinary
4123 unqualified name lookup will not find template conversion
4125 if (IDENTIFIER_TYPENAME_P (name))
4127 struct cp_binding_level *level;
4129 for (level = current_binding_level;
4130 level && level->kind != sk_namespace;
4131 level = level->level_chain)
4136 /* A conversion operator can only be declared in a class
4138 if (level->kind != sk_class)
4141 /* Lookup the conversion operator in the class. */
4142 class_type = level->this_entity;
4143 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4145 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4148 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4151 flags |= lookup_flags (prefer_type, namespaces_only);
4153 /* First, look in non-namespace scopes. */
4155 if (current_class_type == NULL_TREE)
4158 if (block_p || !nonclass)
4159 for (iter = outer_binding (name, NULL, !nonclass);
4161 iter = outer_binding (name, iter, !nonclass))
4165 /* Skip entities we don't want. */
4166 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4169 /* If this is the kind of thing we're looking for, we're done. */
4170 if (qualify_lookup (iter->value, flags))
4171 binding = iter->value;
4172 else if ((flags & LOOKUP_PREFER_TYPES)
4173 && qualify_lookup (iter->type, flags))
4174 binding = iter->type;
4176 binding = NULL_TREE;
4180 if (hidden_name_p (binding))
4182 /* A non namespace-scope binding can only be hidden in the
4183 presence of a local class, due to friend declarations.
4185 In particular, consider:
4193 B* b; // error: B is hidden
4194 C* c; // OK, finds ::C
4197 B *b; // error: B is hidden
4198 C *c; // OK, finds ::C
4203 The standard says that "B" is a local class in "f"
4204 (but not nested within "A") -- but that name lookup
4205 for "B" does not find this declaration until it is
4206 declared directly with "f".
4212 If a friend declaration appears in a local class and
4213 the name specified is an unqualified name, a prior
4214 declaration is looked up without considering scopes
4215 that are outside the innermost enclosing non-class
4216 scope. For a friend function declaration, if there is
4217 no prior declaration, the program is ill-formed. For a
4218 friend class declaration, if there is no prior
4219 declaration, the class that is specified belongs to the
4220 innermost enclosing non-class scope, but if it is
4221 subsequently referenced, its name is not found by name
4222 lookup until a matching declaration is provided in the
4223 innermost enclosing nonclass scope.
4225 So just keep looking for a non-hidden binding.
4227 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4235 /* Now lookup in namespace scopes. */
4237 val = unqualified_namespace_lookup (name, flags);
4239 /* If we have a single function from a using decl, pull it out. */
4240 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4241 val = OVL_FUNCTION (val);
4243 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4247 lookup_name_nonclass (tree name)
4249 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4253 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4256 lookup_arg_dependent (name,
4257 lookup_name_real (name, 0, 1, block_p, 0,
4263 lookup_name (tree name)
4265 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4269 lookup_name_prefer_type (tree name, int prefer_type)
4271 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4272 0, LOOKUP_COMPLAIN);
4275 /* Look up NAME for type used in elaborated name specifier in
4276 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4277 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4278 name, more scopes are checked if cleanup or template parameter
4279 scope is encountered.
4281 Unlike lookup_name_real, we make sure that NAME is actually
4282 declared in the desired scope, not from inheritance, nor using
4283 directive. For using declaration, there is DR138 still waiting
4284 to be resolved. Hidden name coming from an earlier friend
4285 declaration is also returned.
4287 A TYPE_DECL best matching the NAME is returned. Catching error
4288 and issuing diagnostics are caller's responsibility. */
4291 lookup_type_scope (tree name, tag_scope scope)
4293 cxx_binding *iter = NULL;
4294 tree val = NULL_TREE;
4296 timevar_push (TV_NAME_LOOKUP);
4298 /* Look in non-namespace scope first. */
4299 if (current_binding_level->kind != sk_namespace)
4300 iter = outer_binding (name, NULL, /*class_p=*/ true);
4301 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4303 /* Check if this is the kind of thing we're looking for.
4304 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4305 base class. For ITER->VALUE, we can simply use
4306 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4309 We check ITER->TYPE before ITER->VALUE in order to handle
4310 typedef struct C {} C;
4313 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4314 && (scope != ts_current
4315 || LOCAL_BINDING_P (iter)
4316 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4318 else if ((scope != ts_current
4319 || !INHERITED_VALUE_BINDING_P (iter))
4320 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4327 /* Look in namespace scope. */
4330 iter = cxx_scope_find_binding_for_name
4331 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4335 /* If this is the kind of thing we're looking for, we're done. */
4336 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4338 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4344 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4345 and template parameter scopes. */
4348 struct cp_binding_level *b = current_binding_level;
4351 if (iter->scope == b)
4352 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4354 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4355 || b->kind == sk_function_parms)
4357 else if (b->kind == sk_class
4358 && scope == ts_within_enclosing_non_class)
4365 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4368 /* Similar to `lookup_name' but look only in the innermost non-class
4372 lookup_name_innermost_nonclass_level (tree name)
4374 struct cp_binding_level *b;
4377 timevar_push (TV_NAME_LOOKUP);
4378 b = innermost_nonclass_level ();
4380 if (b->kind == sk_namespace)
4382 t = IDENTIFIER_NAMESPACE_VALUE (name);
4384 /* extern "C" function() */
4385 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4388 else if (IDENTIFIER_BINDING (name)
4389 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4391 cxx_binding *binding;
4392 binding = IDENTIFIER_BINDING (name);
4395 if (binding->scope == b
4396 && !(TREE_CODE (binding->value) == VAR_DECL
4397 && DECL_DEAD_FOR_LOCAL (binding->value)))
4398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4400 if (b->kind == sk_cleanup)
4407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4410 /* Returns true iff DECL is a block-scope extern declaration of a function
4414 is_local_extern (tree decl)
4416 cxx_binding *binding;
4418 /* For functions, this is easy. */
4419 if (TREE_CODE (decl) == FUNCTION_DECL)
4420 return DECL_LOCAL_FUNCTION_P (decl);
4422 if (TREE_CODE (decl) != VAR_DECL)
4424 if (!current_function_decl)
4427 /* For variables, this is not easy. We need to look at the binding stack
4428 for the identifier to see whether the decl we have is a local. */
4429 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4430 binding && binding->scope->kind != sk_namespace;
4431 binding = binding->previous)
4432 if (binding->value == decl)
4433 return LOCAL_BINDING_P (binding);
4438 /* Like lookup_name_innermost_nonclass_level, but for types. */
4441 lookup_type_current_level (tree name)
4445 timevar_push (TV_NAME_LOOKUP);
4446 gcc_assert (current_binding_level->kind != sk_namespace);
4448 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4449 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4451 struct cp_binding_level *b = current_binding_level;
4454 if (purpose_member (name, b->type_shadowed))
4455 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4456 REAL_IDENTIFIER_TYPE_VALUE (name));
4457 if (b->kind == sk_cleanup)
4464 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4467 /* [basic.lookup.koenig] */
4468 /* A nonzero return value in the functions below indicates an error. */
4479 static bool arg_assoc (struct arg_lookup*, tree);
4480 static bool arg_assoc_args (struct arg_lookup*, tree);
4481 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4482 static bool arg_assoc_type (struct arg_lookup*, tree);
4483 static bool add_function (struct arg_lookup *, tree);
4484 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4485 static bool arg_assoc_class (struct arg_lookup *, tree);
4486 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4488 /* Add a function to the lookup structure.
4489 Returns true on error. */
4492 add_function (struct arg_lookup *k, tree fn)
4494 /* We used to check here to see if the function was already in the list,
4495 but that's O(n^2), which is just too expensive for function lookup.
4496 Now we deal with the occasional duplicate in joust. In doing this, we
4497 assume that the number of duplicates will be small compared to the
4498 total number of functions being compared, which should usually be the
4501 /* We must find only functions, or exactly one non-function. */
4504 else if (fn == k->functions)
4506 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4507 k->functions = build_overload (fn, k->functions);
4510 tree f1 = OVL_CURRENT (k->functions);
4512 if (is_overloaded_fn (f1))
4514 fn = f1; f1 = f2; f2 = fn;
4516 error ("%q+D is not a function,", f1);
4517 error (" conflict with %q+D", f2);
4518 error (" in call to %qD", k->name);
4525 /* Returns true iff CURRENT has declared itself to be an associated
4526 namespace of SCOPE via a strong using-directive (or transitive chain
4527 thereof). Both are namespaces. */
4530 is_associated_namespace (tree current, tree scope)
4532 tree seen = NULL_TREE;
4533 tree todo = NULL_TREE;
4537 if (scope == current)
4539 seen = tree_cons (scope, NULL_TREE, seen);
4540 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4541 if (!purpose_member (TREE_PURPOSE (t), seen))
4542 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4545 scope = TREE_PURPOSE (todo);
4546 todo = TREE_CHAIN (todo);
4553 /* Return whether FN is a friend of an associated class of ARG. */
4556 friend_of_associated_class_p (tree arg, tree fn)
4562 else if (type_unknown_p (arg))
4565 type = TREE_TYPE (arg);
4567 /* If TYPE is a class, the class itself and all base classes are
4568 associated classes. */
4569 if (CLASS_TYPE_P (type))
4571 if (is_friend (type, fn))
4574 if (TYPE_BINFO (type))
4576 tree binfo, base_binfo;
4579 for (binfo = TYPE_BINFO (type), i = 0;
4580 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4582 if (is_friend (BINFO_TYPE (base_binfo), fn))
4587 /* If TYPE is a class member, the class of which it is a member is
4588 an associated class. */
4589 if ((CLASS_TYPE_P (type)
4590 || TREE_CODE (type) == UNION_TYPE
4591 || TREE_CODE (type) == ENUMERAL_TYPE)
4592 && TYPE_CONTEXT (type)
4593 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4594 && is_friend (TYPE_CONTEXT (type), fn))
4600 /* Add functions of a namespace to the lookup structure.
4601 Returns true on error. */
4604 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4608 if (purpose_member (scope, k->namespaces))
4610 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4612 /* Check out our super-users. */
4613 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4614 value = TREE_CHAIN (value))
4615 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4618 /* Also look down into inline namespaces. */
4619 for (value = DECL_NAMESPACE_USING (scope); value;
4620 value = TREE_CHAIN (value))
4621 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4622 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4625 value = namespace_binding (k->name, scope);
4629 for (; value; value = OVL_NEXT (value))
4631 /* We don't want to find arbitrary hidden functions via argument
4632 dependent lookup. We only want to find friends of associated
4634 if (hidden_name_p (OVL_CURRENT (value)))
4639 for (ix = 0; VEC_iterate (tree, k->args, ix, arg); ++ix)
4640 if (friend_of_associated_class_p (arg, OVL_CURRENT (value)))
4642 if (ix >= VEC_length (tree, k->args))
4646 if (add_function (k, OVL_CURRENT (value)))
4653 /* Adds everything associated with a template argument to the lookup
4654 structure. Returns true on error. */
4657 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4659 /* [basic.lookup.koenig]
4661 If T is a template-id, its associated namespaces and classes are
4662 ... the namespaces and classes associated with the types of the
4663 template arguments provided for template type parameters
4664 (excluding template template parameters); the namespaces in which
4665 any template template arguments are defined; and the classes in
4666 which any member templates used as template template arguments
4667 are defined. [Note: non-type template arguments do not
4668 contribute to the set of associated namespaces. ] */
4670 /* Consider first template template arguments. */
4671 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4672 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4674 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4676 tree ctx = CP_DECL_CONTEXT (arg);
4678 /* It's not a member template. */
4679 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4680 return arg_assoc_namespace (k, ctx);
4681 /* Otherwise, it must be member template. */
4683 return arg_assoc_class (k, ctx);
4685 /* It's an argument pack; handle it recursively. */
4686 else if (ARGUMENT_PACK_P (arg))
4688 tree args = ARGUMENT_PACK_ARGS (arg);
4689 int i, len = TREE_VEC_LENGTH (args);
4690 for (i = 0; i < len; ++i)
4691 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4696 /* It's not a template template argument, but it is a type template
4698 else if (TYPE_P (arg))
4699 return arg_assoc_type (k, arg);
4700 /* It's a non-type template argument. */
4705 /* Adds everything associated with class to the lookup structure.
4706 Returns true on error. */
4709 arg_assoc_class (struct arg_lookup *k, tree type)
4711 tree list, friends, context;
4714 /* Backend build structures, such as __builtin_va_list, aren't
4715 affected by all this. */
4716 if (!CLASS_TYPE_P (type))
4719 if (purpose_member (type, k->classes))
4721 k->classes = tree_cons (type, NULL_TREE, k->classes);
4723 context = decl_namespace_context (type);
4724 if (arg_assoc_namespace (k, context))
4727 if (TYPE_BINFO (type))
4729 /* Process baseclasses. */
4730 tree binfo, base_binfo;
4732 for (binfo = TYPE_BINFO (type), i = 0;
4733 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4734 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4738 /* Process friends. */
4739 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4740 list = TREE_CHAIN (list))
4741 if (k->name == FRIEND_NAME (list))
4742 for (friends = FRIEND_DECLS (list); friends;
4743 friends = TREE_CHAIN (friends))
4745 tree fn = TREE_VALUE (friends);
4747 /* Only interested in global functions with potentially hidden
4748 (i.e. unqualified) declarations. */
4749 if (CP_DECL_CONTEXT (fn) != context)
4751 /* Template specializations are never found by name lookup.
4752 (Templates themselves can be found, but not template
4753 specializations.) */
4754 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4756 if (add_function (k, fn))
4760 /* Process template arguments. */
4761 if (CLASSTYPE_TEMPLATE_INFO (type)
4762 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4764 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4765 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4766 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4772 /* Adds everything associated with a given type.
4773 Returns 1 on error. */
4776 arg_assoc_type (struct arg_lookup *k, tree type)
4778 /* As we do not get the type of non-type dependent expressions
4779 right, we can end up with such things without a type. */
4783 if (TYPE_PTRMEM_P (type))
4785 /* Pointer to member: associate class type and value type. */
4786 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4788 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4790 else switch (TREE_CODE (type))
4800 case FIXED_POINT_TYPE:
4804 if (TYPE_PTRMEMFUNC_P (type))
4805 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4806 return arg_assoc_class (k, type);
4808 case REFERENCE_TYPE:
4810 return arg_assoc_type (k, TREE_TYPE (type));
4813 return arg_assoc_namespace (k, decl_namespace_context (type));
4815 /* The basetype is referenced in the first arg type, so just
4818 /* Associate the parameter types. */
4819 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4821 /* Associate the return type. */
4822 return arg_assoc_type (k, TREE_TYPE (type));
4823 case TEMPLATE_TYPE_PARM:
4824 case BOUND_TEMPLATE_TEMPLATE_PARM:
4829 gcc_assert (type == unknown_type_node
4830 || type == init_list_type_node);
4832 case TYPE_PACK_EXPANSION:
4833 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4841 /* Adds everything associated with arguments. Returns true on error. */
4844 arg_assoc_args (struct arg_lookup *k, tree args)
4846 for (; args; args = TREE_CHAIN (args))
4847 if (arg_assoc (k, TREE_VALUE (args)))
4852 /* Adds everything associated with an argument vector. Returns true
4856 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
4861 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
4862 if (arg_assoc (k, arg))
4867 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4870 arg_assoc (struct arg_lookup *k, tree n)
4872 if (n == error_mark_node)
4876 return arg_assoc_type (k, n);
4878 if (! type_unknown_p (n))
4879 return arg_assoc_type (k, TREE_TYPE (n));
4881 if (TREE_CODE (n) == ADDR_EXPR)
4882 n = TREE_OPERAND (n, 0);
4883 if (TREE_CODE (n) == COMPONENT_REF)
4884 n = TREE_OPERAND (n, 1);
4885 if (TREE_CODE (n) == OFFSET_REF)
4886 n = TREE_OPERAND (n, 1);
4887 while (TREE_CODE (n) == TREE_LIST)
4889 if (TREE_CODE (n) == BASELINK)
4890 n = BASELINK_FUNCTIONS (n);
4892 if (TREE_CODE (n) == FUNCTION_DECL)
4893 return arg_assoc_type (k, TREE_TYPE (n));
4894 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4896 /* [basic.lookup.koenig]
4898 If T is a template-id, its associated namespaces and classes
4899 are the namespace in which the template is defined; for
4900 member templates, the member template's class... */
4901 tree templ = TREE_OPERAND (n, 0);
4902 tree args = TREE_OPERAND (n, 1);
4906 if (TREE_CODE (templ) == COMPONENT_REF)
4907 templ = TREE_OPERAND (templ, 1);
4909 /* First, the template. There may actually be more than one if
4910 this is an overloaded function template. But, in that case,
4911 we only need the first; all the functions will be in the same
4913 templ = OVL_CURRENT (templ);
4915 ctx = CP_DECL_CONTEXT (templ);
4917 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4919 if (arg_assoc_namespace (k, ctx) == 1)
4922 /* It must be a member template. */
4923 else if (arg_assoc_class (k, ctx) == 1)
4926 /* Now the arguments. */
4928 for (ix = TREE_VEC_LENGTH (args); ix--;)
4929 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4932 else if (TREE_CODE (n) == OVERLOAD)
4934 for (; n; n = OVL_CHAIN (n))
4935 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4942 /* Performs Koenig lookup depending on arguments, where fns
4943 are the functions found in normal lookup. */
4946 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args)
4948 struct arg_lookup k;
4950 timevar_push (TV_NAME_LOOKUP);
4952 /* Remove any hidden friend functions from the list of functions
4953 found so far. They will be added back by arg_assoc_class as
4955 fns = remove_hidden_names (fns);
4960 k.classes = NULL_TREE;
4962 /* We previously performed an optimization here by setting
4963 NAMESPACES to the current namespace when it was safe. However, DR
4964 164 says that namespaces that were already searched in the first
4965 stage of template processing are searched again (potentially
4966 picking up later definitions) in the second stage. */
4967 k.namespaces = NULL_TREE;
4969 arg_assoc_args_vec (&k, args);
4974 && TREE_CODE (fns) != VAR_DECL
4975 && !is_overloaded_fn (fns))
4977 error ("argument dependent lookup finds %q+D", fns);
4978 error (" in call to %qD", name);
4979 fns = error_mark_node;
4982 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4985 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4986 changed (i.e. there was already a directive), or the fresh
4987 TREE_LIST otherwise. */
4990 push_using_directive (tree used)
4992 tree ud = current_binding_level->using_directives;
4993 tree iter, ancestor;
4995 timevar_push (TV_NAME_LOOKUP);
4996 /* Check if we already have this. */
4997 if (purpose_member (used, ud) != NULL_TREE)
4998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5000 ancestor = namespace_ancestor (current_decl_namespace (), used);
5001 ud = current_binding_level->using_directives;
5002 ud = tree_cons (used, ancestor, ud);
5003 current_binding_level->using_directives = ud;
5005 /* Recursively add all namespaces used. */
5006 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5007 push_using_directive (TREE_PURPOSE (iter));
5009 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
5012 /* The type TYPE is being declared. If it is a class template, or a
5013 specialization of a class template, do any processing required and
5014 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5015 being declared a friend. B is the binding level at which this TYPE
5018 Returns the TYPE_DECL for TYPE, which may have been altered by this
5022 maybe_process_template_type_declaration (tree type, int is_friend,
5025 tree decl = TYPE_NAME (type);
5027 if (processing_template_parmlist)
5028 /* You can't declare a new template type in a template parameter
5029 list. But, you can declare a non-template type:
5031 template <class A*> struct S;
5033 is a forward-declaration of `A'. */
5035 else if (b->kind == sk_namespace
5036 && current_binding_level->kind != sk_namespace)
5037 /* If this new type is being injected into a containing scope,
5038 then it's not a template type. */
5042 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5043 || TREE_CODE (type) == ENUMERAL_TYPE);
5045 if (processing_template_decl)
5047 /* This may change after the call to
5048 push_template_decl_real, but we want the original value. */
5049 tree name = DECL_NAME (decl);
5051 decl = push_template_decl_real (decl, is_friend);
5052 if (decl == error_mark_node)
5053 return error_mark_node;
5055 /* If the current binding level is the binding level for the
5056 template parameters (see the comment in
5057 begin_template_parm_list) and the enclosing level is a class
5058 scope, and we're not looking at a friend, push the
5059 declaration of the member class into the class scope. In the
5060 friend case, push_template_decl will already have put the
5061 friend into global scope, if appropriate. */
5062 if (TREE_CODE (type) != ENUMERAL_TYPE
5063 && !is_friend && b->kind == sk_template_parms
5064 && b->level_chain->kind == sk_class)
5066 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5068 if (!COMPLETE_TYPE_P (current_class_type))
5070 maybe_add_class_template_decl_list (current_class_type,
5071 type, /*friend_p=*/0);
5072 /* Put this UTD in the table of UTDs for the class. */
5073 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5074 CLASSTYPE_NESTED_UTDS (current_class_type) =
5075 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5077 binding_table_insert
5078 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5087 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5088 that the NAME is a class template, the tag is processed but not pushed.
5090 The pushed scope depend on the SCOPE parameter:
5091 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5093 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5094 non-template-parameter scope. This case is needed for forward
5096 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5097 TS_GLOBAL case except that names within template-parameter scopes
5098 are not pushed at all.
5100 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5103 pushtag (tree name, tree type, tag_scope scope)
5105 struct cp_binding_level *b;
5108 timevar_push (TV_NAME_LOOKUP);
5109 b = current_binding_level;
5110 while (/* Cleanup scopes are not scopes from the point of view of
5112 b->kind == sk_cleanup
5113 /* Neither are function parameter scopes. */
5114 || b->kind == sk_function_parms
5115 /* Neither are the scopes used to hold template parameters
5116 for an explicit specialization. For an ordinary template
5117 declaration, these scopes are not scopes from the point of
5118 view of the language. */
5119 || (b->kind == sk_template_parms
5120 && (b->explicit_spec_p || scope == ts_global))
5121 || (b->kind == sk_class
5122 && (scope != ts_current
5123 /* We may be defining a new type in the initializer
5124 of a static member variable. We allow this when
5125 not pedantic, and it is particularly useful for
5126 type punning via an anonymous union. */
5127 || COMPLETE_TYPE_P (b->this_entity))))
5130 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5132 /* Do C++ gratuitous typedefing. */
5133 if (IDENTIFIER_TYPE_VALUE (name) != type)
5137 tree context = TYPE_CONTEXT (type);
5141 tree cs = current_scope ();
5143 if (scope == ts_current
5144 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5146 else if (cs != NULL_TREE && TYPE_P (cs))
5147 /* When declaring a friend class of a local class, we want
5148 to inject the newly named class into the scope
5149 containing the local class, not the namespace
5151 context = decl_function_context (get_type_decl (cs));
5154 context = current_namespace;
5156 if (b->kind == sk_class
5157 || (b->kind == sk_template_parms
5158 && b->level_chain->kind == sk_class))
5161 if (current_lang_name == lang_name_java)
5162 TYPE_FOR_JAVA (type) = 1;
5164 tdef = create_implicit_typedef (name, type);
5165 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5166 if (scope == ts_within_enclosing_non_class)
5168 /* This is a friend. Make this TYPE_DECL node hidden from
5169 ordinary name lookup. Its corresponding TEMPLATE_DECL
5170 will be marked in push_template_decl_real. */
5171 retrofit_lang_decl (tdef);
5172 DECL_ANTICIPATED (tdef) = 1;
5173 DECL_FRIEND_P (tdef) = 1;
5176 decl = maybe_process_template_type_declaration
5177 (type, scope == ts_within_enclosing_non_class, b);
5178 if (decl == error_mark_node)
5179 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5181 if (b->kind == sk_class)
5183 if (!TYPE_BEING_DEFINED (current_class_type))
5184 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5186 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5187 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5188 class. But if it's a member template class, we want
5189 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5191 finish_member_declaration (decl);
5193 pushdecl_class_level (decl);
5195 else if (b->kind != sk_template_parms)
5197 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5198 if (decl == error_mark_node)
5199 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5203 set_identifier_type_value_with_scope (name, tdef, b);
5205 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5207 /* If this is a local class, keep track of it. We need this
5208 information for name-mangling, and so that it is possible to
5209 find all function definitions in a translation unit in a
5210 convenient way. (It's otherwise tricky to find a member
5211 function definition it's only pointed to from within a local
5213 if (TYPE_CONTEXT (type)
5214 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5215 VEC_safe_push (tree, gc, local_classes, type);
5217 if (b->kind == sk_class
5218 && !COMPLETE_TYPE_P (current_class_type))
5220 maybe_add_class_template_decl_list (current_class_type,
5221 type, /*friend_p=*/0);
5223 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5224 CLASSTYPE_NESTED_UTDS (current_class_type)
5225 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5227 binding_table_insert
5228 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5231 decl = TYPE_NAME (type);
5232 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5233 TYPE_STUB_DECL (type) = decl;
5235 /* Set type visibility now if this is a forward declaration. */
5236 TREE_PUBLIC (decl) = 1;
5237 determine_visibility (decl);
5239 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5242 /* Subroutines for reverting temporarily to top-level for instantiation
5243 of templates and such. We actually need to clear out the class- and
5244 local-value slots of all identifiers, so that only the global values
5245 are at all visible. Simply setting current_binding_level to the global
5246 scope isn't enough, because more binding levels may be pushed. */
5247 struct saved_scope *scope_chain;
5249 /* If ID has not already been marked, add an appropriate binding to
5253 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5255 cxx_saved_binding *saved;
5257 if (!id || !IDENTIFIER_BINDING (id))
5260 if (IDENTIFIER_MARKED (id))
5263 IDENTIFIER_MARKED (id) = 1;
5265 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5266 saved->identifier = id;
5267 saved->binding = IDENTIFIER_BINDING (id);
5268 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5269 IDENTIFIER_BINDING (id) = NULL;
5273 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5277 timevar_push (TV_NAME_LOOKUP);
5278 for (t = names; t; t = TREE_CHAIN (t))
5282 if (TREE_CODE (t) == TREE_LIST)
5283 id = TREE_PURPOSE (t);
5287 store_binding (id, old_bindings);
5289 timevar_pop (TV_NAME_LOOKUP);
5292 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5293 objects, rather than a TREE_LIST. */
5296 store_class_bindings (VEC(cp_class_binding,gc) *names,
5297 VEC(cxx_saved_binding,gc) **old_bindings)
5300 cp_class_binding *cb;
5302 timevar_push (TV_NAME_LOOKUP);
5303 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5304 store_binding (cb->identifier, old_bindings);
5305 timevar_pop (TV_NAME_LOOKUP);
5309 push_to_top_level (void)
5311 struct saved_scope *s;
5312 struct cp_binding_level *b;
5313 cxx_saved_binding *sb;
5317 timevar_push (TV_NAME_LOOKUP);
5318 s = GGC_CNEW (struct saved_scope);
5320 b = scope_chain ? current_binding_level : 0;
5322 /* If we're in the middle of some function, save our state. */
5326 push_function_context ();
5331 if (scope_chain && previous_class_level)
5332 store_class_bindings (previous_class_level->class_shadowed,
5335 /* Have to include the global scope, because class-scope decls
5336 aren't listed anywhere useful. */
5337 for (; b; b = b->level_chain)
5341 /* Template IDs are inserted into the global level. If they were
5342 inserted into namespace level, finish_file wouldn't find them
5343 when doing pending instantiations. Therefore, don't stop at
5344 namespace level, but continue until :: . */
5345 if (global_scope_p (b))
5348 store_bindings (b->names, &s->old_bindings);
5349 /* We also need to check class_shadowed to save class-level type
5350 bindings, since pushclass doesn't fill in b->names. */
5351 if (b->kind == sk_class)
5352 store_class_bindings (b->class_shadowed, &s->old_bindings);
5354 /* Unwind type-value slots back to top level. */
5355 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5356 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5359 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5360 IDENTIFIER_MARKED (sb->identifier) = 0;
5362 s->prev = scope_chain;
5364 s->need_pop_function_context = need_pop;
5365 s->function_decl = current_function_decl;
5366 s->unevaluated_operand = cp_unevaluated_operand;
5367 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5370 current_function_decl = NULL_TREE;
5371 current_lang_base = VEC_alloc (tree, gc, 10);
5372 current_lang_name = lang_name_cplusplus;
5373 current_namespace = global_namespace;
5374 push_class_stack ();
5375 cp_unevaluated_operand = 0;
5376 c_inhibit_evaluation_warnings = 0;
5377 timevar_pop (TV_NAME_LOOKUP);
5381 pop_from_top_level (void)
5383 struct saved_scope *s = scope_chain;
5384 cxx_saved_binding *saved;
5387 timevar_push (TV_NAME_LOOKUP);
5388 /* Clear out class-level bindings cache. */
5389 if (previous_class_level)
5390 invalidate_class_lookup_cache ();
5393 current_lang_base = 0;
5395 scope_chain = s->prev;
5396 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5398 tree id = saved->identifier;
5400 IDENTIFIER_BINDING (id) = saved->binding;
5401 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5404 /* If we were in the middle of compiling a function, restore our
5406 if (s->need_pop_function_context)
5407 pop_function_context ();
5408 current_function_decl = s->function_decl;
5409 cp_unevaluated_operand = s->unevaluated_operand;
5410 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5411 timevar_pop (TV_NAME_LOOKUP);
5414 /* Pop off extraneous binding levels left over due to syntax errors.
5416 We don't pop past namespaces, as they might be valid. */
5419 pop_everything (void)
5421 if (ENABLE_SCOPE_CHECKING)
5422 verbatim ("XXX entering pop_everything ()\n");
5423 while (!toplevel_bindings_p ())
5425 if (current_binding_level->kind == sk_class)
5426 pop_nested_class ();
5430 if (ENABLE_SCOPE_CHECKING)
5431 verbatim ("XXX leaving pop_everything ()\n");
5434 /* Emit debugging information for using declarations and directives.
5435 If input tree is overloaded fn then emit debug info for all
5439 cp_emit_debug_info_for_using (tree t, tree context)
5441 /* Don't try to emit any debug information if we have errors. */
5442 if (sorrycount || errorcount)
5445 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5446 of a builtin function. */
5447 if (TREE_CODE (t) == FUNCTION_DECL
5448 && DECL_EXTERNAL (t)
5449 && DECL_BUILT_IN (t))
5452 /* Do not supply context to imported_module_or_decl, if
5453 it is a global namespace. */
5454 if (context == global_namespace)
5455 context = NULL_TREE;
5458 t = BASELINK_FUNCTIONS (t);
5460 /* FIXME: Handle TEMPLATE_DECLs. */
5461 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5462 if (TREE_CODE (t) != TEMPLATE_DECL)
5464 if (building_stmt_tree ())
5465 add_stmt (build_stmt (input_location, USING_STMT, t));
5467 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5471 #include "gt-cp-name-lookup.h"