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 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73 anonymous_namespace_name = get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable)) binding_entry free_binding_entry = NULL;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name, tree type)
99 if (free_binding_entry)
101 entry = free_binding_entry;
102 free_binding_entry = entry->chain;
105 entry = GGC_NEW (struct binding_entry_s);
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry)
121 entry->chain = free_binding_entry;
122 free_binding_entry = entry;
126 /* The datatype used to implement the mapping from names to types at
128 struct binding_table_s GTY(())
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = GGC_NEW (struct binding_table_s);
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = GGC_NEW (cxx_binding);
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 if (VEC_length (cp_class_binding, scope->class_shadowed))
324 cp_class_binding *old_base;
325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
328 /* Fixup the current bindings, as they might have moved. */
332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
336 b = &IDENTIFIER_BINDING (cb->identifier);
337 while (*b != &old_base[i].base)
338 b = &((*b)->previous);
342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
347 cb->identifier = name;
349 binding->scope = scope;
350 cxx_binding_init (binding, value, type);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id, tree decl, cxx_scope* level)
360 cxx_binding *binding;
362 if (level != class_binding_level)
364 binding = cxx_binding_make (decl, NULL_TREE);
365 binding->scope = level;
368 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
370 /* Now, fill in the binding information. */
371 binding->previous = IDENTIFIER_BINDING (id);
372 INHERITED_VALUE_BINDING_P (binding) = 0;
373 LOCAL_BINDING_P (binding) = (level != class_binding_level);
375 /* And put it on the front of the list of bindings for ID. */
376 IDENTIFIER_BINDING (id) = binding;
379 /* Remove the binding for DECL which should be the innermost binding
383 pop_binding (tree id, tree decl)
385 cxx_binding *binding;
388 /* It's easiest to write the loops that call this function without
389 checking whether or not the entities involved have names. We
390 get here for such an entity. */
393 /* Get the innermost binding for ID. */
394 binding = IDENTIFIER_BINDING (id);
396 /* The name should be bound. */
397 gcc_assert (binding != NULL);
399 /* The DECL will be either the ordinary binding or the type
400 binding for this identifier. Remove that binding. */
401 if (binding->value == decl)
402 binding->value = NULL_TREE;
405 gcc_assert (binding->type == decl);
406 binding->type = NULL_TREE;
409 if (!binding->value && !binding->type)
411 /* We're completely done with the innermost binding for this
412 identifier. Unhook it from the list of bindings. */
413 IDENTIFIER_BINDING (id) = binding->previous;
415 /* Add it to the free list. */
416 cxx_binding_free (binding);
420 /* BINDING records an existing declaration for a name in the current scope.
421 But, DECL is another declaration for that same identifier in the
422 same scope. This is the `struct stat' hack whereby a non-typedef
423 class name or enum-name can be bound at the same level as some other
427 A class name (9.1) or enumeration name (7.2) can be hidden by the
428 name of an object, function, or enumerator declared in the same scope.
429 If a class or enumeration name and an object, function, or enumerator
430 are declared in the same scope (in any order) with the same name, the
431 class or enumeration name is hidden wherever the object, function, or
432 enumerator name is visible.
434 It's the responsibility of the caller to check that
435 inserting this name is valid here. Returns nonzero if the new binding
439 supplement_binding (cxx_binding *binding, tree decl)
441 tree bval = binding->value;
444 timevar_push (TV_NAME_LOOKUP);
445 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
446 /* The new name is the type name. */
447 binding->type = decl;
448 else if (/* BVAL is null when push_class_level_binding moves an
449 inherited type-binding out of the way to make room for a
450 new value binding. */
452 /* BVAL is error_mark_node when DECL's name has been used
453 in a non-class scope prior declaration. In that case,
454 we should have already issued a diagnostic; for graceful
455 error recovery purpose, pretend this was the intended
456 declaration for that name. */
457 || bval == error_mark_node
458 /* If BVAL is anticipated but has not yet been declared,
459 pretend it is not there at all. */
460 || (TREE_CODE (bval) == FUNCTION_DECL
461 && DECL_ANTICIPATED (bval)
462 && !DECL_HIDDEN_FRIEND_P (bval)))
463 binding->value = decl;
464 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
466 /* The old binding was a type name. It was placed in
467 VALUE field because it was thought, at the point it was
468 declared, to be the only entity with such a name. Move the
469 type name into the type slot; it is now hidden by the new
471 binding->type = bval;
472 binding->value = decl;
473 binding->value_is_inherited = false;
475 else if (TREE_CODE (bval) == TYPE_DECL
476 && TREE_CODE (decl) == TYPE_DECL
477 && DECL_NAME (decl) == DECL_NAME (bval)
478 && binding->scope->kind != sk_class
479 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
480 /* If either type involves template parameters, we must
481 wait until instantiation. */
482 || uses_template_parms (TREE_TYPE (decl))
483 || uses_template_parms (TREE_TYPE (bval))))
484 /* We have two typedef-names, both naming the same type to have
485 the same name. In general, this is OK because of:
489 In a given scope, a typedef specifier can be used to redefine
490 the name of any type declared in that scope to refer to the
491 type to which it already refers.
493 However, in class scopes, this rule does not apply due to the
494 stricter language in [class.mem] prohibiting redeclarations of
497 /* There can be two block-scope declarations of the same variable,
498 so long as they are `extern' declarations. However, there cannot
499 be two declarations of the same static data member:
503 A member shall not be declared twice in the
504 member-specification. */
505 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
506 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
507 && !DECL_CLASS_SCOPE_P (decl))
509 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
512 else if (TREE_CODE (decl) == NAMESPACE_DECL
513 && TREE_CODE (bval) == NAMESPACE_DECL
514 && DECL_NAMESPACE_ALIAS (decl)
515 && DECL_NAMESPACE_ALIAS (bval)
516 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
519 In a declarative region, a namespace-alias-definition can be
520 used to redefine a namespace-alias declared in that declarative
521 region to refer only to the namespace to which it already
526 error ("declaration of %q#D", decl);
527 error ("conflicts with previous declaration %q+#D", bval);
531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
534 /* Add DECL to the list of things declared in B. */
537 add_decl_to_level (tree decl, cxx_scope *b)
539 /* We used to record virtual tables as if they were ordinary
540 variables, but no longer do so. */
541 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
543 if (TREE_CODE (decl) == NAMESPACE_DECL
544 && !DECL_NAMESPACE_ALIAS (decl))
546 TREE_CHAIN (decl) = b->namespaces;
547 b->namespaces = decl;
551 /* We build up the list in reverse order, and reverse it later if
553 TREE_CHAIN (decl) = b->names;
557 /* If appropriate, add decl to separate list of statics. We
558 include extern variables because they might turn out to be
559 static later. It's OK for this list to contain a few false
561 if (b->kind == sk_namespace)
562 if ((TREE_CODE (decl) == VAR_DECL
563 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
564 || (TREE_CODE (decl) == FUNCTION_DECL
565 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
566 VEC_safe_push (tree, gc, b->static_decls, decl);
570 /* Record a decl-node X as belonging to the current lexical scope.
571 Check for errors (such as an incompatible declaration for the same
572 name already seen in the same scope). IS_FRIEND is true if X is
573 declared as a friend.
575 Returns either X or an old decl for the same name.
576 If an old decl is returned, it may have been smashed
577 to agree with what X says. */
580 pushdecl_maybe_friend (tree x, bool is_friend)
584 int need_new_binding;
586 timevar_push (TV_NAME_LOOKUP);
588 if (x == error_mark_node)
589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
591 need_new_binding = 1;
593 if (DECL_TEMPLATE_PARM_P (x))
594 /* Template parameters have no context; they are not X::T even
595 when declared within a class or namespace. */
599 if (current_function_decl && x != current_function_decl
600 /* A local declaration for a function doesn't constitute
602 && TREE_CODE (x) != FUNCTION_DECL
603 /* A local declaration for an `extern' variable is in the
604 scope of the current namespace, not the current
606 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
607 /* When parsing the parameter list of a function declarator,
608 don't set DECL_CONTEXT to an enclosing function. When we
609 push the PARM_DECLs in order to process the function body,
610 current_binding_level->this_entity will be set. */
611 && !(TREE_CODE (x) == PARM_DECL
612 && current_binding_level->kind == sk_function_parms
613 && current_binding_level->this_entity == NULL)
614 && !DECL_CONTEXT (x))
615 DECL_CONTEXT (x) = current_function_decl;
617 /* If this is the declaration for a namespace-scope function,
618 but the declaration itself is in a local scope, mark the
620 if (TREE_CODE (x) == FUNCTION_DECL
621 && DECL_NAMESPACE_SCOPE_P (x)
622 && current_function_decl
623 && x != current_function_decl)
624 DECL_LOCAL_FUNCTION_P (x) = 1;
627 name = DECL_NAME (x);
630 int different_binding_level = 0;
632 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
633 name = TREE_OPERAND (name, 0);
635 /* In case this decl was explicitly namespace-qualified, look it
636 up in its namespace context. */
637 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
638 t = namespace_binding (name, DECL_CONTEXT (x));
640 t = lookup_name_innermost_nonclass_level (name);
642 /* [basic.link] If there is a visible declaration of an entity
643 with linkage having the same name and type, ignoring entities
644 declared outside the innermost enclosing namespace scope, the
645 block scope declaration declares that same entity and
646 receives the linkage of the previous declaration. */
647 if (! t && current_function_decl && x != current_function_decl
648 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
649 && DECL_EXTERNAL (x))
651 /* Look in block scope. */
652 t = innermost_non_namespace_value (name);
653 /* Or in the innermost namespace. */
655 t = namespace_binding (name, DECL_CONTEXT (x));
656 /* Does it have linkage? Note that if this isn't a DECL, it's an
657 OVERLOAD, which is OK. */
658 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
661 different_binding_level = 1;
664 /* If we are declaring a function, and the result of name-lookup
665 was an OVERLOAD, look for an overloaded instance that is
666 actually the same as the function we are declaring. (If
667 there is one, we have to merge our declaration with the
668 previous declaration.) */
669 if (t && TREE_CODE (t) == OVERLOAD)
673 if (TREE_CODE (x) == FUNCTION_DECL)
674 for (match = t; match; match = OVL_NEXT (match))
676 if (decls_match (OVL_CURRENT (match), x))
680 /* Just choose one. */
684 t = OVL_CURRENT (match);
689 if (t && t != error_mark_node)
691 if (different_binding_level)
693 if (decls_match (x, t))
694 /* The standard only says that the local extern
695 inherits linkage from the previous decl; in
696 particular, default args are not shared. Add
697 the decl into a hash table to make sure only
698 the previous decl in this case is seen by the
701 struct cxx_int_tree_map *h;
704 TREE_PUBLIC (x) = TREE_PUBLIC (t);
706 if (cp_function_chain->extern_decl_map == NULL)
707 cp_function_chain->extern_decl_map
708 = htab_create_ggc (20, cxx_int_tree_map_hash,
709 cxx_int_tree_map_eq, NULL);
711 h = GGC_NEW (struct cxx_int_tree_map);
712 h->uid = DECL_UID (x);
714 loc = htab_find_slot_with_hash
715 (cp_function_chain->extern_decl_map, h,
717 *(struct cxx_int_tree_map **) loc = h;
720 else if (TREE_CODE (t) == PARM_DECL)
722 /* Check for duplicate params. */
723 tree d = duplicate_decls (x, t, is_friend);
725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
727 else if ((DECL_EXTERN_C_FUNCTION_P (x)
728 || DECL_FUNCTION_TEMPLATE_P (x))
729 && is_overloaded_fn (t))
730 /* Don't do anything just yet. */;
731 else if (t == wchar_decl_node)
733 if (! DECL_IN_SYSTEM_HEADER (x))
734 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
737 /* Throw away the redeclaration. */
738 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
742 tree olddecl = duplicate_decls (x, t, is_friend);
744 /* If the redeclaration failed, we can stop at this
746 if (olddecl == error_mark_node)
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
751 if (TREE_CODE (t) == TYPE_DECL)
752 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
756 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
758 /* A redeclaration of main, but not a duplicate of the
763 This function shall not be overloaded. */
764 error ("invalid redeclaration of %q+D", t);
766 /* We don't try to push this declaration since that
768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
773 /* If x has C linkage-specification, (extern "C"),
774 lookup its binding, in case it's already bound to an object.
775 The lookup is done in all namespaces.
776 If we find an existing binding, make sure it has the same
777 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
778 if ((TREE_CODE (x) == FUNCTION_DECL)
779 && DECL_EXTERN_C_P (x)
780 /* We should ignore declarations happening in system headers. */
781 && !DECL_IN_SYSTEM_HEADER (x))
783 cxx_binding *function_binding =
784 lookup_extern_c_fun_binding_in_all_ns (x);
786 && !DECL_IN_SYSTEM_HEADER (function_binding->value))
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);
816 check_template_shadow (x);
818 /* If this is a function conjured up by the back end, massage it
819 so it looks friendly. */
820 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
822 retrofit_lang_decl (x);
823 SET_DECL_LANGUAGE (x, lang_c);
827 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
829 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
830 if (!namespace_bindings_p ())
831 /* We do not need to create a binding for this name;
832 push_overloaded_decl will have already done so if
834 need_new_binding = 0;
836 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
838 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
840 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
843 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
844 check_default_args (x);
846 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
849 /* If declaring a type as a typedef, copy the type (unless we're
850 at line 0), and install this TYPE_DECL as the new type's typedef
851 name. See the extensive comment in ../c-decl.c (pushdecl). */
852 if (TREE_CODE (x) == TYPE_DECL)
854 tree type = TREE_TYPE (x);
855 if (DECL_IS_BUILTIN (x))
857 if (TYPE_NAME (type) == 0)
858 TYPE_NAME (type) = x;
860 else if (type != error_mark_node && TYPE_NAME (type) != x
861 /* We don't want to copy the type when all we're
862 doing is making a TYPE_DECL for the purposes of
864 && (!TYPE_NAME (type)
865 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
867 DECL_ORIGINAL_TYPE (x) = type;
868 type = build_variant_type_copy (type);
869 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
870 TYPE_NAME (type) = x;
871 TREE_TYPE (x) = type;
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 /* Warn if shadowing an argument at the top level of the body. */
1006 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1007 /* Inline decls shadow nothing. */
1008 && !DECL_FROM_INLINE (x)
1009 && TREE_CODE (oldlocal) == PARM_DECL
1010 /* Don't check the `this' parameter. */
1011 && !DECL_ARTIFICIAL (oldlocal))
1015 /* Don't complain if it's from an enclosing function. */
1016 if (DECL_CONTEXT (oldlocal) == current_function_decl
1017 && TREE_CODE (x) != PARM_DECL)
1019 /* Go to where the parms should be and see if we find
1021 struct cp_binding_level *b = current_binding_level->level_chain;
1023 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1024 /* Skip the ctor/dtor cleanup level. */
1028 if (b->kind == sk_function_parms)
1030 error ("declaration of %q#D shadows a parameter", x);
1035 if (warn_shadow && !err
1036 /* Don't complain about the parms we push and then pop
1037 while tentatively parsing a function declarator. */
1038 && !(TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE))
1040 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
1041 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1045 /* Maybe warn if shadowing something else. */
1046 else if (warn_shadow && !DECL_EXTERNAL (x)
1047 /* No shadow warnings for internally generated vars. */
1048 && ! DECL_ARTIFICIAL (x)
1049 /* No shadow warnings for vars made for inlining. */
1050 && ! DECL_FROM_INLINE (x))
1054 if (current_class_ptr)
1055 member = lookup_member (current_class_type,
1058 /*want_type=*/false);
1062 if (member && !TREE_STATIC (member))
1064 /* Location of previous decl is not useful in this case. */
1065 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1068 else if (oldlocal != NULL_TREE
1069 && TREE_CODE (oldlocal) == VAR_DECL)
1071 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1072 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1074 else if (oldglobal != NULL_TREE
1075 && TREE_CODE (oldglobal) == VAR_DECL)
1076 /* XXX shadow warnings in outer-more namespaces */
1078 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1080 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1085 if (TREE_CODE (x) == VAR_DECL)
1086 maybe_register_incomplete_var (x);
1089 if (need_new_binding)
1090 add_decl_to_level (x,
1091 DECL_NAMESPACE_SCOPE_P (x)
1092 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1093 : current_binding_level);
1095 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1098 /* Record a decl-node X as belonging to the current lexical scope. */
1103 return pushdecl_maybe_friend (x, false);
1106 /* Enter DECL into the symbol table, if that's appropriate. Returns
1107 DECL, or a modified version thereof. */
1110 maybe_push_decl (tree decl)
1112 tree type = TREE_TYPE (decl);
1114 /* Add this decl to the current binding level, but not if it comes
1115 from another scope, e.g. a static member variable. TEM may equal
1116 DECL or it may be a previous decl of the same name. */
1117 if (decl == error_mark_node
1118 || (TREE_CODE (decl) != PARM_DECL
1119 && DECL_CONTEXT (decl) != NULL_TREE
1120 /* Definitions of namespace members outside their namespace are
1122 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1123 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1124 || TREE_CODE (type) == UNKNOWN_TYPE
1125 /* The declaration of a template specialization does not affect
1126 the functions available for overload resolution, so we do not
1128 || (TREE_CODE (decl) == FUNCTION_DECL
1129 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1132 return pushdecl (decl);
1135 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1136 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1137 doesn't really belong to this binding level, that it got here
1138 through a using-declaration. */
1141 push_local_binding (tree id, tree decl, int flags)
1143 struct cp_binding_level *b;
1145 /* Skip over any local classes. This makes sense if we call
1146 push_local_binding with a friend decl of a local class. */
1147 b = innermost_nonclass_level ();
1149 if (lookup_name_innermost_nonclass_level (id))
1151 /* Supplement the existing binding. */
1152 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1153 /* It didn't work. Something else must be bound at this
1154 level. Do not add DECL to the list of things to pop
1159 /* Create a new binding. */
1160 push_binding (id, decl, b);
1162 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1163 /* We must put the OVERLOAD into a TREE_LIST since the
1164 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1165 decls that got here through a using-declaration. */
1166 decl = build_tree_list (NULL_TREE, decl);
1168 /* And put DECL on the list of things declared by the current
1170 add_decl_to_level (decl, b);
1173 /* Check to see whether or not DECL is a variable that would have been
1174 in scope under the ARM, but is not in scope under the ANSI/ISO
1175 standard. If so, issue an error message. If name lookup would
1176 work in both cases, but return a different result, this function
1177 returns the result of ANSI/ISO lookup. Otherwise, it returns
1181 check_for_out_of_scope_variable (tree decl)
1185 /* We only care about out of scope variables. */
1186 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1189 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1190 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1191 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1192 && DECL_DEAD_FOR_LOCAL (shadowed))
1193 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1194 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1196 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1199 if (!DECL_ERROR_REPORTED (decl))
1201 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1202 warning (0, " matches this %q+D under ISO standard rules",
1204 warning (0, " matches this %q+D under old rules", decl);
1205 DECL_ERROR_REPORTED (decl) = 1;
1210 /* If we have already complained about this declaration, there's no
1211 need to do it again. */
1212 if (DECL_ERROR_REPORTED (decl))
1215 DECL_ERROR_REPORTED (decl) = 1;
1217 if (TREE_TYPE (decl) == error_mark_node)
1220 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1222 error ("name lookup of %qD changed for ISO %<for%> scoping",
1224 error (" cannot use obsolete binding at %q+D because "
1225 "it has a destructor", decl);
1226 return error_mark_node;
1230 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1232 if (flag_permissive)
1233 permerror (input_location, " using obsolete binding at %q+D", decl);
1239 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1248 /* true means unconditionally make a BLOCK for the next level pushed. */
1250 static bool keep_next_level_flag;
1252 static int binding_depth = 0;
1253 static int is_class_level = 0;
1260 for (i = 0; i < depth * 2; i++)
1264 /* Return a string describing the kind of SCOPE we have. */
1266 cxx_scope_descriptor (cxx_scope *scope)
1268 /* The order of this table must match the "scope_kind"
1270 static const char* scope_kind_names[] = {
1276 "function-parameter-scope",
1279 "template-parameter-scope",
1280 "template-explicit-spec-scope"
1282 const scope_kind kind = scope->explicit_spec_p
1283 ? sk_template_spec : scope->kind;
1285 return scope_kind_names[kind];
1288 /* Output a debugging information about SCOPE when performing
1291 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1293 const char *desc = cxx_scope_descriptor (scope);
1294 if (scope->this_entity)
1295 verbatim ("%s %s(%E) %p %d\n", action, desc,
1296 scope->this_entity, (void *) scope, line);
1298 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1301 /* Return the estimated initial size of the hashtable of a NAMESPACE
1304 static inline size_t
1305 namespace_scope_ht_size (tree ns)
1307 tree name = DECL_NAME (ns);
1309 return name == std_identifier
1310 ? NAMESPACE_STD_HT_SIZE
1311 : (name == global_scope_name
1312 ? GLOBAL_SCOPE_HT_SIZE
1313 : NAMESPACE_ORDINARY_HT_SIZE);
1316 /* A chain of binding_level structures awaiting reuse. */
1318 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1320 /* Insert SCOPE as the innermost binding level. */
1323 push_binding_level (struct cp_binding_level *scope)
1325 /* Add it to the front of currently active scopes stack. */
1326 scope->level_chain = current_binding_level;
1327 current_binding_level = scope;
1328 keep_next_level_flag = false;
1330 if (ENABLE_SCOPE_CHECKING)
1332 scope->binding_depth = binding_depth;
1333 indent (binding_depth);
1334 cxx_scope_debug (scope, input_line, "push");
1340 /* Create a new KIND scope and make it the top of the active scopes stack.
1341 ENTITY is the scope of the associated C++ entity (namespace, class,
1342 function, C++0x enumeration); it is NULL otherwise. */
1345 begin_scope (scope_kind kind, tree entity)
1349 /* Reuse or create a struct for this binding level. */
1350 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1352 scope = free_binding_level;
1353 memset (scope, 0, sizeof (cxx_scope));
1354 free_binding_level = scope->level_chain;
1357 scope = GGC_CNEW (cxx_scope);
1359 scope->this_entity = entity;
1360 scope->more_cleanups_ok = true;
1367 case sk_template_spec:
1368 scope->explicit_spec_p = true;
1369 kind = sk_template_parms;
1371 case sk_template_parms:
1377 case sk_scoped_enum:
1378 case sk_function_parms:
1380 scope->keep = keep_next_level_flag;
1384 NAMESPACE_LEVEL (entity) = scope;
1385 scope->static_decls =
1386 VEC_alloc (tree, gc,
1387 DECL_NAME (entity) == std_identifier
1388 || DECL_NAME (entity) == global_scope_name
1393 /* Should not happen. */
1399 push_binding_level (scope);
1404 /* We're about to leave current scope. Pop the top of the stack of
1405 currently active scopes. Return the enclosing scope, now active. */
1410 cxx_scope *scope = current_binding_level;
1412 if (scope->kind == sk_namespace && class_binding_level)
1413 current_binding_level = class_binding_level;
1415 /* We cannot leave a scope, if there are none left. */
1416 if (NAMESPACE_LEVEL (global_namespace))
1417 gcc_assert (!global_scope_p (scope));
1419 if (ENABLE_SCOPE_CHECKING)
1421 indent (--binding_depth);
1422 cxx_scope_debug (scope, input_line, "leave");
1423 if (is_class_level != (scope == class_binding_level))
1425 indent (binding_depth);
1426 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1431 /* Move one nesting level up. */
1432 current_binding_level = scope->level_chain;
1434 /* Namespace-scopes are left most probably temporarily, not
1435 completely; they can be reopened later, e.g. in namespace-extension
1436 or any name binding activity that requires us to resume a
1437 namespace. For classes, we cache some binding levels. For other
1438 scopes, we just make the structure available for reuse. */
1439 if (scope->kind != sk_namespace
1440 && scope->kind != sk_class)
1442 scope->level_chain = free_binding_level;
1443 gcc_assert (!ENABLE_SCOPE_CHECKING
1444 || scope->binding_depth == binding_depth);
1445 free_binding_level = scope;
1448 /* Find the innermost enclosing class scope, and reset
1449 CLASS_BINDING_LEVEL appropriately. */
1450 if (scope->kind == sk_class)
1452 class_binding_level = NULL;
1453 for (scope = current_binding_level; scope; scope = scope->level_chain)
1454 if (scope->kind == sk_class)
1456 class_binding_level = scope;
1461 return current_binding_level;
1465 resume_scope (struct cp_binding_level* b)
1467 /* Resuming binding levels is meant only for namespaces,
1468 and those cannot nest into classes. */
1469 gcc_assert (!class_binding_level);
1470 /* Also, resuming a non-directly nested namespace is a no-no. */
1471 gcc_assert (b->level_chain == current_binding_level);
1472 current_binding_level = b;
1473 if (ENABLE_SCOPE_CHECKING)
1475 b->binding_depth = binding_depth;
1476 indent (binding_depth);
1477 cxx_scope_debug (b, input_line, "resume");
1483 /* Return the innermost binding level that is not for a class scope. */
1486 innermost_nonclass_level (void)
1490 b = current_binding_level;
1491 while (b->kind == sk_class)
1497 /* We're defining an object of type TYPE. If it needs a cleanup, but
1498 we're not allowed to add any more objects with cleanups to the current
1499 scope, create a new binding level. */
1502 maybe_push_cleanup_level (tree type)
1504 if (type != error_mark_node
1505 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1506 && current_binding_level->more_cleanups_ok == 0)
1508 begin_scope (sk_cleanup, NULL);
1509 current_binding_level->statement_list = push_stmt_list ();
1513 /* Nonzero if we are currently in the global binding level. */
1516 global_bindings_p (void)
1518 return global_scope_p (current_binding_level);
1521 /* True if we are currently in a toplevel binding level. This
1522 means either the global binding level or a namespace in a toplevel
1523 binding level. Since there are no non-toplevel namespace levels,
1524 this really means any namespace or template parameter level. We
1525 also include a class whose context is toplevel. */
1528 toplevel_bindings_p (void)
1530 struct cp_binding_level *b = innermost_nonclass_level ();
1532 return b->kind == sk_namespace || b->kind == sk_template_parms;
1535 /* True if this is a namespace scope, or if we are defining a class
1536 which is itself at namespace scope, or whose enclosing class is
1537 such a class, etc. */
1540 namespace_bindings_p (void)
1542 struct cp_binding_level *b = innermost_nonclass_level ();
1544 return b->kind == sk_namespace;
1547 /* True if the current level needs to have a BLOCK made. */
1552 return (current_binding_level->blocks != NULL_TREE
1553 || current_binding_level->keep
1554 || current_binding_level->kind == sk_cleanup
1555 || current_binding_level->names != NULL_TREE
1556 || current_binding_level->using_directives);
1559 /* Returns the kind of the innermost scope. */
1562 innermost_scope_kind (void)
1564 return current_binding_level->kind;
1567 /* Returns true if this scope was created to store template parameters. */
1570 template_parm_scope_p (void)
1572 return innermost_scope_kind () == sk_template_parms;
1575 /* If KEEP is true, make a BLOCK node for the next binding level,
1576 unconditionally. Otherwise, use the normal logic to decide whether
1577 or not to create a BLOCK. */
1580 keep_next_level (bool keep)
1582 keep_next_level_flag = keep;
1585 /* Return the list of declarations of the current level.
1586 Note that this list is in reverse order unless/until
1587 you nreverse it; and when you do nreverse it, you must
1588 store the result back using `storedecls' or you will lose. */
1593 return current_binding_level->names;
1596 /* For debugging. */
1597 static int no_print_functions = 0;
1598 static int no_print_builtins = 0;
1601 print_binding_level (struct cp_binding_level* lvl)
1605 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1606 if (lvl->more_cleanups_ok)
1607 fprintf (stderr, " more-cleanups-ok");
1608 if (lvl->have_cleanups)
1609 fprintf (stderr, " have-cleanups");
1610 fprintf (stderr, "\n");
1613 fprintf (stderr, " names:\t");
1614 /* We can probably fit 3 names to a line? */
1615 for (t = lvl->names; t; t = TREE_CHAIN (t))
1617 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1619 if (no_print_builtins
1620 && (TREE_CODE (t) == TYPE_DECL)
1621 && DECL_IS_BUILTIN (t))
1624 /* Function decls tend to have longer names. */
1625 if (TREE_CODE (t) == FUNCTION_DECL)
1632 fprintf (stderr, "\n\t");
1635 print_node_brief (stderr, "", t, 0);
1636 if (t == error_mark_node)
1640 fprintf (stderr, "\n");
1642 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1645 cp_class_binding *b;
1646 fprintf (stderr, " class-shadowed:");
1648 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1650 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1651 fprintf (stderr, "\n");
1653 if (lvl->type_shadowed)
1655 fprintf (stderr, " type-shadowed:");
1656 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1658 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1660 fprintf (stderr, "\n");
1665 print_other_binding_stack (struct cp_binding_level *stack)
1667 struct cp_binding_level *level;
1668 for (level = stack; !global_scope_p (level); level = level->level_chain)
1670 fprintf (stderr, "binding level %p\n", (void *) level);
1671 print_binding_level (level);
1676 print_binding_stack (void)
1678 struct cp_binding_level *b;
1679 fprintf (stderr, "current_binding_level=%p\n"
1680 "class_binding_level=%p\n"
1681 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1682 (void *) current_binding_level, (void *) class_binding_level,
1683 (void *) NAMESPACE_LEVEL (global_namespace));
1684 if (class_binding_level)
1686 for (b = class_binding_level; b; b = b->level_chain)
1687 if (b == current_binding_level)
1690 b = class_binding_level;
1692 b = current_binding_level;
1695 b = current_binding_level;
1696 print_other_binding_stack (b);
1697 fprintf (stderr, "global:\n");
1698 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1701 /* Return the type associated with id. */
1704 identifier_type_value (tree id)
1706 timevar_push (TV_NAME_LOOKUP);
1707 /* There is no type with that name, anywhere. */
1708 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1709 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1710 /* This is not the type marker, but the real thing. */
1711 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1712 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1713 /* Have to search for it. It must be on the global level, now.
1714 Ask lookup_name not to return non-types. */
1715 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1721 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1722 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1725 identifier_global_value (tree t)
1727 return IDENTIFIER_GLOBAL_VALUE (t);
1730 /* Push a definition of struct, union or enum tag named ID. into
1731 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1732 the tag ID is not already defined. */
1735 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1739 if (b->kind != sk_namespace)
1741 /* Shadow the marker, not the real thing, so that the marker
1742 gets restored later. */
1743 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1745 = tree_cons (id, old_type_value, b->type_shadowed);
1746 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1747 TREE_TYPE (b->type_shadowed) = type;
1751 cxx_binding *binding =
1752 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1755 supplement_binding (binding, decl);
1757 binding->value = decl;
1759 /* Store marker instead of real type. */
1760 type = global_type_node;
1762 SET_IDENTIFIER_TYPE_VALUE (id, type);
1765 /* As set_identifier_type_value_with_scope, but using
1766 current_binding_level. */
1769 set_identifier_type_value (tree id, tree decl)
1771 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1774 /* Return the name for the constructor (or destructor) for the
1775 specified class TYPE. When given a template, this routine doesn't
1776 lose the specialization. */
1779 constructor_name_full (tree type)
1781 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1784 /* Return the name for the constructor (or destructor) for the
1785 specified class. When given a template, return the plain
1786 unspecialized name. */
1789 constructor_name (tree type)
1792 name = constructor_name_full (type);
1793 if (IDENTIFIER_TEMPLATE (name))
1794 name = IDENTIFIER_TEMPLATE (name);
1798 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1799 which must be a class type. */
1802 constructor_name_p (tree name, tree type)
1806 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1811 if (TREE_CODE (name) != IDENTIFIER_NODE)
1814 ctor_name = constructor_name_full (type);
1815 if (name == ctor_name)
1817 if (IDENTIFIER_TEMPLATE (ctor_name)
1818 && name == IDENTIFIER_TEMPLATE (ctor_name))
1823 /* Counter used to create anonymous type names. */
1825 static GTY(()) int anon_cnt;
1827 /* Return an IDENTIFIER which can be used as a name for
1828 anonymous structs and unions. */
1831 make_anon_name (void)
1835 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1836 return get_identifier (buf);
1839 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1841 static inline cxx_binding *
1842 find_binding (cxx_scope *scope, cxx_binding *binding)
1844 timevar_push (TV_NAME_LOOKUP);
1846 for (; binding != NULL; binding = binding->previous)
1847 if (binding->scope == scope)
1848 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1853 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1855 static inline cxx_binding *
1856 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1858 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1861 /* Fold-in case where NAME is used only once. */
1862 if (scope == b->scope && b->previous == NULL)
1864 return find_binding (scope, b);
1869 /* Always returns a binding for name in scope. If no binding is
1870 found, make a new one. */
1872 static cxx_binding *
1873 binding_for_name (cxx_scope *scope, tree name)
1875 cxx_binding *result;
1877 result = cxx_scope_find_binding_for_name (scope, name);
1880 /* Not found, make a new one. */
1881 result = cxx_binding_make (NULL, NULL);
1882 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1883 result->scope = scope;
1884 result->is_local = false;
1885 result->value_is_inherited = false;
1886 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1890 /* Walk through the bindings associated to the name of FUNCTION,
1891 and return the first binding that declares a function with a
1892 "C" linkage specification, a.k.a 'extern "C"'.
1893 This function looks for the binding, regardless of which scope it
1894 has been defined in. It basically looks in all the known scopes.
1895 Note that this function does not lookup for bindings of builtin functions
1896 or for functions declared in system headers. */
1898 lookup_extern_c_fun_binding_in_all_ns (tree function)
1903 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1905 name = DECL_NAME (function);
1906 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1908 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1910 iter = iter->previous)
1913 && TREE_CODE (iter->value) == FUNCTION_DECL
1914 && DECL_EXTERN_C_P (iter->value)
1915 && !DECL_ARTIFICIAL (iter->value))
1923 /* Insert another USING_DECL into the current binding level, returning
1924 this declaration. If this is a redeclaration, do nothing, and
1925 return NULL_TREE if this not in namespace scope (in namespace
1926 scope, a using decl might extend any previous bindings). */
1929 push_using_decl (tree scope, tree name)
1933 timevar_push (TV_NAME_LOOKUP);
1934 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1935 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1936 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1937 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1940 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1941 namespace_bindings_p () ? decl : NULL_TREE);
1942 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1943 USING_DECL_SCOPE (decl) = scope;
1944 TREE_CHAIN (decl) = current_binding_level->usings;
1945 current_binding_level->usings = decl;
1946 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1949 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1950 caller to set DECL_CONTEXT properly. */
1953 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1955 struct cp_binding_level *b;
1956 tree function_decl = current_function_decl;
1958 timevar_push (TV_NAME_LOOKUP);
1959 current_function_decl = NULL_TREE;
1960 if (level->kind == sk_class)
1962 b = class_binding_level;
1963 class_binding_level = level;
1964 pushdecl_class_level (x);
1965 class_binding_level = b;
1969 b = current_binding_level;
1970 current_binding_level = level;
1971 x = pushdecl_maybe_friend (x, is_friend);
1972 current_binding_level = b;
1974 current_function_decl = function_decl;
1975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1978 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1979 other definitions already in place. We get around this by making
1980 the value of the identifier point to a list of all the things that
1981 want to be referenced by that name. It is then up to the users of
1982 that name to decide what to do with that list.
1984 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1985 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1987 FLAGS is a bitwise-or of the following values:
1988 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1990 PUSH_USING: DECL is being pushed as the result of a using
1993 IS_FRIEND is true if this is a friend declaration.
1995 The value returned may be a previous declaration if we guessed wrong
1996 about what language DECL should belong to (C or C++). Otherwise,
1997 it's always DECL (and never something that's not a _DECL). */
2000 push_overloaded_decl (tree decl, int flags, bool is_friend)
2002 tree name = DECL_NAME (decl);
2005 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2007 timevar_push (TV_NAME_LOOKUP);
2009 old = namespace_binding (name, DECL_CONTEXT (decl));
2011 old = lookup_name_innermost_nonclass_level (name);
2015 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2017 tree t = TREE_TYPE (old);
2018 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2019 && (! DECL_IN_SYSTEM_HEADER (decl)
2020 || ! DECL_IN_SYSTEM_HEADER (old)))
2021 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2024 else if (is_overloaded_fn (old))
2028 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2030 tree fn = OVL_CURRENT (tmp);
2033 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2034 && !(flags & PUSH_USING)
2035 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2036 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2037 && ! decls_match (fn, decl))
2038 error ("%q#D conflicts with previous using declaration %q#D",
2041 dup = duplicate_decls (decl, fn, is_friend);
2042 /* If DECL was a redeclaration of FN -- even an invalid
2043 one -- pass that information along to our caller. */
2044 if (dup == fn || dup == error_mark_node)
2045 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2048 /* We don't overload implicit built-ins. duplicate_decls()
2049 may fail to merge the decls if the new decl is e.g. a
2050 template function. */
2051 if (TREE_CODE (old) == FUNCTION_DECL
2052 && DECL_ANTICIPATED (old)
2053 && !DECL_HIDDEN_FRIEND_P (old))
2056 else if (old == error_mark_node)
2057 /* Ignore the undefined symbol marker. */
2061 error ("previous non-function declaration %q+#D", old);
2062 error ("conflicts with function declaration %q#D", decl);
2063 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2067 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2068 /* If it's a using declaration, we always need to build an OVERLOAD,
2069 because it's the only way to remember that the declaration comes
2070 from 'using', and have the lookup behave correctly. */
2071 || (flags & PUSH_USING))
2073 if (old && TREE_CODE (old) != OVERLOAD)
2074 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2076 new_binding = ovl_cons (decl, old);
2077 if (flags & PUSH_USING)
2078 OVL_USED (new_binding) = 1;
2081 /* NAME is not ambiguous. */
2085 set_namespace_binding (name, current_namespace, new_binding);
2088 /* We only create an OVERLOAD if there was a previous binding at
2089 this level, or if decl is a template. In the former case, we
2090 need to remove the old binding and replace it with the new
2091 binding. We must also run through the NAMES on the binding
2092 level where the name was bound to update the chain. */
2094 if (TREE_CODE (new_binding) == OVERLOAD && old)
2098 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2100 d = &TREE_CHAIN (*d))
2102 || (TREE_CODE (*d) == TREE_LIST
2103 && TREE_VALUE (*d) == old))
2105 if (TREE_CODE (*d) == TREE_LIST)
2106 /* Just replace the old binding with the new. */
2107 TREE_VALUE (*d) = new_binding;
2109 /* Build a TREE_LIST to wrap the OVERLOAD. */
2110 *d = tree_cons (NULL_TREE, new_binding,
2113 /* And update the cxx_binding node. */
2114 IDENTIFIER_BINDING (name)->value = new_binding;
2115 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2118 /* We should always find a previous binding in this case. */
2122 /* Install the new binding. */
2123 push_local_binding (name, new_binding, flags);
2126 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2129 /* Check a non-member using-declaration. Return the name and scope
2130 being used, and the USING_DECL, or NULL_TREE on failure. */
2133 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2135 /* [namespace.udecl]
2136 A using-declaration for a class member shall be a
2137 member-declaration. */
2140 error ("%qT is not a namespace", scope);
2143 else if (scope == error_mark_node)
2146 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2149 A using-declaration shall not name a template-id. */
2150 error ("a using-declaration cannot specify a template-id. "
2151 "Try %<using %D%>", name);
2155 if (TREE_CODE (decl) == NAMESPACE_DECL)
2157 error ("namespace %qD not allowed in using-declaration", decl);
2161 if (TREE_CODE (decl) == SCOPE_REF)
2163 /* It's a nested name with template parameter dependent scope.
2164 This can only be using-declaration for class member. */
2165 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2169 if (is_overloaded_fn (decl))
2170 decl = get_first_fn (decl);
2172 gcc_assert (DECL_P (decl));
2174 /* Make a USING_DECL. */
2175 return push_using_decl (scope, name);
2178 /* Process local and global using-declarations. */
2181 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2182 tree *newval, tree *newtype)
2184 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2186 *newval = *newtype = NULL_TREE;
2187 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2191 if (!decls.value && !decls.type)
2193 error ("%qD not declared", name);
2197 /* Shift the old and new bindings around so we're comparing class and
2198 enumeration names to each other. */
2199 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2205 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2207 decls.type = decls.value;
2208 decls.value = NULL_TREE;
2211 /* It is impossible to overload a built-in function; any explicit
2212 declaration eliminates the built-in declaration. So, if OLDVAL
2213 is a built-in, then we can just pretend it isn't there. */
2215 && TREE_CODE (oldval) == FUNCTION_DECL
2216 && DECL_ANTICIPATED (oldval)
2217 && !DECL_HIDDEN_FRIEND_P (oldval))
2222 /* Check for using functions. */
2223 if (is_overloaded_fn (decls.value))
2227 if (oldval && !is_overloaded_fn (oldval))
2229 error ("%qD is already declared in this scope", name);
2234 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2236 tree new_fn = OVL_CURRENT (tmp);
2238 /* [namespace.udecl]
2240 If a function declaration in namespace scope or block
2241 scope has the same name and the same parameter types as a
2242 function introduced by a using declaration the program is
2244 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2246 tree old_fn = OVL_CURRENT (tmp1);
2248 if (new_fn == old_fn)
2249 /* The function already exists in the current namespace. */
2251 else if (OVL_USED (tmp1))
2252 continue; /* this is a using decl */
2253 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2254 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2256 gcc_assert (!DECL_ANTICIPATED (old_fn)
2257 || DECL_HIDDEN_FRIEND_P (old_fn));
2259 /* There was already a non-using declaration in
2260 this scope with the same parameter types. If both
2261 are the same extern "C" functions, that's ok. */
2262 if (decls_match (new_fn, old_fn))
2266 error ("%qD is already declared in this scope", name);
2272 /* If we broke out of the loop, there's no reason to add
2273 this function to the using declarations for this
2278 /* If we are adding to an existing OVERLOAD, then we no
2279 longer know the type of the set of functions. */
2280 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2281 TREE_TYPE (*newval) = unknown_type_node;
2282 /* Add this new function to the set. */
2283 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2284 /* If there is only one function, then we use its type. (A
2285 using-declaration naming a single function can be used in
2286 contexts where overload resolution cannot be
2288 if (TREE_CODE (*newval) != OVERLOAD)
2290 *newval = ovl_cons (*newval, NULL_TREE);
2291 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2293 OVL_USED (*newval) = 1;
2298 *newval = decls.value;
2299 if (oldval && !decls_match (*newval, oldval))
2300 error ("%qD is already declared in this scope", name);
2306 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2308 error ("reference to %qD is ambiguous", name);
2309 print_candidates (decls.type);
2313 *newtype = decls.type;
2314 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2315 error ("%qD is already declared in this scope", name);
2318 /* If *newval is empty, shift any class or enumeration name down. */
2322 *newtype = NULL_TREE;
2326 /* Process a using-declaration at function scope. */
2329 do_local_using_decl (tree decl, tree scope, tree name)
2331 tree oldval, oldtype, newval, newtype;
2332 tree orig_decl = decl;
2334 decl = validate_nonmember_using_decl (decl, scope, name);
2335 if (decl == NULL_TREE)
2338 if (building_stmt_tree ()
2339 && at_function_scope_p ())
2340 add_decl_expr (decl);
2342 oldval = lookup_name_innermost_nonclass_level (name);
2343 oldtype = lookup_type_current_level (name);
2345 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2349 if (is_overloaded_fn (newval))
2353 /* We only need to push declarations for those functions
2354 that were not already bound in the current level.
2355 The old value might be NULL_TREE, it might be a single
2356 function, or an OVERLOAD. */
2357 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2358 term = OVL_FUNCTION (oldval);
2361 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2363 push_overloaded_decl (OVL_CURRENT (fn),
2364 PUSH_LOCAL | PUSH_USING,
2368 push_local_binding (name, newval, PUSH_USING);
2372 push_local_binding (name, newtype, PUSH_USING);
2373 set_identifier_type_value (name, newtype);
2376 /* Emit debug info. */
2377 if (!processing_template_decl)
2378 cp_emit_debug_info_for_using (orig_decl, current_scope());
2381 /* Returns true if ROOT (a namespace, class, or function) encloses
2382 CHILD. CHILD may be either a class type or a namespace. */
2385 is_ancestor (tree root, tree child)
2387 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2388 || TREE_CODE (root) == FUNCTION_DECL
2389 || CLASS_TYPE_P (root)));
2390 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2391 || CLASS_TYPE_P (child)));
2393 /* The global namespace encloses everything. */
2394 if (root == global_namespace)
2399 /* If we've run out of scopes, stop. */
2402 /* If we've reached the ROOT, it encloses CHILD. */
2405 /* Go out one level. */
2407 child = TYPE_NAME (child);
2408 child = DECL_CONTEXT (child);
2412 /* Enter the class or namespace scope indicated by T suitable for name
2413 lookup. T can be arbitrary scope, not necessary nested inside the
2414 current scope. Returns a non-null scope to pop iff pop_scope
2415 should be called later to exit this scope. */
2420 if (TREE_CODE (t) == NAMESPACE_DECL)
2421 push_decl_namespace (t);
2422 else if (CLASS_TYPE_P (t))
2424 if (!at_class_scope_p ()
2425 || !same_type_p (current_class_type, t))
2426 push_nested_class (t);
2428 /* T is the same as the current scope. There is therefore no
2429 need to re-enter the scope. Since we are not actually
2430 pushing a new scope, our caller should not call
2438 /* Leave scope pushed by push_scope. */
2443 if (TREE_CODE (t) == NAMESPACE_DECL)
2444 pop_decl_namespace ();
2445 else if CLASS_TYPE_P (t)
2446 pop_nested_class ();
2449 /* Subroutine of push_inner_scope. */
2452 push_inner_scope_r (tree outer, tree inner)
2457 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2460 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2462 push_inner_scope_r (outer, prev);
2463 if (TREE_CODE (inner) == NAMESPACE_DECL)
2465 struct cp_binding_level *save_template_parm = 0;
2466 /* Temporary take out template parameter scopes. They are saved
2467 in reversed order in save_template_parm. */
2468 while (current_binding_level->kind == sk_template_parms)
2470 struct cp_binding_level *b = current_binding_level;
2471 current_binding_level = b->level_chain;
2472 b->level_chain = save_template_parm;
2473 save_template_parm = b;
2476 resume_scope (NAMESPACE_LEVEL (inner));
2477 current_namespace = inner;
2479 /* Restore template parameter scopes. */
2480 while (save_template_parm)
2482 struct cp_binding_level *b = save_template_parm;
2483 save_template_parm = b->level_chain;
2484 b->level_chain = current_binding_level;
2485 current_binding_level = b;
2492 /* Enter the scope INNER from current scope. INNER must be a scope
2493 nested inside current scope. This works with both name lookup and
2494 pushing name into scope. In case a template parameter scope is present,
2495 namespace is pushed under the template parameter scope according to
2496 name lookup rule in 14.6.1/6.
2498 Return the former current scope suitable for pop_inner_scope. */
2501 push_inner_scope (tree inner)
2503 tree outer = current_scope ();
2505 outer = current_namespace;
2507 push_inner_scope_r (outer, inner);
2511 /* Exit the current scope INNER back to scope OUTER. */
2514 pop_inner_scope (tree outer, tree inner)
2517 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2520 while (outer != inner)
2522 if (TREE_CODE (inner) == NAMESPACE_DECL)
2524 struct cp_binding_level *save_template_parm = 0;
2525 /* Temporary take out template parameter scopes. They are saved
2526 in reversed order in save_template_parm. */
2527 while (current_binding_level->kind == sk_template_parms)
2529 struct cp_binding_level *b = current_binding_level;
2530 current_binding_level = b->level_chain;
2531 b->level_chain = save_template_parm;
2532 save_template_parm = b;
2537 /* Restore template parameter scopes. */
2538 while (save_template_parm)
2540 struct cp_binding_level *b = save_template_parm;
2541 save_template_parm = b->level_chain;
2542 b->level_chain = current_binding_level;
2543 current_binding_level = b;
2549 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2553 /* Do a pushlevel for class declarations. */
2556 pushlevel_class (void)
2558 if (ENABLE_SCOPE_CHECKING)
2561 class_binding_level = begin_scope (sk_class, current_class_type);
2564 /* ...and a poplevel for class declarations. */
2567 poplevel_class (void)
2569 struct cp_binding_level *level = class_binding_level;
2570 cp_class_binding *cb;
2574 timevar_push (TV_NAME_LOOKUP);
2575 gcc_assert (level != 0);
2577 /* If we're leaving a toplevel class, cache its binding level. */
2578 if (current_class_depth == 1)
2579 previous_class_level = level;
2580 for (shadowed = level->type_shadowed;
2582 shadowed = TREE_CHAIN (shadowed))
2583 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2585 /* Remove the bindings for all of the class-level declarations. */
2586 if (level->class_shadowed)
2589 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2591 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2592 ggc_free (level->class_shadowed);
2593 level->class_shadowed = NULL;
2596 /* Now, pop out of the binding level which we created up in the
2597 `pushlevel_class' routine. */
2598 if (ENABLE_SCOPE_CHECKING)
2602 timevar_pop (TV_NAME_LOOKUP);
2605 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2606 appropriate. DECL is the value to which a name has just been
2607 bound. CLASS_TYPE is the class in which the lookup occurred. */
2610 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2613 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2617 if (TREE_CODE (decl) == OVERLOAD)
2618 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2621 gcc_assert (DECL_P (decl));
2622 context = context_for_name_lookup (decl);
2625 if (is_properly_derived_from (class_type, context))
2626 INHERITED_VALUE_BINDING_P (binding) = 1;
2628 INHERITED_VALUE_BINDING_P (binding) = 0;
2630 else if (binding->value == decl)
2631 /* We only encounter a TREE_LIST when there is an ambiguity in the
2632 base classes. Such an ambiguity can be overridden by a
2633 definition in this class. */
2634 INHERITED_VALUE_BINDING_P (binding) = 1;
2636 INHERITED_VALUE_BINDING_P (binding) = 0;
2639 /* Make the declaration of X appear in CLASS scope. */
2642 pushdecl_class_level (tree x)
2645 bool is_valid = true;
2647 timevar_push (TV_NAME_LOOKUP);
2648 /* Get the name of X. */
2649 if (TREE_CODE (x) == OVERLOAD)
2650 name = DECL_NAME (get_first_fn (x));
2652 name = DECL_NAME (x);
2656 is_valid = push_class_level_binding (name, x);
2657 if (TREE_CODE (x) == TYPE_DECL)
2658 set_identifier_type_value (name, x);
2660 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2662 /* If X is an anonymous aggregate, all of its members are
2663 treated as if they were members of the class containing the
2664 aggregate, for naming purposes. */
2667 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2669 location_t save_location = input_location;
2670 input_location = DECL_SOURCE_LOCATION (f);
2671 if (!pushdecl_class_level (f))
2673 input_location = save_location;
2676 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2679 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2680 scope. If the value returned is non-NULL, and the PREVIOUS field
2681 is not set, callers must set the PREVIOUS field explicitly. */
2683 static cxx_binding *
2684 get_class_binding (tree name, cxx_scope *scope)
2689 cxx_binding *binding;
2691 class_type = scope->this_entity;
2693 /* Get the type binding. */
2694 type_binding = lookup_member (class_type, name,
2695 /*protect=*/2, /*want_type=*/true);
2696 /* Get the value binding. */
2697 value_binding = lookup_member (class_type, name,
2698 /*protect=*/2, /*want_type=*/false);
2701 && (TREE_CODE (value_binding) == TYPE_DECL
2702 || DECL_CLASS_TEMPLATE_P (value_binding)
2703 || (TREE_CODE (value_binding) == TREE_LIST
2704 && TREE_TYPE (value_binding) == error_mark_node
2705 && (TREE_CODE (TREE_VALUE (value_binding))
2707 /* We found a type binding, even when looking for a non-type
2708 binding. This means that we already processed this binding
2711 else if (value_binding)
2713 if (TREE_CODE (value_binding) == TREE_LIST
2714 && TREE_TYPE (value_binding) == error_mark_node)
2715 /* NAME is ambiguous. */
2717 else if (BASELINK_P (value_binding))
2718 /* NAME is some overloaded functions. */
2719 value_binding = BASELINK_FUNCTIONS (value_binding);
2722 /* If we found either a type binding or a value binding, create a
2723 new binding object. */
2724 if (type_binding || value_binding)
2726 binding = new_class_binding (name,
2730 /* This is a class-scope binding, not a block-scope binding. */
2731 LOCAL_BINDING_P (binding) = 0;
2732 set_inherited_value_binding_p (binding, value_binding, class_type);
2740 /* Make the declaration(s) of X appear in CLASS scope under the name
2741 NAME. Returns true if the binding is valid. */
2744 push_class_level_binding (tree name, tree x)
2746 cxx_binding *binding;
2750 timevar_push (TV_NAME_LOOKUP);
2751 /* The class_binding_level will be NULL if x is a template
2752 parameter name in a member template. */
2753 if (!class_binding_level)
2754 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2756 if (name == error_mark_node)
2757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2759 /* Check for invalid member names. */
2760 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2761 /* We could have been passed a tree list if this is an ambiguous
2762 declaration. If so, pull the declaration out because
2763 check_template_shadow will not handle a TREE_LIST. */
2764 if (TREE_CODE (decl) == TREE_LIST
2765 && TREE_TYPE (decl) == error_mark_node)
2766 decl = TREE_VALUE (decl);
2768 if (!check_template_shadow (decl))
2769 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2773 If T is the name of a class, then each of the following shall
2774 have a name different from T:
2776 -- every static data member of class T;
2778 -- every member of class T that is itself a type;
2780 -- every enumerator of every member of class T that is an
2783 -- every member of every anonymous union that is a member of
2786 (Non-static data members were also forbidden to have the same
2787 name as T until TC1.) */
2788 if ((TREE_CODE (x) == VAR_DECL
2789 || TREE_CODE (x) == CONST_DECL
2790 || (TREE_CODE (x) == TYPE_DECL
2791 && !DECL_SELF_REFERENCE_P (x))
2792 /* A data member of an anonymous union. */
2793 || (TREE_CODE (x) == FIELD_DECL
2794 && DECL_CONTEXT (x) != current_class_type))
2795 && DECL_NAME (x) == constructor_name (current_class_type))
2797 tree scope = context_for_name_lookup (x);
2798 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2800 error ("%qD has the same name as the class in which it is "
2803 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2807 /* Get the current binding for NAME in this class, if any. */
2808 binding = IDENTIFIER_BINDING (name);
2809 if (!binding || binding->scope != class_binding_level)
2811 binding = get_class_binding (name, class_binding_level);
2812 /* If a new binding was created, put it at the front of the
2813 IDENTIFIER_BINDING list. */
2816 binding->previous = IDENTIFIER_BINDING (name);
2817 IDENTIFIER_BINDING (name) = binding;
2821 /* If there is already a binding, then we may need to update the
2823 if (binding && binding->value)
2825 tree bval = binding->value;
2826 tree old_decl = NULL_TREE;
2828 if (INHERITED_VALUE_BINDING_P (binding))
2830 /* If the old binding was from a base class, and was for a
2831 tag name, slide it over to make room for the new binding.
2832 The old binding is still visible if explicitly qualified
2833 with a class-key. */
2834 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2835 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2837 old_decl = binding->type;
2838 binding->type = bval;
2839 binding->value = NULL_TREE;
2840 INHERITED_VALUE_BINDING_P (binding) = 0;
2845 /* Any inherited type declaration is hidden by the type
2846 declaration in the derived class. */
2847 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2848 binding->type = NULL_TREE;
2851 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2853 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2854 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2855 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2857 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2858 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2860 if (old_decl && binding->scope == class_binding_level)
2863 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2864 here. This function is only used to register bindings
2865 from with the class definition itself. */
2866 INHERITED_VALUE_BINDING_P (binding) = 0;
2867 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2871 /* Note that we declared this value so that we can issue an error if
2872 this is an invalid redeclaration of a name already used for some
2874 note_name_declared_in_class (name, decl);
2876 /* If we didn't replace an existing binding, put the binding on the
2877 stack of bindings for the identifier, and update the shadowed
2879 if (binding && binding->scope == class_binding_level)
2880 /* Supplement the existing binding. */
2881 ok = supplement_binding (binding, decl);
2884 /* Create a new binding. */
2885 push_binding (name, decl, class_binding_level);
2889 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2892 /* Process "using SCOPE::NAME" in a class scope. Return the
2893 USING_DECL created. */
2896 do_class_using_decl (tree scope, tree name)
2898 /* The USING_DECL returned by this function. */
2900 /* The declaration (or declarations) name by this using
2901 declaration. NULL if we are in a template and cannot figure out
2902 what has been named. */
2904 /* True if SCOPE is a dependent type. */
2905 bool scope_dependent_p;
2906 /* True if SCOPE::NAME is dependent. */
2907 bool name_dependent_p;
2908 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2909 bool bases_dependent_p;
2914 if (name == error_mark_node)
2917 if (!scope || !TYPE_P (scope))
2919 error ("using-declaration for non-member at class scope");
2923 /* Make sure the name is not invalid */
2924 if (TREE_CODE (name) == BIT_NOT_EXPR)
2926 error ("%<%T::%D%> names destructor", scope, name);
2929 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2931 error ("%<%T::%D%> names constructor", scope, name);
2934 if (constructor_name_p (name, current_class_type))
2936 error ("%<%T::%D%> names constructor in %qT",
2937 scope, name, current_class_type);
2941 scope_dependent_p = dependent_type_p (scope);
2942 name_dependent_p = (scope_dependent_p
2943 || (IDENTIFIER_TYPENAME_P (name)
2944 && dependent_type_p (TREE_TYPE (name))));
2946 bases_dependent_p = false;
2947 if (processing_template_decl)
2948 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2949 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2951 if (dependent_type_p (TREE_TYPE (base_binfo)))
2953 bases_dependent_p = true;
2959 /* From [namespace.udecl]:
2961 A using-declaration used as a member-declaration shall refer to a
2962 member of a base class of the class being defined.
2964 In general, we cannot check this constraint in a template because
2965 we do not know the entire set of base classes of the current
2966 class type. However, if all of the base classes are
2967 non-dependent, then we can avoid delaying the check until
2969 if (!scope_dependent_p)
2972 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2973 if (b_kind < bk_proper_base)
2975 if (!bases_dependent_p)
2977 error_not_base_type (scope, current_class_type);
2981 else if (!name_dependent_p)
2983 decl = lookup_member (binfo, name, 0, false);
2986 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2990 /* The binfo from which the functions came does not matter. */
2991 if (BASELINK_P (decl))
2992 decl = BASELINK_FUNCTIONS (decl);
2996 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2997 USING_DECL_DECLS (value) = decl;
2998 USING_DECL_SCOPE (value) = scope;
2999 DECL_DEPENDENT_P (value) = !decl;
3005 /* Return the binding value for name in scope. */
3008 namespace_binding (tree name, tree scope)
3010 cxx_binding *binding;
3013 scope = global_namespace;
3015 /* Unnecessary for the global namespace because it can't be an alias. */
3016 scope = ORIGINAL_NAMESPACE (scope);
3018 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3020 return binding ? binding->value : NULL_TREE;
3023 /* Set the binding value for name in scope. */
3026 set_namespace_binding (tree name, tree scope, tree val)
3030 timevar_push (TV_NAME_LOOKUP);
3031 if (scope == NULL_TREE)
3032 scope = global_namespace;
3033 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3034 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3037 supplement_binding (b, val);
3038 timevar_pop (TV_NAME_LOOKUP);
3041 /* Set the context of a declaration to scope. Complain if we are not
3045 set_decl_namespace (tree decl, tree scope, bool friendp)
3049 /* Get rid of namespace aliases. */
3050 scope = ORIGINAL_NAMESPACE (scope);
3052 /* It is ok for friends to be qualified in parallel space. */
3053 if (!friendp && !is_ancestor (current_namespace, scope))
3054 error ("declaration of %qD not in a namespace surrounding %qD",
3056 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3058 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3059 if (scope == current_namespace)
3061 if (at_namespace_scope_p ())
3062 error ("explicit qualification in declaration of %qD",
3067 /* See whether this has been declared in the namespace. */
3068 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3069 if (old == error_mark_node)
3070 /* No old declaration at all. */
3072 if (!is_overloaded_fn (decl))
3073 /* Don't compare non-function decls with decls_match here, since
3074 it can't check for the correct constness at this
3075 point. pushdecl will find those errors later. */
3077 /* Since decl is a function, old should contain a function decl. */
3078 if (!is_overloaded_fn (old))
3080 fn = OVL_CURRENT (old);
3081 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3083 /* A template can be explicitly specialized in any namespace. */
3084 if (processing_explicit_instantiation)
3086 if (processing_template_decl || processing_specialization)
3087 /* We have not yet called push_template_decl to turn a
3088 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3089 match. But, we'll check later, when we construct the
3092 /* Instantiations or specializations of templates may be declared as
3093 friends in any namespace. */
3094 if (friendp && DECL_USE_TEMPLATE (decl))
3096 if (is_overloaded_fn (old))
3098 for (; old; old = OVL_NEXT (old))
3099 if (decls_match (decl, OVL_CURRENT (old)))
3102 else if (decls_match (decl, old))
3105 error ("%qD should have been declared inside %qD", decl, scope);
3108 /* Return the namespace where the current declaration is declared. */
3111 current_decl_namespace (void)
3114 /* If we have been pushed into a different namespace, use it. */
3115 if (decl_namespace_list)
3116 return TREE_PURPOSE (decl_namespace_list);
3118 if (current_class_type)
3119 result = decl_namespace_context (current_class_type);
3120 else if (current_function_decl)
3121 result = decl_namespace_context (current_function_decl);
3123 result = current_namespace;
3127 /* Process any ATTRIBUTES on a namespace definition. Currently only
3128 attribute visibility is meaningful, which is a property of the syntactic
3129 block rather than the namespace as a whole, so we don't touch the
3130 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3133 handle_namespace_attrs (tree ns, tree attributes)
3136 bool saw_vis = false;
3138 for (d = attributes; d; d = TREE_CHAIN (d))
3140 tree name = TREE_PURPOSE (d);
3141 tree args = TREE_VALUE (d);
3143 #ifdef HANDLE_PRAGMA_VISIBILITY
3144 if (is_attribute_p ("visibility", name))
3146 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3147 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3149 warning (OPT_Wattributes,
3150 "%qD attribute requires a single NTBS argument",
3155 if (!TREE_PUBLIC (ns))
3156 warning (OPT_Wattributes,
3157 "%qD attribute is meaningless since members of the "
3158 "anonymous namespace get local symbols", name);
3160 push_visibility (TREE_STRING_POINTER (x));
3166 warning (OPT_Wattributes, "%qD attribute directive ignored",
3175 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3176 select a name that is unique to this compilation unit. */
3179 push_namespace (tree name)
3183 int implicit_use = 0;
3186 timevar_push (TV_NAME_LOOKUP);
3188 /* We should not get here if the global_namespace is not yet constructed
3189 nor if NAME designates the global namespace: The global scope is
3190 constructed elsewhere. */
3191 gcc_assert (global_namespace != NULL && name != global_scope_name);
3195 name = get_anonymous_namespace_name();
3196 d = IDENTIFIER_NAMESPACE_VALUE (name);
3198 /* Reopening anonymous namespace. */
3204 /* Check whether this is an extended namespace definition. */
3205 d = IDENTIFIER_NAMESPACE_VALUE (name);
3206 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3209 if (DECL_NAMESPACE_ALIAS (d))
3211 error ("namespace alias %qD not allowed here, assuming %qD",
3212 d, DECL_NAMESPACE_ALIAS (d));
3213 d = DECL_NAMESPACE_ALIAS (d);
3220 /* Make a new namespace, binding the name to it. */
3221 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3222 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3223 /* The name of this namespace is not visible to other translation
3224 units if it is an anonymous namespace or member thereof. */
3225 if (anon || decl_anon_ns_mem_p (current_namespace))
3226 TREE_PUBLIC (d) = 0;
3228 TREE_PUBLIC (d) = 1;
3232 /* Clear DECL_NAME for the benefit of debugging back ends. */
3233 SET_DECL_ASSEMBLER_NAME (d, name);
3234 DECL_NAME (d) = NULL_TREE;
3236 begin_scope (sk_namespace, d);
3239 resume_scope (NAMESPACE_LEVEL (d));
3242 do_using_directive (d);
3243 /* Enter the name space. */
3244 current_namespace = d;
3246 timevar_pop (TV_NAME_LOOKUP);
3249 /* Pop from the scope of the current namespace. */
3252 pop_namespace (void)
3254 gcc_assert (current_namespace != global_namespace);
3255 current_namespace = CP_DECL_CONTEXT (current_namespace);
3256 /* The binding level is not popped, as it might be re-opened later. */
3260 /* Push into the scope of the namespace NS, even if it is deeply
3261 nested within another namespace. */
3264 push_nested_namespace (tree ns)
3266 if (ns == global_namespace)
3267 push_to_top_level ();
3270 push_nested_namespace (CP_DECL_CONTEXT (ns));
3271 push_namespace (DECL_NAME (ns));
3275 /* Pop back from the scope of the namespace NS, which was previously
3276 entered with push_nested_namespace. */
3279 pop_nested_namespace (tree ns)
3281 timevar_push (TV_NAME_LOOKUP);
3282 while (ns != global_namespace)
3285 ns = CP_DECL_CONTEXT (ns);
3288 pop_from_top_level ();
3289 timevar_pop (TV_NAME_LOOKUP);
3292 /* Temporarily set the namespace for the current declaration. */
3295 push_decl_namespace (tree decl)
3297 if (TREE_CODE (decl) != NAMESPACE_DECL)
3298 decl = decl_namespace_context (decl);
3299 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3300 NULL_TREE, decl_namespace_list);
3303 /* [namespace.memdef]/2 */
3306 pop_decl_namespace (void)
3308 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3311 /* Return the namespace that is the common ancestor
3312 of two given namespaces. */
3315 namespace_ancestor (tree ns1, tree ns2)
3317 timevar_push (TV_NAME_LOOKUP);
3318 if (is_ancestor (ns1, ns2))
3319 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3320 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3321 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3324 /* Process a namespace-alias declaration. */
3327 do_namespace_alias (tree alias, tree name_space)
3329 if (name_space == error_mark_node)
3332 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3334 name_space = ORIGINAL_NAMESPACE (name_space);
3336 /* Build the alias. */
3337 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3338 DECL_NAMESPACE_ALIAS (alias) = name_space;
3339 DECL_EXTERNAL (alias) = 1;
3340 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3343 /* Emit debug info for namespace alias. */
3344 if (!building_stmt_tree ())
3345 (*debug_hooks->global_decl) (alias);
3348 /* Like pushdecl, only it places X in the current namespace,
3352 pushdecl_namespace_level (tree x, bool is_friend)
3354 struct cp_binding_level *b = current_binding_level;
3357 timevar_push (TV_NAME_LOOKUP);
3358 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3360 /* Now, the type_shadowed stack may screw us. Munge it so it does
3362 if (TREE_CODE (t) == TYPE_DECL)
3364 tree name = DECL_NAME (t);
3366 tree *ptr = (tree *)0;
3367 for (; !global_scope_p (b); b = b->level_chain)
3369 tree shadowed = b->type_shadowed;
3370 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3371 if (TREE_PURPOSE (shadowed) == name)
3373 ptr = &TREE_VALUE (shadowed);
3374 /* Can't break out of the loop here because sometimes
3375 a binding level will have duplicate bindings for
3376 PT names. It's gross, but I haven't time to fix it. */
3379 newval = TREE_TYPE (t);
3380 if (ptr == (tree *)0)
3382 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3383 up here if this is changed to an assertion. --KR */
3384 SET_IDENTIFIER_TYPE_VALUE (name, t);
3391 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3394 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3395 directive is not directly from the source. Also find the common
3396 ancestor and let our users know about the new namespace */
3398 add_using_namespace (tree user, tree used, bool indirect)
3401 timevar_push (TV_NAME_LOOKUP);
3402 /* Using oneself is a no-op. */
3405 timevar_pop (TV_NAME_LOOKUP);
3408 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3409 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3410 /* Check if we already have this. */
3411 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3415 /* Promote to direct usage. */
3416 TREE_INDIRECT_USING (t) = 0;
3417 timevar_pop (TV_NAME_LOOKUP);
3421 /* Add used to the user's using list. */
3422 DECL_NAMESPACE_USING (user)
3423 = tree_cons (used, namespace_ancestor (user, used),
3424 DECL_NAMESPACE_USING (user));
3426 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3428 /* Add user to the used's users list. */
3429 DECL_NAMESPACE_USERS (used)
3430 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3432 /* Recursively add all namespaces used. */
3433 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3434 /* indirect usage */
3435 add_using_namespace (user, TREE_PURPOSE (t), 1);
3437 /* Tell everyone using us about the new used namespaces. */
3438 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3439 add_using_namespace (TREE_PURPOSE (t), used, 1);
3440 timevar_pop (TV_NAME_LOOKUP);
3443 /* Process a using-declaration not appearing in class or local scope. */
3446 do_toplevel_using_decl (tree decl, tree scope, tree name)
3448 tree oldval, oldtype, newval, newtype;
3449 tree orig_decl = decl;
3450 cxx_binding *binding;
3452 decl = validate_nonmember_using_decl (decl, scope, name);
3453 if (decl == NULL_TREE)
3456 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3458 oldval = binding->value;
3459 oldtype = binding->type;
3461 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3463 /* Emit debug info. */
3464 if (!processing_template_decl)
3465 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3467 /* Copy declarations found. */
3469 binding->value = newval;
3471 binding->type = newtype;
3474 /* Process a using-directive. */
3477 do_using_directive (tree name_space)
3479 tree context = NULL_TREE;
3481 if (name_space == error_mark_node)
3484 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3486 if (building_stmt_tree ())
3487 add_stmt (build_stmt (USING_STMT, name_space));
3488 name_space = ORIGINAL_NAMESPACE (name_space);
3490 if (!toplevel_bindings_p ())
3492 push_using_directive (name_space);
3497 add_using_namespace (current_namespace, name_space, 0);
3498 if (current_namespace != global_namespace)
3499 context = current_namespace;
3501 /* Emit debugging info. */
3502 if (!processing_template_decl)
3503 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3508 /* Deal with a using-directive seen by the parser. Currently we only
3509 handle attributes here, since they cannot appear inside a template. */
3512 parse_using_directive (tree name_space, tree attribs)
3516 do_using_directive (name_space);
3518 for (a = attribs; a; a = TREE_CHAIN (a))
3520 tree name = TREE_PURPOSE (a);
3521 if (is_attribute_p ("strong", name))
3523 if (!toplevel_bindings_p ())
3524 error ("strong using only meaningful at namespace scope");
3525 else if (name_space != error_mark_node)
3527 if (!is_ancestor (current_namespace, name_space))
3528 error ("current namespace %qD does not enclose strongly used namespace %qD",
3529 current_namespace, name_space);
3530 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3531 = tree_cons (current_namespace, 0,
3532 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3536 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3540 /* Like pushdecl, only it places X in the global scope if appropriate.
3541 Calls cp_finish_decl to register the variable, initializing it with
3542 *INIT, if INIT is non-NULL. */
3545 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3547 timevar_push (TV_NAME_LOOKUP);
3548 push_to_top_level ();
3549 x = pushdecl_namespace_level (x, is_friend);
3551 finish_decl (x, *init, NULL_TREE);
3552 pop_from_top_level ();
3553 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3556 /* Like pushdecl, only it places X in the global scope if appropriate. */
3559 pushdecl_top_level (tree x)
3561 return pushdecl_top_level_1 (x, NULL, false);
3564 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3567 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3569 return pushdecl_top_level_1 (x, NULL, is_friend);
3572 /* Like pushdecl, only it places X in the global scope if
3573 appropriate. Calls cp_finish_decl to register the variable,
3574 initializing it with INIT. */
3577 pushdecl_top_level_and_finish (tree x, tree init)
3579 return pushdecl_top_level_1 (x, &init, false);
3582 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3583 duplicates. The first list becomes the tail of the result.
3585 The algorithm is O(n^2). We could get this down to O(n log n) by
3586 doing a sort on the addresses of the functions, if that becomes
3590 merge_functions (tree s1, tree s2)
3592 for (; s2; s2 = OVL_NEXT (s2))
3594 tree fn2 = OVL_CURRENT (s2);
3597 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3599 tree fn1 = OVL_CURRENT (fns1);
3601 /* If the function from S2 is already in S1, there is no
3602 need to add it again. For `extern "C"' functions, we
3603 might have two FUNCTION_DECLs for the same function, in
3604 different namespaces; again, we only need one of them. */
3606 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3607 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3611 /* If we exhausted all of the functions in S1, FN2 is new. */
3613 s1 = build_overload (fn2, s1);
3618 /* This should return an error not all definitions define functions.
3619 It is not an error if we find two functions with exactly the
3620 same signature, only if these are selected in overload resolution.
3621 old is the current set of bindings, new_binding the freshly-found binding.
3622 XXX Do we want to give *all* candidates in case of ambiguity?
3623 XXX In what way should I treat extern declarations?
3624 XXX I don't want to repeat the entire duplicate_decls here */
3627 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3630 gcc_assert (old != NULL);
3632 /* Copy the type. */
3633 type = new_binding->type;
3634 if (LOOKUP_NAMESPACES_ONLY (flags)
3635 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3638 /* Copy the value. */
3639 val = new_binding->value;
3642 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3645 switch (TREE_CODE (val))
3648 /* If we expect types or namespaces, and not templates,
3649 or this is not a template class. */
3650 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3651 && !DECL_CLASS_TEMPLATE_P (val)))
3655 if (LOOKUP_NAMESPACES_ONLY (flags)
3656 || (type && (flags & LOOKUP_PREFER_TYPES)))
3659 case NAMESPACE_DECL:
3660 if (LOOKUP_TYPES_ONLY (flags))
3664 /* Ignore built-in functions that are still anticipated. */
3665 if (LOOKUP_QUALIFIERS_ONLY (flags))
3669 if (LOOKUP_QUALIFIERS_ONLY (flags))
3674 /* If val is hidden, shift down any class or enumeration name. */
3683 else if (val && val != old->value)
3685 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3686 old->value = merge_functions (old->value, val);
3689 old->value = tree_cons (NULL_TREE, old->value,
3690 build_tree_list (NULL_TREE, val));
3691 TREE_TYPE (old->value) = error_mark_node;
3697 else if (type && old->type != type)
3699 old->type = tree_cons (NULL_TREE, old->type,
3700 build_tree_list (NULL_TREE, type));
3701 TREE_TYPE (old->type) = error_mark_node;
3705 /* Return the declarations that are members of the namespace NS. */
3708 cp_namespace_decls (tree ns)
3710 return NAMESPACE_LEVEL (ns)->names;
3713 /* Combine prefer_type and namespaces_only into flags. */
3716 lookup_flags (int prefer_type, int namespaces_only)
3718 if (namespaces_only)
3719 return LOOKUP_PREFER_NAMESPACES;
3720 if (prefer_type > 1)
3721 return LOOKUP_PREFER_TYPES;
3722 if (prefer_type > 0)
3723 return LOOKUP_PREFER_BOTH;
3727 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3728 ignore it or not. Subroutine of lookup_name_real and
3729 lookup_type_scope. */
3732 qualify_lookup (tree val, int flags)
3734 if (val == NULL_TREE)
3736 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3738 if ((flags & LOOKUP_PREFER_TYPES)
3739 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3741 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3746 /* Given a lookup that returned VAL, decide if we want to ignore it or
3747 not based on DECL_ANTICIPATED. */
3750 hidden_name_p (tree val)
3753 && DECL_LANG_SPECIFIC (val)
3754 && DECL_ANTICIPATED (val))
3759 /* Remove any hidden friend functions from a possibly overloaded set
3763 remove_hidden_names (tree fns)
3768 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3770 else if (TREE_CODE (fns) == OVERLOAD)
3774 for (o = fns; o; o = OVL_NEXT (o))
3775 if (hidden_name_p (OVL_CURRENT (o)))
3781 for (o = fns; o; o = OVL_NEXT (o))
3782 if (!hidden_name_p (OVL_CURRENT (o)))
3783 n = build_overload (OVL_CURRENT (o), n);
3791 /* Unscoped lookup of a global: iterate over current namespaces,
3792 considering using-directives. */
3795 unqualified_namespace_lookup (tree name, int flags)
3797 tree initial = current_decl_namespace ();
3798 tree scope = initial;
3800 struct cp_binding_level *level;
3801 tree val = NULL_TREE;
3803 timevar_push (TV_NAME_LOOKUP);
3805 for (; !val; scope = CP_DECL_CONTEXT (scope))
3807 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3809 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3812 ambiguous_decl (&binding, b, flags);
3814 /* Add all _DECLs seen through local using-directives. */
3815 for (level = current_binding_level;
3816 level->kind != sk_namespace;
3817 level = level->level_chain)
3818 if (!lookup_using_namespace (name, &binding, level->using_directives,
3820 /* Give up because of error. */
3821 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3823 /* Add all _DECLs seen through global using-directives. */
3824 /* XXX local and global using lists should work equally. */
3828 if (!lookup_using_namespace (name, &binding,
3829 DECL_NAMESPACE_USING (siter),
3831 /* Give up because of error. */
3832 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3833 if (siter == scope) break;
3834 siter = CP_DECL_CONTEXT (siter);
3837 val = binding.value;
3838 if (scope == global_namespace)
3841 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3844 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3845 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3848 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3849 declaration found. If no suitable declaration can be found,
3850 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3851 neither a class-type nor a namespace a diagnostic is issued. */
3854 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3859 if (TREE_CODE (scope) == NAMESPACE_DECL)
3861 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3863 flags |= LOOKUP_COMPLAIN;
3865 flags |= LOOKUP_PREFER_TYPES;
3866 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3869 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3870 t = lookup_enumerator (scope, name);
3871 else if (is_class_type (scope, complain))
3872 t = lookup_member (scope, name, 2, is_type_p);
3875 return error_mark_node;
3879 /* Subroutine of unqualified_namespace_lookup:
3880 Add the bindings of NAME in used namespaces to VAL.
3881 We are currently looking for names in namespace SCOPE, so we
3882 look through USINGS for using-directives of namespaces
3883 which have SCOPE as a common ancestor with the current scope.
3884 Returns false on errors. */
3887 lookup_using_namespace (tree name, struct scope_binding *val,
3888 tree usings, tree scope, int flags)
3891 timevar_push (TV_NAME_LOOKUP);
3892 /* Iterate over all used namespaces in current, searching for using
3893 directives of scope. */
3894 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3895 if (TREE_VALUE (iter) == scope)
3897 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3899 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3900 /* Resolve ambiguities. */
3902 ambiguous_decl (val, val1, flags);
3904 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3908 Accepts the NAME to lookup and its qualifying SCOPE.
3909 Returns the name/type pair found into the cxx_binding *RESULT,
3910 or false on error. */
3913 qualified_lookup_using_namespace (tree name, tree scope,
3914 struct scope_binding *result, int flags)
3916 /* Maintain a list of namespaces visited... */
3917 tree seen = NULL_TREE;
3918 /* ... and a list of namespace yet to see. */
3919 tree todo = NULL_TREE;
3920 tree todo_maybe = NULL_TREE;
3922 timevar_push (TV_NAME_LOOKUP);
3923 /* Look through namespace aliases. */
3924 scope = ORIGINAL_NAMESPACE (scope);
3925 while (scope && result->value != error_mark_node)
3927 cxx_binding *binding =
3928 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3929 seen = tree_cons (scope, NULL_TREE, seen);
3931 ambiguous_decl (result, binding, flags);
3933 /* Consider strong using directives always, and non-strong ones
3934 if we haven't found a binding yet. ??? Shouldn't we consider
3935 non-strong ones if the initial RESULT is non-NULL, but the
3936 binding in the given namespace is? */
3937 for (usings = DECL_NAMESPACE_USING (scope); usings;
3938 usings = TREE_CHAIN (usings))
3939 /* If this was a real directive, and we have not seen it. */
3940 if (!TREE_INDIRECT_USING (usings))
3942 /* Try to avoid queuing the same namespace more than once,
3943 the exception being when a namespace was already
3944 enqueued for todo_maybe and then a strong using is
3945 found for it. We could try to remove it from
3946 todo_maybe, but it's probably not worth the effort. */
3947 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3948 && !purpose_member (TREE_PURPOSE (usings), seen)
3949 && !purpose_member (TREE_PURPOSE (usings), todo))
3950 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3951 else if ((!result->value && !result->type)
3952 && !purpose_member (TREE_PURPOSE (usings), seen)
3953 && !purpose_member (TREE_PURPOSE (usings), todo)
3954 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3955 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3960 scope = TREE_PURPOSE (todo);
3961 todo = TREE_CHAIN (todo);
3964 && (!result->value && !result->type))
3966 scope = TREE_PURPOSE (todo_maybe);
3967 todo = TREE_CHAIN (todo_maybe);
3968 todo_maybe = NULL_TREE;
3971 scope = NULL_TREE; /* If there never was a todo list. */
3973 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3976 /* Subroutine of outer_binding.
3977 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
3981 binding_to_template_parms_of_scope_p (cxx_binding *binding,
3986 if (!binding || !scope)
3989 binding_value = binding->value ? binding->value : binding->type;
3992 && scope->this_entity
3993 && get_template_info (scope->this_entity)
3994 && parameter_of_template_p (binding_value,
3995 TI_TEMPLATE (get_template_info \
3996 (scope->this_entity))));
3999 /* Return the innermost non-namespace binding for NAME from a scope
4000 containing BINDING, or, if BINDING is NULL, the current scope.
4001 Please note that for a given template, the template parameters are
4002 considered to be in the scope containing the current scope.
4003 If CLASS_P is false, then class bindings are ignored. */
4006 outer_binding (tree name,
4007 cxx_binding *binding,
4012 cxx_scope *outer_scope;
4016 scope = binding->scope->level_chain;
4017 outer = binding->previous;
4021 scope = current_binding_level;
4022 outer = IDENTIFIER_BINDING (name);
4024 outer_scope = outer ? outer->scope : NULL;
4026 /* Because we create class bindings lazily, we might be missing a
4027 class binding for NAME. If there are any class binding levels
4028 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4029 declared, we must lookup NAME in those class scopes. */
4031 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4033 if (scope->kind == sk_class)
4035 cxx_binding *class_binding;
4037 class_binding = get_class_binding (name, scope);
4040 /* Thread this new class-scope binding onto the
4041 IDENTIFIER_BINDING list so that future lookups
4043 class_binding->previous = outer;
4045 binding->previous = class_binding;
4047 IDENTIFIER_BINDING (name) = class_binding;
4048 return class_binding;
4051 /* If we are in a member template, the template parms of the member
4052 template are considered to be inside the scope of the containing
4053 class, but within G++ the class bindings are all pushed between the
4054 template parms and the function body. So if the outer binding is
4055 a template parm for the current scope, return it now rather than
4056 look for a class binding. */
4057 if (outer_scope && outer_scope->kind == sk_template_parms
4058 && binding_to_template_parms_of_scope_p (outer, scope))
4061 scope = scope->level_chain;
4067 /* Return the innermost block-scope or class-scope value binding for
4068 NAME, or NULL_TREE if there is no such binding. */
4071 innermost_non_namespace_value (tree name)
4073 cxx_binding *binding;
4074 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4075 return binding ? binding->value : NULL_TREE;
4078 /* Look up NAME in the current binding level and its superiors in the
4079 namespace of variables, functions and typedefs. Return a ..._DECL
4080 node of some kind representing its definition if there is only one
4081 such declaration, or return a TREE_LIST with all the overloaded
4082 definitions if there are many, or return 0 if it is undefined.
4083 Hidden name, either friend declaration or built-in function, are
4086 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4087 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4088 Otherwise we prefer non-TYPE_DECLs.
4090 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4091 BLOCK_P is false, bindings in block scopes are ignored. */
4094 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4095 int namespaces_only, int flags)
4098 tree val = NULL_TREE;
4100 timevar_push (TV_NAME_LOOKUP);
4101 /* Conversion operators are handled specially because ordinary
4102 unqualified name lookup will not find template conversion
4104 if (IDENTIFIER_TYPENAME_P (name))
4106 struct cp_binding_level *level;
4108 for (level = current_binding_level;
4109 level && level->kind != sk_namespace;
4110 level = level->level_chain)
4115 /* A conversion operator can only be declared in a class
4117 if (level->kind != sk_class)
4120 /* Lookup the conversion operator in the class. */
4121 class_type = level->this_entity;
4122 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4124 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4127 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4130 flags |= lookup_flags (prefer_type, namespaces_only);
4132 /* First, look in non-namespace scopes. */
4134 if (current_class_type == NULL_TREE)
4137 if (block_p || !nonclass)
4138 for (iter = outer_binding (name, NULL, !nonclass);
4140 iter = outer_binding (name, iter, !nonclass))
4144 /* Skip entities we don't want. */
4145 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4148 /* If this is the kind of thing we're looking for, we're done. */
4149 if (qualify_lookup (iter->value, flags))
4150 binding = iter->value;
4151 else if ((flags & LOOKUP_PREFER_TYPES)
4152 && qualify_lookup (iter->type, flags))
4153 binding = iter->type;
4155 binding = NULL_TREE;
4159 if (hidden_name_p (binding))
4161 /* A non namespace-scope binding can only be hidden in the
4162 presence of a local class, due to friend declarations.
4164 In particular, consider:
4172 B* b; // error: B is hidden
4173 C* c; // OK, finds ::C
4176 B *b; // error: B is hidden
4177 C *c; // OK, finds ::C
4182 The standard says that "B" is a local class in "f"
4183 (but not nested within "A") -- but that name lookup
4184 for "B" does not find this declaration until it is
4185 declared directly with "f".
4191 If a friend declaration appears in a local class and
4192 the name specified is an unqualified name, a prior
4193 declaration is looked up without considering scopes
4194 that are outside the innermost enclosing non-class
4195 scope. For a friend function declaration, if there is
4196 no prior declaration, the program is ill-formed. For a
4197 friend class declaration, if there is no prior
4198 declaration, the class that is specified belongs to the
4199 innermost enclosing non-class scope, but if it is
4200 subsequently referenced, its name is not found by name
4201 lookup until a matching declaration is provided in the
4202 innermost enclosing nonclass scope.
4204 So just keep looking for a non-hidden binding.
4206 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4214 /* Now lookup in namespace scopes. */
4216 val = unqualified_namespace_lookup (name, flags);
4218 /* If we have a single function from a using decl, pull it out. */
4219 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4220 val = OVL_FUNCTION (val);
4222 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4226 lookup_name_nonclass (tree name)
4228 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4232 lookup_function_nonclass (tree name, tree args, bool block_p)
4235 lookup_arg_dependent (name,
4236 lookup_name_real (name, 0, 1, block_p, 0,
4242 lookup_name (tree name)
4244 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4248 lookup_name_prefer_type (tree name, int prefer_type)
4250 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4251 0, LOOKUP_COMPLAIN);
4254 /* Look up NAME for type used in elaborated name specifier in
4255 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4256 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4257 name, more scopes are checked if cleanup or template parameter
4258 scope is encountered.
4260 Unlike lookup_name_real, we make sure that NAME is actually
4261 declared in the desired scope, not from inheritance, nor using
4262 directive. For using declaration, there is DR138 still waiting
4263 to be resolved. Hidden name coming from an earlier friend
4264 declaration is also returned.
4266 A TYPE_DECL best matching the NAME is returned. Catching error
4267 and issuing diagnostics are caller's responsibility. */
4270 lookup_type_scope (tree name, tag_scope scope)
4272 cxx_binding *iter = NULL;
4273 tree val = NULL_TREE;
4275 timevar_push (TV_NAME_LOOKUP);
4277 /* Look in non-namespace scope first. */
4278 if (current_binding_level->kind != sk_namespace)
4279 iter = outer_binding (name, NULL, /*class_p=*/ true);
4280 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4282 /* Check if this is the kind of thing we're looking for.
4283 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4284 base class. For ITER->VALUE, we can simply use
4285 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4288 We check ITER->TYPE before ITER->VALUE in order to handle
4289 typedef struct C {} C;
4292 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4293 && (scope != ts_current
4294 || LOCAL_BINDING_P (iter)
4295 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4297 else if ((scope != ts_current
4298 || !INHERITED_VALUE_BINDING_P (iter))
4299 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4306 /* Look in namespace scope. */
4309 iter = cxx_scope_find_binding_for_name
4310 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4314 /* If this is the kind of thing we're looking for, we're done. */
4315 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4317 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4323 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4324 and template parameter scopes. */
4327 struct cp_binding_level *b = current_binding_level;
4330 if (iter->scope == b)
4331 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4333 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4334 || b->kind == sk_function_parms)
4336 else if (b->kind == sk_class
4337 && scope == ts_within_enclosing_non_class)
4344 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4347 /* Similar to `lookup_name' but look only in the innermost non-class
4351 lookup_name_innermost_nonclass_level (tree name)
4353 struct cp_binding_level *b;
4356 timevar_push (TV_NAME_LOOKUP);
4357 b = innermost_nonclass_level ();
4359 if (b->kind == sk_namespace)
4361 t = IDENTIFIER_NAMESPACE_VALUE (name);
4363 /* extern "C" function() */
4364 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4367 else if (IDENTIFIER_BINDING (name)
4368 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4370 cxx_binding *binding;
4371 binding = IDENTIFIER_BINDING (name);
4374 if (binding->scope == b
4375 && !(TREE_CODE (binding->value) == VAR_DECL
4376 && DECL_DEAD_FOR_LOCAL (binding->value)))
4377 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4379 if (b->kind == sk_cleanup)
4386 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4389 /* Like lookup_name_innermost_nonclass_level, but for types. */
4392 lookup_type_current_level (tree name)
4396 timevar_push (TV_NAME_LOOKUP);
4397 gcc_assert (current_binding_level->kind != sk_namespace);
4399 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4400 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4402 struct cp_binding_level *b = current_binding_level;
4405 if (purpose_member (name, b->type_shadowed))
4406 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4407 REAL_IDENTIFIER_TYPE_VALUE (name));
4408 if (b->kind == sk_cleanup)
4415 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4418 /* [basic.lookup.koenig] */
4419 /* A nonzero return value in the functions below indicates an error. */
4430 static bool arg_assoc (struct arg_lookup*, tree);
4431 static bool arg_assoc_args (struct arg_lookup*, tree);
4432 static bool arg_assoc_type (struct arg_lookup*, tree);
4433 static bool add_function (struct arg_lookup *, tree);
4434 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4435 static bool arg_assoc_class (struct arg_lookup *, tree);
4436 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4438 /* Add a function to the lookup structure.
4439 Returns true on error. */
4442 add_function (struct arg_lookup *k, tree fn)
4444 /* We used to check here to see if the function was already in the list,
4445 but that's O(n^2), which is just too expensive for function lookup.
4446 Now we deal with the occasional duplicate in joust. In doing this, we
4447 assume that the number of duplicates will be small compared to the
4448 total number of functions being compared, which should usually be the
4451 /* We must find only functions, or exactly one non-function. */
4454 else if (fn == k->functions)
4456 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4457 k->functions = build_overload (fn, k->functions);
4460 tree f1 = OVL_CURRENT (k->functions);
4462 if (is_overloaded_fn (f1))
4464 fn = f1; f1 = f2; f2 = fn;
4466 error ("%q+D is not a function,", f1);
4467 error (" conflict with %q+D", f2);
4468 error (" in call to %qD", k->name);
4475 /* Returns true iff CURRENT has declared itself to be an associated
4476 namespace of SCOPE via a strong using-directive (or transitive chain
4477 thereof). Both are namespaces. */
4480 is_associated_namespace (tree current, tree scope)
4482 tree seen = NULL_TREE;
4483 tree todo = NULL_TREE;
4487 if (scope == current)
4489 seen = tree_cons (scope, NULL_TREE, seen);
4490 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4491 if (!purpose_member (TREE_PURPOSE (t), seen))
4492 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4495 scope = TREE_PURPOSE (todo);
4496 todo = TREE_CHAIN (todo);
4503 /* Return whether FN is a friend of an associated class of ARG. */
4506 friend_of_associated_class_p (tree arg, tree fn)
4512 else if (type_unknown_p (arg))
4515 type = TREE_TYPE (arg);
4517 /* If TYPE is a class, the class itself and all base classes are
4518 associated classes. */
4519 if (CLASS_TYPE_P (type))
4521 if (is_friend (type, fn))
4524 if (TYPE_BINFO (type))
4526 tree binfo, base_binfo;
4529 for (binfo = TYPE_BINFO (type), i = 0;
4530 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4532 if (is_friend (BINFO_TYPE (base_binfo), fn))
4537 /* If TYPE is a class member, the class of which it is a member is
4538 an associated class. */
4539 if ((CLASS_TYPE_P (type)
4540 || TREE_CODE (type) == UNION_TYPE
4541 || TREE_CODE (type) == ENUMERAL_TYPE)
4542 && TYPE_CONTEXT (type)
4543 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4544 && is_friend (TYPE_CONTEXT (type), fn))
4550 /* Add functions of a namespace to the lookup structure.
4551 Returns true on error. */
4554 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4558 if (purpose_member (scope, k->namespaces))
4560 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4562 /* Check out our super-users. */
4563 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4564 value = TREE_CHAIN (value))
4565 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4568 /* Also look down into inline namespaces. */
4569 for (value = DECL_NAMESPACE_USING (scope); value;
4570 value = TREE_CHAIN (value))
4571 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4572 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4575 value = namespace_binding (k->name, scope);
4579 for (; value; value = OVL_NEXT (value))
4581 /* We don't want to find arbitrary hidden functions via argument
4582 dependent lookup. We only want to find friends of associated
4584 if (hidden_name_p (OVL_CURRENT (value)))
4588 for (args = k->args; args; args = TREE_CHAIN (args))
4589 if (friend_of_associated_class_p (TREE_VALUE (args),
4590 OVL_CURRENT (value)))
4596 if (add_function (k, OVL_CURRENT (value)))
4603 /* Adds everything associated with a template argument to the lookup
4604 structure. Returns true on error. */
4607 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4609 /* [basic.lookup.koenig]
4611 If T is a template-id, its associated namespaces and classes are
4612 ... the namespaces and classes associated with the types of the
4613 template arguments provided for template type parameters
4614 (excluding template template parameters); the namespaces in which
4615 any template template arguments are defined; and the classes in
4616 which any member templates used as template template arguments
4617 are defined. [Note: non-type template arguments do not
4618 contribute to the set of associated namespaces. ] */
4620 /* Consider first template template arguments. */
4621 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4622 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4624 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4626 tree ctx = CP_DECL_CONTEXT (arg);
4628 /* It's not a member template. */
4629 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4630 return arg_assoc_namespace (k, ctx);
4631 /* Otherwise, it must be member template. */
4633 return arg_assoc_class (k, ctx);
4635 /* It's an argument pack; handle it recursively. */
4636 else if (ARGUMENT_PACK_P (arg))
4638 tree args = ARGUMENT_PACK_ARGS (arg);
4639 int i, len = TREE_VEC_LENGTH (args);
4640 for (i = 0; i < len; ++i)
4641 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4646 /* It's not a template template argument, but it is a type template
4648 else if (TYPE_P (arg))
4649 return arg_assoc_type (k, arg);
4650 /* It's a non-type template argument. */
4655 /* Adds everything associated with class to the lookup structure.
4656 Returns true on error. */
4659 arg_assoc_class (struct arg_lookup *k, tree type)
4661 tree list, friends, context;
4664 /* Backend build structures, such as __builtin_va_list, aren't
4665 affected by all this. */
4666 if (!CLASS_TYPE_P (type))
4669 if (purpose_member (type, k->classes))
4671 k->classes = tree_cons (type, NULL_TREE, k->classes);
4673 context = decl_namespace_context (type);
4674 if (arg_assoc_namespace (k, context))
4677 if (TYPE_BINFO (type))
4679 /* Process baseclasses. */
4680 tree binfo, base_binfo;
4682 for (binfo = TYPE_BINFO (type), i = 0;
4683 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4684 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4688 /* Process friends. */
4689 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4690 list = TREE_CHAIN (list))
4691 if (k->name == FRIEND_NAME (list))
4692 for (friends = FRIEND_DECLS (list); friends;
4693 friends = TREE_CHAIN (friends))
4695 tree fn = TREE_VALUE (friends);
4697 /* Only interested in global functions with potentially hidden
4698 (i.e. unqualified) declarations. */
4699 if (CP_DECL_CONTEXT (fn) != context)
4701 /* Template specializations are never found by name lookup.
4702 (Templates themselves can be found, but not template
4703 specializations.) */
4704 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4706 if (add_function (k, fn))
4710 /* Process template arguments. */
4711 if (CLASSTYPE_TEMPLATE_INFO (type)
4712 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4714 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4715 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4716 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4722 /* Adds everything associated with a given type.
4723 Returns 1 on error. */
4726 arg_assoc_type (struct arg_lookup *k, tree type)
4728 /* As we do not get the type of non-type dependent expressions
4729 right, we can end up with such things without a type. */
4733 if (TYPE_PTRMEM_P (type))
4735 /* Pointer to member: associate class type and value type. */
4736 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4738 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4740 else switch (TREE_CODE (type))
4750 case FIXED_POINT_TYPE:
4754 if (TYPE_PTRMEMFUNC_P (type))
4755 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4756 return arg_assoc_class (k, type);
4758 case REFERENCE_TYPE:
4760 return arg_assoc_type (k, TREE_TYPE (type));
4763 return arg_assoc_namespace (k, decl_namespace_context (type));
4765 /* The basetype is referenced in the first arg type, so just
4768 /* Associate the parameter types. */
4769 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4771 /* Associate the return type. */
4772 return arg_assoc_type (k, TREE_TYPE (type));
4773 case TEMPLATE_TYPE_PARM:
4774 case BOUND_TEMPLATE_TEMPLATE_PARM:
4779 gcc_assert (type == unknown_type_node
4780 || type == init_list_type_node);
4782 case TYPE_PACK_EXPANSION:
4783 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4791 /* Adds everything associated with arguments. Returns true on error. */
4794 arg_assoc_args (struct arg_lookup *k, tree args)
4796 for (; args; args = TREE_CHAIN (args))
4797 if (arg_assoc (k, TREE_VALUE (args)))
4802 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4805 arg_assoc (struct arg_lookup *k, tree n)
4807 if (n == error_mark_node)
4811 return arg_assoc_type (k, n);
4813 if (! type_unknown_p (n))
4814 return arg_assoc_type (k, TREE_TYPE (n));
4816 if (TREE_CODE (n) == ADDR_EXPR)
4817 n = TREE_OPERAND (n, 0);
4818 if (TREE_CODE (n) == COMPONENT_REF)
4819 n = TREE_OPERAND (n, 1);
4820 if (TREE_CODE (n) == OFFSET_REF)
4821 n = TREE_OPERAND (n, 1);
4822 while (TREE_CODE (n) == TREE_LIST)
4824 if (TREE_CODE (n) == BASELINK)
4825 n = BASELINK_FUNCTIONS (n);
4827 if (TREE_CODE (n) == FUNCTION_DECL)
4828 return arg_assoc_type (k, TREE_TYPE (n));
4829 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4831 /* [basic.lookup.koenig]
4833 If T is a template-id, its associated namespaces and classes
4834 are the namespace in which the template is defined; for
4835 member templates, the member template's class... */
4836 tree templ = TREE_OPERAND (n, 0);
4837 tree args = TREE_OPERAND (n, 1);
4841 if (TREE_CODE (templ) == COMPONENT_REF)
4842 templ = TREE_OPERAND (templ, 1);
4844 /* First, the template. There may actually be more than one if
4845 this is an overloaded function template. But, in that case,
4846 we only need the first; all the functions will be in the same
4848 templ = OVL_CURRENT (templ);
4850 ctx = CP_DECL_CONTEXT (templ);
4852 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4854 if (arg_assoc_namespace (k, ctx) == 1)
4857 /* It must be a member template. */
4858 else if (arg_assoc_class (k, ctx) == 1)
4861 /* Now the arguments. */
4863 for (ix = TREE_VEC_LENGTH (args); ix--;)
4864 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4867 else if (TREE_CODE (n) == OVERLOAD)
4869 for (; n; n = OVL_CHAIN (n))
4870 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4877 /* Performs Koenig lookup depending on arguments, where fns
4878 are the functions found in normal lookup. */
4881 lookup_arg_dependent (tree name, tree fns, tree args)
4883 struct arg_lookup k;
4885 timevar_push (TV_NAME_LOOKUP);
4887 /* Remove any hidden friend functions from the list of functions
4888 found so far. They will be added back by arg_assoc_class as
4890 fns = remove_hidden_names (fns);
4895 k.classes = NULL_TREE;
4897 /* We previously performed an optimization here by setting
4898 NAMESPACES to the current namespace when it was safe. However, DR
4899 164 says that namespaces that were already searched in the first
4900 stage of template processing are searched again (potentially
4901 picking up later definitions) in the second stage. */
4902 k.namespaces = NULL_TREE;
4904 arg_assoc_args (&k, args);
4909 && TREE_CODE (fns) != VAR_DECL
4910 && !is_overloaded_fn (fns))
4912 error ("argument dependent lookup finds %q+D", fns);
4913 error (" in call to %qD", name);
4914 fns = error_mark_node;
4917 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4920 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4921 changed (i.e. there was already a directive), or the fresh
4922 TREE_LIST otherwise. */
4925 push_using_directive (tree used)
4927 tree ud = current_binding_level->using_directives;
4928 tree iter, ancestor;
4930 timevar_push (TV_NAME_LOOKUP);
4931 /* Check if we already have this. */
4932 if (purpose_member (used, ud) != NULL_TREE)
4933 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4935 ancestor = namespace_ancestor (current_decl_namespace (), used);
4936 ud = current_binding_level->using_directives;
4937 ud = tree_cons (used, ancestor, ud);
4938 current_binding_level->using_directives = ud;
4940 /* Recursively add all namespaces used. */
4941 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4942 push_using_directive (TREE_PURPOSE (iter));
4944 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4947 /* The type TYPE is being declared. If it is a class template, or a
4948 specialization of a class template, do any processing required and
4949 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4950 being declared a friend. B is the binding level at which this TYPE
4953 Returns the TYPE_DECL for TYPE, which may have been altered by this
4957 maybe_process_template_type_declaration (tree type, int is_friend,
4960 tree decl = TYPE_NAME (type);
4962 if (processing_template_parmlist)
4963 /* You can't declare a new template type in a template parameter
4964 list. But, you can declare a non-template type:
4966 template <class A*> struct S;
4968 is a forward-declaration of `A'. */
4970 else if (b->kind == sk_namespace
4971 && current_binding_level->kind != sk_namespace)
4972 /* If this new type is being injected into a containing scope,
4973 then it's not a template type. */
4977 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4978 || TREE_CODE (type) == ENUMERAL_TYPE);
4980 if (processing_template_decl)
4982 /* This may change after the call to
4983 push_template_decl_real, but we want the original value. */
4984 tree name = DECL_NAME (decl);
4986 decl = push_template_decl_real (decl, is_friend);
4987 if (decl == error_mark_node)
4988 return error_mark_node;
4990 /* If the current binding level is the binding level for the
4991 template parameters (see the comment in
4992 begin_template_parm_list) and the enclosing level is a class
4993 scope, and we're not looking at a friend, push the
4994 declaration of the member class into the class scope. In the
4995 friend case, push_template_decl will already have put the
4996 friend into global scope, if appropriate. */
4997 if (TREE_CODE (type) != ENUMERAL_TYPE
4998 && !is_friend && b->kind == sk_template_parms
4999 && b->level_chain->kind == sk_class)
5001 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5003 if (!COMPLETE_TYPE_P (current_class_type))
5005 maybe_add_class_template_decl_list (current_class_type,
5006 type, /*friend_p=*/0);
5007 /* Put this UTD in the table of UTDs for the class. */
5008 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5009 CLASSTYPE_NESTED_UTDS (current_class_type) =
5010 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5012 binding_table_insert
5013 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5022 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5023 that the NAME is a class template, the tag is processed but not pushed.
5025 The pushed scope depend on the SCOPE parameter:
5026 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5028 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5029 non-template-parameter scope. This case is needed for forward
5031 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5032 TS_GLOBAL case except that names within template-parameter scopes
5033 are not pushed at all.
5035 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5038 pushtag (tree name, tree type, tag_scope scope)
5040 struct cp_binding_level *b;
5043 timevar_push (TV_NAME_LOOKUP);
5044 b = current_binding_level;
5045 while (/* Cleanup scopes are not scopes from the point of view of
5047 b->kind == sk_cleanup
5048 /* Neither are function parameter scopes. */
5049 || b->kind == sk_function_parms
5050 /* Neither are the scopes used to hold template parameters
5051 for an explicit specialization. For an ordinary template
5052 declaration, these scopes are not scopes from the point of
5053 view of the language. */
5054 || (b->kind == sk_template_parms
5055 && (b->explicit_spec_p || scope == ts_global))
5056 || (b->kind == sk_class
5057 && (scope != ts_current
5058 /* We may be defining a new type in the initializer
5059 of a static member variable. We allow this when
5060 not pedantic, and it is particularly useful for
5061 type punning via an anonymous union. */
5062 || COMPLETE_TYPE_P (b->this_entity))))
5065 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5067 /* Do C++ gratuitous typedefing. */
5068 if (IDENTIFIER_TYPE_VALUE (name) != type)
5072 tree context = TYPE_CONTEXT (type);
5076 tree cs = current_scope ();
5078 if (scope == ts_current)
5080 else if (cs != NULL_TREE && TYPE_P (cs))
5081 /* When declaring a friend class of a local class, we want
5082 to inject the newly named class into the scope
5083 containing the local class, not the namespace
5085 context = decl_function_context (get_type_decl (cs));
5088 context = current_namespace;
5090 if (b->kind == sk_class
5091 || (b->kind == sk_template_parms
5092 && b->level_chain->kind == sk_class))
5095 if (current_lang_name == lang_name_java)
5096 TYPE_FOR_JAVA (type) = 1;
5098 tdef = create_implicit_typedef (name, type);
5099 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5100 if (scope == ts_within_enclosing_non_class)
5102 /* This is a friend. Make this TYPE_DECL node hidden from
5103 ordinary name lookup. Its corresponding TEMPLATE_DECL
5104 will be marked in push_template_decl_real. */
5105 retrofit_lang_decl (tdef);
5106 DECL_ANTICIPATED (tdef) = 1;
5107 DECL_FRIEND_P (tdef) = 1;
5110 decl = maybe_process_template_type_declaration
5111 (type, scope == ts_within_enclosing_non_class, b);
5112 if (decl == error_mark_node)
5113 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5115 if (b->kind == sk_class)
5117 if (!TYPE_BEING_DEFINED (current_class_type))
5118 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5120 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5121 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5122 class. But if it's a member template class, we want
5123 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5125 finish_member_declaration (decl);
5127 pushdecl_class_level (decl);
5129 else if (b->kind != sk_template_parms)
5131 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5132 if (decl == error_mark_node)
5133 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5137 set_identifier_type_value_with_scope (name, tdef, b);
5139 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5141 /* If this is a local class, keep track of it. We need this
5142 information for name-mangling, and so that it is possible to
5143 find all function definitions in a translation unit in a
5144 convenient way. (It's otherwise tricky to find a member
5145 function definition it's only pointed to from within a local
5147 if (TYPE_CONTEXT (type)
5148 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5149 VEC_safe_push (tree, gc, local_classes, type);
5151 if (b->kind == sk_class
5152 && !COMPLETE_TYPE_P (current_class_type))
5154 maybe_add_class_template_decl_list (current_class_type,
5155 type, /*friend_p=*/0);
5157 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5158 CLASSTYPE_NESTED_UTDS (current_class_type)
5159 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5161 binding_table_insert
5162 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5165 decl = TYPE_NAME (type);
5166 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5167 TYPE_STUB_DECL (type) = decl;
5169 /* Set type visibility now if this is a forward declaration. */
5170 TREE_PUBLIC (decl) = 1;
5171 determine_visibility (decl);
5173 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5176 /* Subroutines for reverting temporarily to top-level for instantiation
5177 of templates and such. We actually need to clear out the class- and
5178 local-value slots of all identifiers, so that only the global values
5179 are at all visible. Simply setting current_binding_level to the global
5180 scope isn't enough, because more binding levels may be pushed. */
5181 struct saved_scope *scope_chain;
5183 /* If ID has not already been marked, add an appropriate binding to
5187 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5189 cxx_saved_binding *saved;
5191 if (!id || !IDENTIFIER_BINDING (id))
5194 if (IDENTIFIER_MARKED (id))
5197 IDENTIFIER_MARKED (id) = 1;
5199 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5200 saved->identifier = id;
5201 saved->binding = IDENTIFIER_BINDING (id);
5202 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5203 IDENTIFIER_BINDING (id) = NULL;
5207 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5211 timevar_push (TV_NAME_LOOKUP);
5212 for (t = names; t; t = TREE_CHAIN (t))
5216 if (TREE_CODE (t) == TREE_LIST)
5217 id = TREE_PURPOSE (t);
5221 store_binding (id, old_bindings);
5223 timevar_pop (TV_NAME_LOOKUP);
5226 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5227 objects, rather than a TREE_LIST. */
5230 store_class_bindings (VEC(cp_class_binding,gc) *names,
5231 VEC(cxx_saved_binding,gc) **old_bindings)
5234 cp_class_binding *cb;
5236 timevar_push (TV_NAME_LOOKUP);
5237 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5238 store_binding (cb->identifier, old_bindings);
5239 timevar_pop (TV_NAME_LOOKUP);
5243 push_to_top_level (void)
5245 struct saved_scope *s;
5246 struct cp_binding_level *b;
5247 cxx_saved_binding *sb;
5251 timevar_push (TV_NAME_LOOKUP);
5252 s = GGC_CNEW (struct saved_scope);
5254 b = scope_chain ? current_binding_level : 0;
5256 /* If we're in the middle of some function, save our state. */
5260 push_function_context ();
5265 if (scope_chain && previous_class_level)
5266 store_class_bindings (previous_class_level->class_shadowed,
5269 /* Have to include the global scope, because class-scope decls
5270 aren't listed anywhere useful. */
5271 for (; b; b = b->level_chain)
5275 /* Template IDs are inserted into the global level. If they were
5276 inserted into namespace level, finish_file wouldn't find them
5277 when doing pending instantiations. Therefore, don't stop at
5278 namespace level, but continue until :: . */
5279 if (global_scope_p (b))
5282 store_bindings (b->names, &s->old_bindings);
5283 /* We also need to check class_shadowed to save class-level type
5284 bindings, since pushclass doesn't fill in b->names. */
5285 if (b->kind == sk_class)
5286 store_class_bindings (b->class_shadowed, &s->old_bindings);
5288 /* Unwind type-value slots back to top level. */
5289 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5290 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5293 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5294 IDENTIFIER_MARKED (sb->identifier) = 0;
5296 s->prev = scope_chain;
5298 s->need_pop_function_context = need_pop;
5299 s->function_decl = current_function_decl;
5300 s->skip_evaluation = skip_evaluation;
5303 current_function_decl = NULL_TREE;
5304 current_lang_base = VEC_alloc (tree, gc, 10);
5305 current_lang_name = lang_name_cplusplus;
5306 current_namespace = global_namespace;
5307 push_class_stack ();
5308 skip_evaluation = 0;
5309 timevar_pop (TV_NAME_LOOKUP);
5313 pop_from_top_level (void)
5315 struct saved_scope *s = scope_chain;
5316 cxx_saved_binding *saved;
5319 timevar_push (TV_NAME_LOOKUP);
5320 /* Clear out class-level bindings cache. */
5321 if (previous_class_level)
5322 invalidate_class_lookup_cache ();
5325 current_lang_base = 0;
5327 scope_chain = s->prev;
5328 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5330 tree id = saved->identifier;
5332 IDENTIFIER_BINDING (id) = saved->binding;
5333 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5336 /* If we were in the middle of compiling a function, restore our
5338 if (s->need_pop_function_context)
5339 pop_function_context ();
5340 current_function_decl = s->function_decl;
5341 skip_evaluation = s->skip_evaluation;
5342 timevar_pop (TV_NAME_LOOKUP);
5345 /* Pop off extraneous binding levels left over due to syntax errors.
5347 We don't pop past namespaces, as they might be valid. */
5350 pop_everything (void)
5352 if (ENABLE_SCOPE_CHECKING)
5353 verbatim ("XXX entering pop_everything ()\n");
5354 while (!toplevel_bindings_p ())
5356 if (current_binding_level->kind == sk_class)
5357 pop_nested_class ();
5361 if (ENABLE_SCOPE_CHECKING)
5362 verbatim ("XXX leaving pop_everything ()\n");
5365 /* Emit debugging information for using declarations and directives.
5366 If input tree is overloaded fn then emit debug info for all
5370 cp_emit_debug_info_for_using (tree t, tree context)
5372 /* Don't try to emit any debug information if we have errors. */
5373 if (sorrycount || errorcount)
5376 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5377 of a builtin function. */
5378 if (TREE_CODE (t) == FUNCTION_DECL
5379 && DECL_EXTERNAL (t)
5380 && DECL_BUILT_IN (t))
5383 /* Do not supply context to imported_module_or_decl, if
5384 it is a global namespace. */
5385 if (context == global_namespace)
5386 context = NULL_TREE;
5389 t = BASELINK_FUNCTIONS (t);
5391 /* FIXME: Handle TEMPLATE_DECLs. */
5392 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5393 if (TREE_CODE (t) != TEMPLATE_DECL)
5395 if (building_stmt_tree ())
5396 add_stmt (build_stmt (USING_STMT, t));
5398 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5402 #include "gt-cp-name-lookup.h"