1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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 && !DECL_CONTEXT (x))
608 DECL_CONTEXT (x) = current_function_decl;
610 /* If this is the declaration for a namespace-scope function,
611 but the declaration itself is in a local scope, mark the
613 if (TREE_CODE (x) == FUNCTION_DECL
614 && DECL_NAMESPACE_SCOPE_P (x)
615 && current_function_decl
616 && x != current_function_decl)
617 DECL_LOCAL_FUNCTION_P (x) = 1;
620 name = DECL_NAME (x);
623 int different_binding_level = 0;
625 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
626 name = TREE_OPERAND (name, 0);
628 /* In case this decl was explicitly namespace-qualified, look it
629 up in its namespace context. */
630 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
631 t = namespace_binding (name, DECL_CONTEXT (x));
633 t = lookup_name_innermost_nonclass_level (name);
635 /* [basic.link] If there is a visible declaration of an entity
636 with linkage having the same name and type, ignoring entities
637 declared outside the innermost enclosing namespace scope, the
638 block scope declaration declares that same entity and
639 receives the linkage of the previous declaration. */
640 if (! t && current_function_decl && x != current_function_decl
641 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
642 && DECL_EXTERNAL (x))
644 /* Look in block scope. */
645 t = innermost_non_namespace_value (name);
646 /* Or in the innermost namespace. */
648 t = namespace_binding (name, DECL_CONTEXT (x));
649 /* Does it have linkage? Note that if this isn't a DECL, it's an
650 OVERLOAD, which is OK. */
651 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
654 different_binding_level = 1;
657 /* If we are declaring a function, and the result of name-lookup
658 was an OVERLOAD, look for an overloaded instance that is
659 actually the same as the function we are declaring. (If
660 there is one, we have to merge our declaration with the
661 previous declaration.) */
662 if (t && TREE_CODE (t) == OVERLOAD)
666 if (TREE_CODE (x) == FUNCTION_DECL)
667 for (match = t; match; match = OVL_NEXT (match))
669 if (decls_match (OVL_CURRENT (match), x))
673 /* Just choose one. */
677 t = OVL_CURRENT (match);
682 if (t && t != error_mark_node)
684 if (different_binding_level)
686 if (decls_match (x, t))
687 /* The standard only says that the local extern
688 inherits linkage from the previous decl; in
689 particular, default args are not shared. Add
690 the decl into a hash table to make sure only
691 the previous decl in this case is seen by the
694 struct cxx_int_tree_map *h;
697 TREE_PUBLIC (x) = TREE_PUBLIC (t);
699 if (cp_function_chain->extern_decl_map == NULL)
700 cp_function_chain->extern_decl_map
701 = htab_create_ggc (20, cxx_int_tree_map_hash,
702 cxx_int_tree_map_eq, NULL);
704 h = GGC_NEW (struct cxx_int_tree_map);
705 h->uid = DECL_UID (x);
707 loc = htab_find_slot_with_hash
708 (cp_function_chain->extern_decl_map, h,
710 *(struct cxx_int_tree_map **) loc = h;
713 else if (TREE_CODE (t) == PARM_DECL)
715 gcc_assert (DECL_CONTEXT (t));
717 /* Check for duplicate params. */
718 if (duplicate_decls (x, t, is_friend))
719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
721 else if ((DECL_EXTERN_C_FUNCTION_P (x)
722 || DECL_FUNCTION_TEMPLATE_P (x))
723 && is_overloaded_fn (t))
724 /* Don't do anything just yet. */;
725 else if (t == wchar_decl_node)
727 if (! DECL_IN_SYSTEM_HEADER (x))
728 pedwarn (OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
731 /* Throw away the redeclaration. */
732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
736 tree olddecl = duplicate_decls (x, t, is_friend);
738 /* If the redeclaration failed, we can stop at this
740 if (olddecl == error_mark_node)
741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
745 if (TREE_CODE (t) == TYPE_DECL)
746 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
750 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
752 /* A redeclaration of main, but not a duplicate of the
757 This function shall not be overloaded. */
758 error ("invalid redeclaration of %q+D", t);
760 /* We don't try to push this declaration since that
762 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
767 /* If x has C linkage-specification, (extern "C"),
768 lookup its binding, in case it's already bound to an object.
769 The lookup is done in all namespaces.
770 If we find an existing binding, make sure it has the same
771 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
772 if ((TREE_CODE (x) == FUNCTION_DECL)
773 && DECL_EXTERN_C_P (x)
774 /* We should ignore declarations happening in system headers. */
775 && !DECL_IN_SYSTEM_HEADER (x))
777 cxx_binding *function_binding =
778 lookup_extern_c_fun_binding_in_all_ns (x);
780 && !DECL_IN_SYSTEM_HEADER (function_binding->value))
782 tree previous = function_binding->value;
784 /* In case either x or previous is declared to throw an exception,
785 make sure both exception specifications are equal. */
786 if (decls_match (x, previous))
788 tree x_exception_spec = NULL_TREE;
789 tree previous_exception_spec = NULL_TREE;
792 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
793 previous_exception_spec =
794 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
795 if (!comp_except_specs (previous_exception_spec,
799 pedwarn (0, "declaration of %q#D with C language linkage",
801 pedwarn (0, "conflicts with previous declaration %q+#D",
803 pedwarn (0, "due to different exception specifications");
804 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
810 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
811 check_default_args (x);
813 check_template_shadow (x);
815 /* If this is a function conjured up by the back end, massage it
816 so it looks friendly. */
817 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
819 retrofit_lang_decl (x);
820 SET_DECL_LANGUAGE (x, lang_c);
823 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
825 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
827 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
828 if (!namespace_bindings_p ())
829 /* We do not need to create a binding for this name;
830 push_overloaded_decl will have already done so if
832 need_new_binding = 0;
834 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
836 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
838 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
839 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
842 /* If declaring a type as a typedef, copy the type (unless we're
843 at line 0), and install this TYPE_DECL as the new type's typedef
844 name. See the extensive comment in ../c-decl.c (pushdecl). */
845 if (TREE_CODE (x) == TYPE_DECL)
847 tree type = TREE_TYPE (x);
848 if (DECL_IS_BUILTIN (x))
850 if (TYPE_NAME (type) == 0)
851 TYPE_NAME (type) = x;
853 else if (type != error_mark_node && TYPE_NAME (type) != x
854 /* We don't want to copy the type when all we're
855 doing is making a TYPE_DECL for the purposes of
857 && (!TYPE_NAME (type)
858 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
860 DECL_ORIGINAL_TYPE (x) = type;
861 type = build_variant_type_copy (type);
862 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
863 TYPE_NAME (type) = x;
864 TREE_TYPE (x) = type;
867 if (type != error_mark_node
869 && TYPE_IDENTIFIER (type))
870 set_identifier_type_value (DECL_NAME (x), x);
873 /* Multiple external decls of the same identifier ought to match.
875 We get warnings about inline functions where they are defined.
876 We get warnings about other functions from push_overloaded_decl.
878 Avoid duplicate warnings where they are used. */
879 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
883 decl = IDENTIFIER_NAMESPACE_VALUE (name);
884 if (decl && TREE_CODE (decl) == OVERLOAD)
885 decl = OVL_FUNCTION (decl);
887 if (decl && decl != error_mark_node
888 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
889 /* If different sort of thing, we already gave an error. */
890 && TREE_CODE (decl) == TREE_CODE (x)
891 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
893 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
894 permerror (input_location, "previous external decl of %q+#D", decl);
898 if (TREE_CODE (x) == FUNCTION_DECL
900 && !flag_friend_injection)
902 /* This is a new declaration of a friend function, so hide
903 it from ordinary function lookup. */
904 DECL_ANTICIPATED (x) = 1;
905 DECL_HIDDEN_FRIEND_P (x) = 1;
908 /* This name is new in its binding level.
909 Install the new declaration and return it. */
910 if (namespace_bindings_p ())
912 /* Install a global value. */
914 /* If the first global decl has external linkage,
915 warn if we later see static one. */
916 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
917 TREE_PUBLIC (name) = 1;
919 /* Bind the name for the entity. */
920 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
922 && (TREE_CODE (x) == TYPE_DECL
923 || TREE_CODE (x) == VAR_DECL
924 || TREE_CODE (x) == NAMESPACE_DECL
925 || TREE_CODE (x) == CONST_DECL
926 || TREE_CODE (x) == TEMPLATE_DECL))
927 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
929 /* If new decl is `static' and an `extern' was seen previously,
931 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
932 warn_extern_redeclared_static (x, t);
936 /* Here to install a non-global value. */
937 tree oldlocal = innermost_non_namespace_value (name);
938 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
940 if (need_new_binding)
942 push_local_binding (name, x, 0);
943 /* Because push_local_binding will hook X on to the
944 current_binding_level's name list, we don't want to
945 do that again below. */
946 need_new_binding = 0;
949 /* If this is a TYPE_DECL, push it into the type value slot. */
950 if (TREE_CODE (x) == TYPE_DECL)
951 set_identifier_type_value (name, x);
953 /* Clear out any TYPE_DECL shadowed by a namespace so that
954 we won't think this is a type. The C struct hack doesn't
955 go through namespaces. */
956 if (TREE_CODE (x) == NAMESPACE_DECL)
957 set_identifier_type_value (name, NULL_TREE);
964 && TREE_CODE (oldlocal) == VAR_DECL
965 && DECL_DEAD_FOR_LOCAL (oldlocal))
966 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
968 if (oldlocal == NULL_TREE)
969 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
972 /* If this is an extern function declaration, see if we
973 have a global definition or declaration for the function. */
974 if (oldlocal == NULL_TREE
976 && oldglobal != NULL_TREE
977 && TREE_CODE (x) == FUNCTION_DECL
978 && TREE_CODE (oldglobal) == FUNCTION_DECL)
980 /* We have one. Their types must agree. */
981 if (decls_match (x, oldglobal))
985 warning (0, "extern declaration of %q#D doesn't match", x);
986 warning (0, "global declaration %q+#D", oldglobal);
989 /* If we have a local external declaration,
990 and no file-scope declaration has yet been seen,
991 then if we later have a file-scope decl it must not be static. */
992 if (oldlocal == NULL_TREE
993 && oldglobal == NULL_TREE
996 TREE_PUBLIC (name) = 1;
998 /* Warn if shadowing an argument at the top level of the body. */
999 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1000 /* Inline decls shadow nothing. */
1001 && !DECL_FROM_INLINE (x)
1002 && TREE_CODE (oldlocal) == PARM_DECL
1003 /* Don't check the `this' parameter. */
1004 && !DECL_ARTIFICIAL (oldlocal))
1008 /* Don't complain if it's from an enclosing function. */
1009 if (DECL_CONTEXT (oldlocal) == current_function_decl
1010 && TREE_CODE (x) != PARM_DECL)
1012 /* Go to where the parms should be and see if we find
1014 struct cp_binding_level *b = current_binding_level->level_chain;
1016 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1017 /* Skip the ctor/dtor cleanup level. */
1021 if (b->kind == sk_function_parms)
1023 error ("declaration of %q#D shadows a parameter", x);
1028 if (warn_shadow && !err)
1030 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
1031 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1035 /* Maybe warn if shadowing something else. */
1036 else if (warn_shadow && !DECL_EXTERNAL (x)
1037 /* No shadow warnings for internally generated vars. */
1038 && ! DECL_ARTIFICIAL (x)
1039 /* No shadow warnings for vars made for inlining. */
1040 && ! DECL_FROM_INLINE (x))
1044 if (current_class_ptr)
1045 member = lookup_member (current_class_type,
1048 /*want_type=*/false);
1052 if (member && !TREE_STATIC (member))
1054 /* Location of previous decl is not useful in this case. */
1055 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1058 else if (oldlocal != NULL_TREE
1059 && TREE_CODE (oldlocal) == VAR_DECL)
1061 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1062 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1064 else if (oldglobal != NULL_TREE
1065 && TREE_CODE (oldglobal) == VAR_DECL)
1066 /* XXX shadow warnings in outer-more namespaces */
1068 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1070 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1075 if (TREE_CODE (x) == VAR_DECL)
1076 maybe_register_incomplete_var (x);
1079 if (need_new_binding)
1080 add_decl_to_level (x,
1081 DECL_NAMESPACE_SCOPE_P (x)
1082 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1083 : current_binding_level);
1085 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1088 /* Record a decl-node X as belonging to the current lexical scope. */
1093 return pushdecl_maybe_friend (x, false);
1096 /* Enter DECL into the symbol table, if that's appropriate. Returns
1097 DECL, or a modified version thereof. */
1100 maybe_push_decl (tree decl)
1102 tree type = TREE_TYPE (decl);
1104 /* Add this decl to the current binding level, but not if it comes
1105 from another scope, e.g. a static member variable. TEM may equal
1106 DECL or it may be a previous decl of the same name. */
1107 if (decl == error_mark_node
1108 || (TREE_CODE (decl) != PARM_DECL
1109 && DECL_CONTEXT (decl) != NULL_TREE
1110 /* Definitions of namespace members outside their namespace are
1112 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1113 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1114 || TREE_CODE (type) == UNKNOWN_TYPE
1115 /* The declaration of a template specialization does not affect
1116 the functions available for overload resolution, so we do not
1118 || (TREE_CODE (decl) == FUNCTION_DECL
1119 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1122 return pushdecl (decl);
1125 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1126 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1127 doesn't really belong to this binding level, that it got here
1128 through a using-declaration. */
1131 push_local_binding (tree id, tree decl, int flags)
1133 struct cp_binding_level *b;
1135 /* Skip over any local classes. This makes sense if we call
1136 push_local_binding with a friend decl of a local class. */
1137 b = innermost_nonclass_level ();
1139 if (lookup_name_innermost_nonclass_level (id))
1141 /* Supplement the existing binding. */
1142 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1143 /* It didn't work. Something else must be bound at this
1144 level. Do not add DECL to the list of things to pop
1149 /* Create a new binding. */
1150 push_binding (id, decl, b);
1152 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1153 /* We must put the OVERLOAD into a TREE_LIST since the
1154 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1155 decls that got here through a using-declaration. */
1156 decl = build_tree_list (NULL_TREE, decl);
1158 /* And put DECL on the list of things declared by the current
1160 add_decl_to_level (decl, b);
1163 /* Check to see whether or not DECL is a variable that would have been
1164 in scope under the ARM, but is not in scope under the ANSI/ISO
1165 standard. If so, issue an error message. If name lookup would
1166 work in both cases, but return a different result, this function
1167 returns the result of ANSI/ISO lookup. Otherwise, it returns
1171 check_for_out_of_scope_variable (tree decl)
1175 /* We only care about out of scope variables. */
1176 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1179 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1180 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1181 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1182 && DECL_DEAD_FOR_LOCAL (shadowed))
1183 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1184 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1186 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1189 if (!DECL_ERROR_REPORTED (decl))
1191 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1192 warning (0, " matches this %q+D under ISO standard rules",
1194 warning (0, " matches this %q+D under old rules", decl);
1195 DECL_ERROR_REPORTED (decl) = 1;
1200 /* If we have already complained about this declaration, there's no
1201 need to do it again. */
1202 if (DECL_ERROR_REPORTED (decl))
1205 DECL_ERROR_REPORTED (decl) = 1;
1207 if (TREE_TYPE (decl) == error_mark_node)
1210 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1212 error ("name lookup of %qD changed for ISO %<for%> scoping",
1214 error (" cannot use obsolete binding at %q+D because "
1215 "it has a destructor", decl);
1216 return error_mark_node;
1220 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1222 if (flag_permissive)
1223 permerror (input_location, " using obsolete binding at %q+D", decl);
1229 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1238 /* true means unconditionally make a BLOCK for the next level pushed. */
1240 static bool keep_next_level_flag;
1242 static int binding_depth = 0;
1243 static int is_class_level = 0;
1250 for (i = 0; i < depth * 2; i++)
1254 /* Return a string describing the kind of SCOPE we have. */
1256 cxx_scope_descriptor (cxx_scope *scope)
1258 /* The order of this table must match the "scope_kind"
1260 static const char* scope_kind_names[] = {
1266 "function-parameter-scope",
1269 "template-parameter-scope",
1270 "template-explicit-spec-scope"
1272 const scope_kind kind = scope->explicit_spec_p
1273 ? sk_template_spec : scope->kind;
1275 return scope_kind_names[kind];
1278 /* Output a debugging information about SCOPE when performing
1281 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1283 const char *desc = cxx_scope_descriptor (scope);
1284 if (scope->this_entity)
1285 verbatim ("%s %s(%E) %p %d\n", action, desc,
1286 scope->this_entity, (void *) scope, line);
1288 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1291 /* Return the estimated initial size of the hashtable of a NAMESPACE
1294 static inline size_t
1295 namespace_scope_ht_size (tree ns)
1297 tree name = DECL_NAME (ns);
1299 return name == std_identifier
1300 ? NAMESPACE_STD_HT_SIZE
1301 : (name == global_scope_name
1302 ? GLOBAL_SCOPE_HT_SIZE
1303 : NAMESPACE_ORDINARY_HT_SIZE);
1306 /* A chain of binding_level structures awaiting reuse. */
1308 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1310 /* Insert SCOPE as the innermost binding level. */
1313 push_binding_level (struct cp_binding_level *scope)
1315 /* Add it to the front of currently active scopes stack. */
1316 scope->level_chain = current_binding_level;
1317 current_binding_level = scope;
1318 keep_next_level_flag = false;
1320 if (ENABLE_SCOPE_CHECKING)
1322 scope->binding_depth = binding_depth;
1323 indent (binding_depth);
1324 cxx_scope_debug (scope, input_line, "push");
1330 /* Create a new KIND scope and make it the top of the active scopes stack.
1331 ENTITY is the scope of the associated C++ entity (namespace, class,
1332 function); it is NULL otherwise. */
1335 begin_scope (scope_kind kind, tree entity)
1339 /* Reuse or create a struct for this binding level. */
1340 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1342 scope = free_binding_level;
1343 memset (scope, 0, sizeof (cxx_scope));
1344 free_binding_level = scope->level_chain;
1347 scope = GGC_CNEW (cxx_scope);
1349 scope->this_entity = entity;
1350 scope->more_cleanups_ok = true;
1357 case sk_template_spec:
1358 scope->explicit_spec_p = true;
1359 kind = sk_template_parms;
1361 case sk_template_parms:
1367 case sk_function_parms:
1369 scope->keep = keep_next_level_flag;
1373 NAMESPACE_LEVEL (entity) = scope;
1374 scope->static_decls =
1375 VEC_alloc (tree, gc,
1376 DECL_NAME (entity) == std_identifier
1377 || DECL_NAME (entity) == global_scope_name
1382 /* Should not happen. */
1388 push_binding_level (scope);
1393 /* We're about to leave current scope. Pop the top of the stack of
1394 currently active scopes. Return the enclosing scope, now active. */
1399 cxx_scope *scope = current_binding_level;
1401 if (scope->kind == sk_namespace && class_binding_level)
1402 current_binding_level = class_binding_level;
1404 /* We cannot leave a scope, if there are none left. */
1405 if (NAMESPACE_LEVEL (global_namespace))
1406 gcc_assert (!global_scope_p (scope));
1408 if (ENABLE_SCOPE_CHECKING)
1410 indent (--binding_depth);
1411 cxx_scope_debug (scope, input_line, "leave");
1412 if (is_class_level != (scope == class_binding_level))
1414 indent (binding_depth);
1415 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1420 /* Move one nesting level up. */
1421 current_binding_level = scope->level_chain;
1423 /* Namespace-scopes are left most probably temporarily, not
1424 completely; they can be reopened later, e.g. in namespace-extension
1425 or any name binding activity that requires us to resume a
1426 namespace. For classes, we cache some binding levels. For other
1427 scopes, we just make the structure available for reuse. */
1428 if (scope->kind != sk_namespace
1429 && scope->kind != sk_class)
1431 scope->level_chain = free_binding_level;
1432 gcc_assert (!ENABLE_SCOPE_CHECKING
1433 || scope->binding_depth == binding_depth);
1434 free_binding_level = scope;
1437 /* Find the innermost enclosing class scope, and reset
1438 CLASS_BINDING_LEVEL appropriately. */
1439 if (scope->kind == sk_class)
1441 class_binding_level = NULL;
1442 for (scope = current_binding_level; scope; scope = scope->level_chain)
1443 if (scope->kind == sk_class)
1445 class_binding_level = scope;
1450 return current_binding_level;
1454 resume_scope (struct cp_binding_level* b)
1456 /* Resuming binding levels is meant only for namespaces,
1457 and those cannot nest into classes. */
1458 gcc_assert (!class_binding_level);
1459 /* Also, resuming a non-directly nested namespace is a no-no. */
1460 gcc_assert (b->level_chain == current_binding_level);
1461 current_binding_level = b;
1462 if (ENABLE_SCOPE_CHECKING)
1464 b->binding_depth = binding_depth;
1465 indent (binding_depth);
1466 cxx_scope_debug (b, input_line, "resume");
1472 /* Return the innermost binding level that is not for a class scope. */
1475 innermost_nonclass_level (void)
1479 b = current_binding_level;
1480 while (b->kind == sk_class)
1486 /* We're defining an object of type TYPE. If it needs a cleanup, but
1487 we're not allowed to add any more objects with cleanups to the current
1488 scope, create a new binding level. */
1491 maybe_push_cleanup_level (tree type)
1493 if (type != error_mark_node
1494 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1495 && current_binding_level->more_cleanups_ok == 0)
1497 begin_scope (sk_cleanup, NULL);
1498 current_binding_level->statement_list = push_stmt_list ();
1502 /* Nonzero if we are currently in the global binding level. */
1505 global_bindings_p (void)
1507 return global_scope_p (current_binding_level);
1510 /* True if we are currently in a toplevel binding level. This
1511 means either the global binding level or a namespace in a toplevel
1512 binding level. Since there are no non-toplevel namespace levels,
1513 this really means any namespace or template parameter level. We
1514 also include a class whose context is toplevel. */
1517 toplevel_bindings_p (void)
1519 struct cp_binding_level *b = innermost_nonclass_level ();
1521 return b->kind == sk_namespace || b->kind == sk_template_parms;
1524 /* True if this is a namespace scope, or if we are defining a class
1525 which is itself at namespace scope, or whose enclosing class is
1526 such a class, etc. */
1529 namespace_bindings_p (void)
1531 struct cp_binding_level *b = innermost_nonclass_level ();
1533 return b->kind == sk_namespace;
1536 /* True if the current level needs to have a BLOCK made. */
1541 return (current_binding_level->blocks != NULL_TREE
1542 || current_binding_level->keep
1543 || current_binding_level->kind == sk_cleanup
1544 || current_binding_level->names != NULL_TREE);
1547 /* Returns the kind of the innermost scope. */
1550 innermost_scope_kind (void)
1552 return current_binding_level->kind;
1555 /* Returns true if this scope was created to store template parameters. */
1558 template_parm_scope_p (void)
1560 return innermost_scope_kind () == sk_template_parms;
1563 /* If KEEP is true, make a BLOCK node for the next binding level,
1564 unconditionally. Otherwise, use the normal logic to decide whether
1565 or not to create a BLOCK. */
1568 keep_next_level (bool keep)
1570 keep_next_level_flag = keep;
1573 /* Return the list of declarations of the current level.
1574 Note that this list is in reverse order unless/until
1575 you nreverse it; and when you do nreverse it, you must
1576 store the result back using `storedecls' or you will lose. */
1581 return current_binding_level->names;
1584 /* For debugging. */
1585 static int no_print_functions = 0;
1586 static int no_print_builtins = 0;
1589 print_binding_level (struct cp_binding_level* lvl)
1593 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1594 if (lvl->more_cleanups_ok)
1595 fprintf (stderr, " more-cleanups-ok");
1596 if (lvl->have_cleanups)
1597 fprintf (stderr, " have-cleanups");
1598 fprintf (stderr, "\n");
1601 fprintf (stderr, " names:\t");
1602 /* We can probably fit 3 names to a line? */
1603 for (t = lvl->names; t; t = TREE_CHAIN (t))
1605 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1607 if (no_print_builtins
1608 && (TREE_CODE (t) == TYPE_DECL)
1609 && DECL_IS_BUILTIN (t))
1612 /* Function decls tend to have longer names. */
1613 if (TREE_CODE (t) == FUNCTION_DECL)
1620 fprintf (stderr, "\n\t");
1623 print_node_brief (stderr, "", t, 0);
1624 if (t == error_mark_node)
1628 fprintf (stderr, "\n");
1630 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1633 cp_class_binding *b;
1634 fprintf (stderr, " class-shadowed:");
1636 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1638 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1639 fprintf (stderr, "\n");
1641 if (lvl->type_shadowed)
1643 fprintf (stderr, " type-shadowed:");
1644 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1646 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1648 fprintf (stderr, "\n");
1653 print_other_binding_stack (struct cp_binding_level *stack)
1655 struct cp_binding_level *level;
1656 for (level = stack; !global_scope_p (level); level = level->level_chain)
1658 fprintf (stderr, "binding level %p\n", (void *) level);
1659 print_binding_level (level);
1664 print_binding_stack (void)
1666 struct cp_binding_level *b;
1667 fprintf (stderr, "current_binding_level=%p\n"
1668 "class_binding_level=%p\n"
1669 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1670 (void *) current_binding_level, (void *) class_binding_level,
1671 (void *) NAMESPACE_LEVEL (global_namespace));
1672 if (class_binding_level)
1674 for (b = class_binding_level; b; b = b->level_chain)
1675 if (b == current_binding_level)
1678 b = class_binding_level;
1680 b = current_binding_level;
1683 b = current_binding_level;
1684 print_other_binding_stack (b);
1685 fprintf (stderr, "global:\n");
1686 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1689 /* Return the type associated with id. */
1692 identifier_type_value (tree id)
1694 timevar_push (TV_NAME_LOOKUP);
1695 /* There is no type with that name, anywhere. */
1696 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1697 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1698 /* This is not the type marker, but the real thing. */
1699 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1701 /* Have to search for it. It must be on the global level, now.
1702 Ask lookup_name not to return non-types. */
1703 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1709 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1710 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1713 identifier_global_value (tree t)
1715 return IDENTIFIER_GLOBAL_VALUE (t);
1718 /* Push a definition of struct, union or enum tag named ID. into
1719 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1720 the tag ID is not already defined. */
1723 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1727 if (b->kind != sk_namespace)
1729 /* Shadow the marker, not the real thing, so that the marker
1730 gets restored later. */
1731 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1733 = tree_cons (id, old_type_value, b->type_shadowed);
1734 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1735 TREE_TYPE (b->type_shadowed) = type;
1739 cxx_binding *binding =
1740 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1743 supplement_binding (binding, decl);
1745 binding->value = decl;
1747 /* Store marker instead of real type. */
1748 type = global_type_node;
1750 SET_IDENTIFIER_TYPE_VALUE (id, type);
1753 /* As set_identifier_type_value_with_scope, but using
1754 current_binding_level. */
1757 set_identifier_type_value (tree id, tree decl)
1759 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1762 /* Return the name for the constructor (or destructor) for the
1763 specified class TYPE. When given a template, this routine doesn't
1764 lose the specialization. */
1767 constructor_name_full (tree type)
1769 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1772 /* Return the name for the constructor (or destructor) for the
1773 specified class. When given a template, return the plain
1774 unspecialized name. */
1777 constructor_name (tree type)
1780 name = constructor_name_full (type);
1781 if (IDENTIFIER_TEMPLATE (name))
1782 name = IDENTIFIER_TEMPLATE (name);
1786 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1787 which must be a class type. */
1790 constructor_name_p (tree name, tree type)
1794 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1799 if (TREE_CODE (name) != IDENTIFIER_NODE)
1802 ctor_name = constructor_name_full (type);
1803 if (name == ctor_name)
1805 if (IDENTIFIER_TEMPLATE (ctor_name)
1806 && name == IDENTIFIER_TEMPLATE (ctor_name))
1811 /* Counter used to create anonymous type names. */
1813 static GTY(()) int anon_cnt;
1815 /* Return an IDENTIFIER which can be used as a name for
1816 anonymous structs and unions. */
1819 make_anon_name (void)
1823 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1824 return get_identifier (buf);
1827 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1829 static inline cxx_binding *
1830 find_binding (cxx_scope *scope, cxx_binding *binding)
1832 timevar_push (TV_NAME_LOOKUP);
1834 for (; binding != NULL; binding = binding->previous)
1835 if (binding->scope == scope)
1836 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1838 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1841 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1843 static inline cxx_binding *
1844 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1846 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1849 /* Fold-in case where NAME is used only once. */
1850 if (scope == b->scope && b->previous == NULL)
1852 return find_binding (scope, b);
1857 /* Always returns a binding for name in scope. If no binding is
1858 found, make a new one. */
1860 static cxx_binding *
1861 binding_for_name (cxx_scope *scope, tree name)
1863 cxx_binding *result;
1865 result = cxx_scope_find_binding_for_name (scope, name);
1868 /* Not found, make a new one. */
1869 result = cxx_binding_make (NULL, NULL);
1870 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1871 result->scope = scope;
1872 result->is_local = false;
1873 result->value_is_inherited = false;
1874 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1878 /* Walk through the bindings associated to the name of FUNCTION,
1879 and return the first binding that declares a function with a
1880 "C" linkage specification, a.k.a 'extern "C"'.
1881 This function looks for the binding, regardless of which scope it
1882 has been defined in. It basically looks in all the known scopes.
1883 Note that this function does not lookup for bindings of builtin functions
1884 or for functions declared in system headers. */
1886 lookup_extern_c_fun_binding_in_all_ns (tree function)
1891 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1893 name = DECL_NAME (function);
1894 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1896 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1898 iter = iter->previous)
1901 && TREE_CODE (iter->value) == FUNCTION_DECL
1902 && DECL_EXTERN_C_P (iter->value)
1903 && !DECL_ARTIFICIAL (iter->value))
1911 /* Insert another USING_DECL into the current binding level, returning
1912 this declaration. If this is a redeclaration, do nothing, and
1913 return NULL_TREE if this not in namespace scope (in namespace
1914 scope, a using decl might extend any previous bindings). */
1917 push_using_decl (tree scope, tree name)
1921 timevar_push (TV_NAME_LOOKUP);
1922 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1923 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1924 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1925 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1928 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1929 namespace_bindings_p () ? decl : NULL_TREE);
1930 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1931 USING_DECL_SCOPE (decl) = scope;
1932 TREE_CHAIN (decl) = current_binding_level->usings;
1933 current_binding_level->usings = decl;
1934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1937 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1938 caller to set DECL_CONTEXT properly. */
1941 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1943 struct cp_binding_level *b;
1944 tree function_decl = current_function_decl;
1946 timevar_push (TV_NAME_LOOKUP);
1947 current_function_decl = NULL_TREE;
1948 if (level->kind == sk_class)
1950 b = class_binding_level;
1951 class_binding_level = level;
1952 pushdecl_class_level (x);
1953 class_binding_level = b;
1957 b = current_binding_level;
1958 current_binding_level = level;
1959 x = pushdecl_maybe_friend (x, is_friend);
1960 current_binding_level = b;
1962 current_function_decl = function_decl;
1963 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1966 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1967 other definitions already in place. We get around this by making
1968 the value of the identifier point to a list of all the things that
1969 want to be referenced by that name. It is then up to the users of
1970 that name to decide what to do with that list.
1972 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1973 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1975 FLAGS is a bitwise-or of the following values:
1976 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1978 PUSH_USING: DECL is being pushed as the result of a using
1981 IS_FRIEND is true if this is a friend declaration.
1983 The value returned may be a previous declaration if we guessed wrong
1984 about what language DECL should belong to (C or C++). Otherwise,
1985 it's always DECL (and never something that's not a _DECL). */
1988 push_overloaded_decl (tree decl, int flags, bool is_friend)
1990 tree name = DECL_NAME (decl);
1993 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1995 timevar_push (TV_NAME_LOOKUP);
1997 old = namespace_binding (name, DECL_CONTEXT (decl));
1999 old = lookup_name_innermost_nonclass_level (name);
2003 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2005 tree t = TREE_TYPE (old);
2006 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2007 && (! DECL_IN_SYSTEM_HEADER (decl)
2008 || ! DECL_IN_SYSTEM_HEADER (old)))
2009 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2012 else if (is_overloaded_fn (old))
2016 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2018 tree fn = OVL_CURRENT (tmp);
2021 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2022 && !(flags & PUSH_USING)
2023 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2024 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2025 && ! decls_match (fn, decl))
2026 error ("%q#D conflicts with previous using declaration %q#D",
2029 dup = duplicate_decls (decl, fn, is_friend);
2030 /* If DECL was a redeclaration of FN -- even an invalid
2031 one -- pass that information along to our caller. */
2032 if (dup == fn || dup == error_mark_node)
2033 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2036 /* We don't overload implicit built-ins. duplicate_decls()
2037 may fail to merge the decls if the new decl is e.g. a
2038 template function. */
2039 if (TREE_CODE (old) == FUNCTION_DECL
2040 && DECL_ANTICIPATED (old)
2041 && !DECL_HIDDEN_FRIEND_P (old))
2044 else if (old == error_mark_node)
2045 /* Ignore the undefined symbol marker. */
2049 error ("previous non-function declaration %q+#D", old);
2050 error ("conflicts with function declaration %q#D", decl);
2051 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2055 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2056 /* If it's a using declaration, we always need to build an OVERLOAD,
2057 because it's the only way to remember that the declaration comes
2058 from 'using', and have the lookup behave correctly. */
2059 || (flags & PUSH_USING))
2061 if (old && TREE_CODE (old) != OVERLOAD)
2062 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2064 new_binding = ovl_cons (decl, old);
2065 if (flags & PUSH_USING)
2066 OVL_USED (new_binding) = 1;
2069 /* NAME is not ambiguous. */
2073 set_namespace_binding (name, current_namespace, new_binding);
2076 /* We only create an OVERLOAD if there was a previous binding at
2077 this level, or if decl is a template. In the former case, we
2078 need to remove the old binding and replace it with the new
2079 binding. We must also run through the NAMES on the binding
2080 level where the name was bound to update the chain. */
2082 if (TREE_CODE (new_binding) == OVERLOAD && old)
2086 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2088 d = &TREE_CHAIN (*d))
2090 || (TREE_CODE (*d) == TREE_LIST
2091 && TREE_VALUE (*d) == old))
2093 if (TREE_CODE (*d) == TREE_LIST)
2094 /* Just replace the old binding with the new. */
2095 TREE_VALUE (*d) = new_binding;
2097 /* Build a TREE_LIST to wrap the OVERLOAD. */
2098 *d = tree_cons (NULL_TREE, new_binding,
2101 /* And update the cxx_binding node. */
2102 IDENTIFIER_BINDING (name)->value = new_binding;
2103 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2106 /* We should always find a previous binding in this case. */
2110 /* Install the new binding. */
2111 push_local_binding (name, new_binding, flags);
2114 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2117 /* Check a non-member using-declaration. Return the name and scope
2118 being used, and the USING_DECL, or NULL_TREE on failure. */
2121 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2123 /* [namespace.udecl]
2124 A using-declaration for a class member shall be a
2125 member-declaration. */
2128 error ("%qT is not a namespace", scope);
2131 else if (scope == error_mark_node)
2134 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2137 A using-declaration shall not name a template-id. */
2138 error ("a using-declaration cannot specify a template-id. "
2139 "Try %<using %D%>", name);
2143 if (TREE_CODE (decl) == NAMESPACE_DECL)
2145 error ("namespace %qD not allowed in using-declaration", decl);
2149 if (TREE_CODE (decl) == SCOPE_REF)
2151 /* It's a nested name with template parameter dependent scope.
2152 This can only be using-declaration for class member. */
2153 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2157 if (is_overloaded_fn (decl))
2158 decl = get_first_fn (decl);
2160 gcc_assert (DECL_P (decl));
2162 /* Make a USING_DECL. */
2163 return push_using_decl (scope, name);
2166 /* Process local and global using-declarations. */
2169 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2170 tree *newval, tree *newtype)
2172 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2174 *newval = *newtype = NULL_TREE;
2175 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2179 if (!decls.value && !decls.type)
2181 error ("%qD not declared", name);
2185 /* Shift the old and new bindings around so we're comparing class and
2186 enumeration names to each other. */
2187 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2193 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2195 decls.type = decls.value;
2196 decls.value = NULL_TREE;
2199 /* It is impossible to overload a built-in function; any explicit
2200 declaration eliminates the built-in declaration. So, if OLDVAL
2201 is a built-in, then we can just pretend it isn't there. */
2203 && TREE_CODE (oldval) == FUNCTION_DECL
2204 && DECL_ANTICIPATED (oldval)
2205 && !DECL_HIDDEN_FRIEND_P (oldval))
2210 /* Check for using functions. */
2211 if (is_overloaded_fn (decls.value))
2215 if (oldval && !is_overloaded_fn (oldval))
2217 error ("%qD is already declared in this scope", name);
2222 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2224 tree new_fn = OVL_CURRENT (tmp);
2226 /* [namespace.udecl]
2228 If a function declaration in namespace scope or block
2229 scope has the same name and the same parameter types as a
2230 function introduced by a using declaration the program is
2232 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2234 tree old_fn = OVL_CURRENT (tmp1);
2236 if (new_fn == old_fn)
2237 /* The function already exists in the current namespace. */
2239 else if (OVL_USED (tmp1))
2240 continue; /* this is a using decl */
2241 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2242 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2244 gcc_assert (!DECL_ANTICIPATED (old_fn)
2245 || DECL_HIDDEN_FRIEND_P (old_fn));
2247 /* There was already a non-using declaration in
2248 this scope with the same parameter types. If both
2249 are the same extern "C" functions, that's ok. */
2250 if (decls_match (new_fn, old_fn))
2254 error ("%qD is already declared in this scope", name);
2260 /* If we broke out of the loop, there's no reason to add
2261 this function to the using declarations for this
2266 /* If we are adding to an existing OVERLOAD, then we no
2267 longer know the type of the set of functions. */
2268 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2269 TREE_TYPE (*newval) = unknown_type_node;
2270 /* Add this new function to the set. */
2271 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2272 /* If there is only one function, then we use its type. (A
2273 using-declaration naming a single function can be used in
2274 contexts where overload resolution cannot be
2276 if (TREE_CODE (*newval) != OVERLOAD)
2278 *newval = ovl_cons (*newval, NULL_TREE);
2279 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2281 OVL_USED (*newval) = 1;
2286 *newval = decls.value;
2287 if (oldval && !decls_match (*newval, oldval))
2288 error ("%qD is already declared in this scope", name);
2294 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2296 error ("reference to %qD is ambiguous", name);
2297 print_candidates (decls.type);
2301 *newtype = decls.type;
2302 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2303 error ("%qD is already declared in this scope", name);
2306 /* If *newval is empty, shift any class or enumeration name down. */
2310 *newtype = NULL_TREE;
2314 /* Process a using-declaration at function scope. */
2317 do_local_using_decl (tree decl, tree scope, tree name)
2319 tree oldval, oldtype, newval, newtype;
2320 tree orig_decl = decl;
2322 decl = validate_nonmember_using_decl (decl, scope, name);
2323 if (decl == NULL_TREE)
2326 if (building_stmt_tree ()
2327 && at_function_scope_p ())
2328 add_decl_expr (decl);
2330 oldval = lookup_name_innermost_nonclass_level (name);
2331 oldtype = lookup_type_current_level (name);
2333 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2337 if (is_overloaded_fn (newval))
2341 /* We only need to push declarations for those functions
2342 that were not already bound in the current level.
2343 The old value might be NULL_TREE, it might be a single
2344 function, or an OVERLOAD. */
2345 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2346 term = OVL_FUNCTION (oldval);
2349 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2351 push_overloaded_decl (OVL_CURRENT (fn),
2352 PUSH_LOCAL | PUSH_USING,
2356 push_local_binding (name, newval, PUSH_USING);
2360 push_local_binding (name, newtype, PUSH_USING);
2361 set_identifier_type_value (name, newtype);
2364 /* Emit debug info. */
2365 if (!processing_template_decl)
2366 cp_emit_debug_info_for_using (orig_decl, current_scope());
2369 /* Returns true if ROOT (a namespace, class, or function) encloses
2370 CHILD. CHILD may be either a class type or a namespace. */
2373 is_ancestor (tree root, tree child)
2375 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2376 || TREE_CODE (root) == FUNCTION_DECL
2377 || CLASS_TYPE_P (root)));
2378 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2379 || CLASS_TYPE_P (child)));
2381 /* The global namespace encloses everything. */
2382 if (root == global_namespace)
2387 /* If we've run out of scopes, stop. */
2390 /* If we've reached the ROOT, it encloses CHILD. */
2393 /* Go out one level. */
2395 child = TYPE_NAME (child);
2396 child = DECL_CONTEXT (child);
2400 /* Enter the class or namespace scope indicated by T suitable for name
2401 lookup. T can be arbitrary scope, not necessary nested inside the
2402 current scope. Returns a non-null scope to pop iff pop_scope
2403 should be called later to exit this scope. */
2408 if (TREE_CODE (t) == NAMESPACE_DECL)
2409 push_decl_namespace (t);
2410 else if (CLASS_TYPE_P (t))
2412 if (!at_class_scope_p ()
2413 || !same_type_p (current_class_type, t))
2414 push_nested_class (t);
2416 /* T is the same as the current scope. There is therefore no
2417 need to re-enter the scope. Since we are not actually
2418 pushing a new scope, our caller should not call
2426 /* Leave scope pushed by push_scope. */
2431 if (TREE_CODE (t) == NAMESPACE_DECL)
2432 pop_decl_namespace ();
2433 else if CLASS_TYPE_P (t)
2434 pop_nested_class ();
2437 /* Subroutine of push_inner_scope. */
2440 push_inner_scope_r (tree outer, tree inner)
2445 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2448 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2450 push_inner_scope_r (outer, prev);
2451 if (TREE_CODE (inner) == NAMESPACE_DECL)
2453 struct cp_binding_level *save_template_parm = 0;
2454 /* Temporary take out template parameter scopes. They are saved
2455 in reversed order in save_template_parm. */
2456 while (current_binding_level->kind == sk_template_parms)
2458 struct cp_binding_level *b = current_binding_level;
2459 current_binding_level = b->level_chain;
2460 b->level_chain = save_template_parm;
2461 save_template_parm = b;
2464 resume_scope (NAMESPACE_LEVEL (inner));
2465 current_namespace = inner;
2467 /* Restore template parameter scopes. */
2468 while (save_template_parm)
2470 struct cp_binding_level *b = save_template_parm;
2471 save_template_parm = b->level_chain;
2472 b->level_chain = current_binding_level;
2473 current_binding_level = b;
2480 /* Enter the scope INNER from current scope. INNER must be a scope
2481 nested inside current scope. This works with both name lookup and
2482 pushing name into scope. In case a template parameter scope is present,
2483 namespace is pushed under the template parameter scope according to
2484 name lookup rule in 14.6.1/6.
2486 Return the former current scope suitable for pop_inner_scope. */
2489 push_inner_scope (tree inner)
2491 tree outer = current_scope ();
2493 outer = current_namespace;
2495 push_inner_scope_r (outer, inner);
2499 /* Exit the current scope INNER back to scope OUTER. */
2502 pop_inner_scope (tree outer, tree inner)
2505 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2508 while (outer != inner)
2510 if (TREE_CODE (inner) == NAMESPACE_DECL)
2512 struct cp_binding_level *save_template_parm = 0;
2513 /* Temporary take out template parameter scopes. They are saved
2514 in reversed order in save_template_parm. */
2515 while (current_binding_level->kind == sk_template_parms)
2517 struct cp_binding_level *b = current_binding_level;
2518 current_binding_level = b->level_chain;
2519 b->level_chain = save_template_parm;
2520 save_template_parm = b;
2525 /* Restore template parameter scopes. */
2526 while (save_template_parm)
2528 struct cp_binding_level *b = save_template_parm;
2529 save_template_parm = b->level_chain;
2530 b->level_chain = current_binding_level;
2531 current_binding_level = b;
2537 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2541 /* Do a pushlevel for class declarations. */
2544 pushlevel_class (void)
2546 if (ENABLE_SCOPE_CHECKING)
2549 class_binding_level = begin_scope (sk_class, current_class_type);
2552 /* ...and a poplevel for class declarations. */
2555 poplevel_class (void)
2557 struct cp_binding_level *level = class_binding_level;
2558 cp_class_binding *cb;
2562 timevar_push (TV_NAME_LOOKUP);
2563 gcc_assert (level != 0);
2565 /* If we're leaving a toplevel class, cache its binding level. */
2566 if (current_class_depth == 1)
2567 previous_class_level = level;
2568 for (shadowed = level->type_shadowed;
2570 shadowed = TREE_CHAIN (shadowed))
2571 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2573 /* Remove the bindings for all of the class-level declarations. */
2574 if (level->class_shadowed)
2577 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2579 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2580 ggc_free (level->class_shadowed);
2581 level->class_shadowed = NULL;
2584 /* Now, pop out of the binding level which we created up in the
2585 `pushlevel_class' routine. */
2586 if (ENABLE_SCOPE_CHECKING)
2590 timevar_pop (TV_NAME_LOOKUP);
2593 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2594 appropriate. DECL is the value to which a name has just been
2595 bound. CLASS_TYPE is the class in which the lookup occurred. */
2598 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2601 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2605 if (TREE_CODE (decl) == OVERLOAD)
2606 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2609 gcc_assert (DECL_P (decl));
2610 context = context_for_name_lookup (decl);
2613 if (is_properly_derived_from (class_type, context))
2614 INHERITED_VALUE_BINDING_P (binding) = 1;
2616 INHERITED_VALUE_BINDING_P (binding) = 0;
2618 else if (binding->value == decl)
2619 /* We only encounter a TREE_LIST when there is an ambiguity in the
2620 base classes. Such an ambiguity can be overridden by a
2621 definition in this class. */
2622 INHERITED_VALUE_BINDING_P (binding) = 1;
2624 INHERITED_VALUE_BINDING_P (binding) = 0;
2627 /* Make the declaration of X appear in CLASS scope. */
2630 pushdecl_class_level (tree x)
2633 bool is_valid = true;
2635 timevar_push (TV_NAME_LOOKUP);
2636 /* Get the name of X. */
2637 if (TREE_CODE (x) == OVERLOAD)
2638 name = DECL_NAME (get_first_fn (x));
2640 name = DECL_NAME (x);
2644 is_valid = push_class_level_binding (name, x);
2645 if (TREE_CODE (x) == TYPE_DECL)
2646 set_identifier_type_value (name, x);
2648 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2650 /* If X is an anonymous aggregate, all of its members are
2651 treated as if they were members of the class containing the
2652 aggregate, for naming purposes. */
2655 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2657 location_t save_location = input_location;
2658 input_location = DECL_SOURCE_LOCATION (f);
2659 if (!pushdecl_class_level (f))
2661 input_location = save_location;
2664 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2667 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2668 scope. If the value returned is non-NULL, and the PREVIOUS field
2669 is not set, callers must set the PREVIOUS field explicitly. */
2671 static cxx_binding *
2672 get_class_binding (tree name, cxx_scope *scope)
2677 cxx_binding *binding;
2679 class_type = scope->this_entity;
2681 /* Get the type binding. */
2682 type_binding = lookup_member (class_type, name,
2683 /*protect=*/2, /*want_type=*/true);
2684 /* Get the value binding. */
2685 value_binding = lookup_member (class_type, name,
2686 /*protect=*/2, /*want_type=*/false);
2689 && (TREE_CODE (value_binding) == TYPE_DECL
2690 || DECL_CLASS_TEMPLATE_P (value_binding)
2691 || (TREE_CODE (value_binding) == TREE_LIST
2692 && TREE_TYPE (value_binding) == error_mark_node
2693 && (TREE_CODE (TREE_VALUE (value_binding))
2695 /* We found a type binding, even when looking for a non-type
2696 binding. This means that we already processed this binding
2699 else if (value_binding)
2701 if (TREE_CODE (value_binding) == TREE_LIST
2702 && TREE_TYPE (value_binding) == error_mark_node)
2703 /* NAME is ambiguous. */
2705 else if (BASELINK_P (value_binding))
2706 /* NAME is some overloaded functions. */
2707 value_binding = BASELINK_FUNCTIONS (value_binding);
2710 /* If we found either a type binding or a value binding, create a
2711 new binding object. */
2712 if (type_binding || value_binding)
2714 binding = new_class_binding (name,
2718 /* This is a class-scope binding, not a block-scope binding. */
2719 LOCAL_BINDING_P (binding) = 0;
2720 set_inherited_value_binding_p (binding, value_binding, class_type);
2728 /* Make the declaration(s) of X appear in CLASS scope under the name
2729 NAME. Returns true if the binding is valid. */
2732 push_class_level_binding (tree name, tree x)
2734 cxx_binding *binding;
2738 timevar_push (TV_NAME_LOOKUP);
2739 /* The class_binding_level will be NULL if x is a template
2740 parameter name in a member template. */
2741 if (!class_binding_level)
2742 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2744 if (name == error_mark_node)
2745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2747 /* Check for invalid member names. */
2748 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2749 /* We could have been passed a tree list if this is an ambiguous
2750 declaration. If so, pull the declaration out because
2751 check_template_shadow will not handle a TREE_LIST. */
2752 if (TREE_CODE (decl) == TREE_LIST
2753 && TREE_TYPE (decl) == error_mark_node)
2754 decl = TREE_VALUE (decl);
2756 if (!check_template_shadow (decl))
2757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2761 If T is the name of a class, then each of the following shall
2762 have a name different from T:
2764 -- every static data member of class T;
2766 -- every member of class T that is itself a type;
2768 -- every enumerator of every member of class T that is an
2771 -- every member of every anonymous union that is a member of
2774 (Non-static data members were also forbidden to have the same
2775 name as T until TC1.) */
2776 if ((TREE_CODE (x) == VAR_DECL
2777 || TREE_CODE (x) == CONST_DECL
2778 || (TREE_CODE (x) == TYPE_DECL
2779 && !DECL_SELF_REFERENCE_P (x))
2780 /* A data member of an anonymous union. */
2781 || (TREE_CODE (x) == FIELD_DECL
2782 && DECL_CONTEXT (x) != current_class_type))
2783 && DECL_NAME (x) == constructor_name (current_class_type))
2785 tree scope = context_for_name_lookup (x);
2786 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2788 error ("%qD has the same name as the class in which it is "
2791 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2795 /* Get the current binding for NAME in this class, if any. */
2796 binding = IDENTIFIER_BINDING (name);
2797 if (!binding || binding->scope != class_binding_level)
2799 binding = get_class_binding (name, class_binding_level);
2800 /* If a new binding was created, put it at the front of the
2801 IDENTIFIER_BINDING list. */
2804 binding->previous = IDENTIFIER_BINDING (name);
2805 IDENTIFIER_BINDING (name) = binding;
2809 /* If there is already a binding, then we may need to update the
2811 if (binding && binding->value)
2813 tree bval = binding->value;
2814 tree old_decl = NULL_TREE;
2816 if (INHERITED_VALUE_BINDING_P (binding))
2818 /* If the old binding was from a base class, and was for a
2819 tag name, slide it over to make room for the new binding.
2820 The old binding is still visible if explicitly qualified
2821 with a class-key. */
2822 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2823 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2825 old_decl = binding->type;
2826 binding->type = bval;
2827 binding->value = NULL_TREE;
2828 INHERITED_VALUE_BINDING_P (binding) = 0;
2833 /* Any inherited type declaration is hidden by the type
2834 declaration in the derived class. */
2835 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2836 binding->type = NULL_TREE;
2839 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2841 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2842 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2843 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2845 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2846 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2848 if (old_decl && binding->scope == class_binding_level)
2851 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2852 here. This function is only used to register bindings
2853 from with the class definition itself. */
2854 INHERITED_VALUE_BINDING_P (binding) = 0;
2855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2859 /* Note that we declared this value so that we can issue an error if
2860 this is an invalid redeclaration of a name already used for some
2862 note_name_declared_in_class (name, decl);
2864 /* If we didn't replace an existing binding, put the binding on the
2865 stack of bindings for the identifier, and update the shadowed
2867 if (binding && binding->scope == class_binding_level)
2868 /* Supplement the existing binding. */
2869 ok = supplement_binding (binding, decl);
2872 /* Create a new binding. */
2873 push_binding (name, decl, class_binding_level);
2877 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2880 /* Process "using SCOPE::NAME" in a class scope. Return the
2881 USING_DECL created. */
2884 do_class_using_decl (tree scope, tree name)
2886 /* The USING_DECL returned by this function. */
2888 /* The declaration (or declarations) name by this using
2889 declaration. NULL if we are in a template and cannot figure out
2890 what has been named. */
2892 /* True if SCOPE is a dependent type. */
2893 bool scope_dependent_p;
2894 /* True if SCOPE::NAME is dependent. */
2895 bool name_dependent_p;
2896 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2897 bool bases_dependent_p;
2902 if (name == error_mark_node)
2905 if (!scope || !TYPE_P (scope))
2907 error ("using-declaration for non-member at class scope");
2911 /* Make sure the name is not invalid */
2912 if (TREE_CODE (name) == BIT_NOT_EXPR)
2914 error ("%<%T::%D%> names destructor", scope, name);
2917 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2919 error ("%<%T::%D%> names constructor", scope, name);
2922 if (constructor_name_p (name, current_class_type))
2924 error ("%<%T::%D%> names constructor in %qT",
2925 scope, name, current_class_type);
2929 scope_dependent_p = dependent_type_p (scope);
2930 name_dependent_p = (scope_dependent_p
2931 || (IDENTIFIER_TYPENAME_P (name)
2932 && dependent_type_p (TREE_TYPE (name))));
2934 bases_dependent_p = false;
2935 if (processing_template_decl)
2936 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2937 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2939 if (dependent_type_p (TREE_TYPE (base_binfo)))
2941 bases_dependent_p = true;
2947 /* From [namespace.udecl]:
2949 A using-declaration used as a member-declaration shall refer to a
2950 member of a base class of the class being defined.
2952 In general, we cannot check this constraint in a template because
2953 we do not know the entire set of base classes of the current
2954 class type. However, if all of the base classes are
2955 non-dependent, then we can avoid delaying the check until
2957 if (!scope_dependent_p)
2960 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2961 if (b_kind < bk_proper_base)
2963 if (!bases_dependent_p)
2965 error_not_base_type (scope, current_class_type);
2969 else if (!name_dependent_p)
2971 decl = lookup_member (binfo, name, 0, false);
2974 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2978 /* The binfo from which the functions came does not matter. */
2979 if (BASELINK_P (decl))
2980 decl = BASELINK_FUNCTIONS (decl);
2984 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2985 USING_DECL_DECLS (value) = decl;
2986 USING_DECL_SCOPE (value) = scope;
2987 DECL_DEPENDENT_P (value) = !decl;
2993 /* Return the binding value for name in scope. */
2996 namespace_binding (tree name, tree scope)
2998 cxx_binding *binding;
3001 scope = global_namespace;
3003 /* Unnecessary for the global namespace because it can't be an alias. */
3004 scope = ORIGINAL_NAMESPACE (scope);
3006 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3008 return binding ? binding->value : NULL_TREE;
3011 /* Set the binding value for name in scope. */
3014 set_namespace_binding (tree name, tree scope, tree val)
3018 timevar_push (TV_NAME_LOOKUP);
3019 if (scope == NULL_TREE)
3020 scope = global_namespace;
3021 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3022 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3025 supplement_binding (b, val);
3026 timevar_pop (TV_NAME_LOOKUP);
3029 /* Set the context of a declaration to scope. Complain if we are not
3033 set_decl_namespace (tree decl, tree scope, bool friendp)
3037 /* Get rid of namespace aliases. */
3038 scope = ORIGINAL_NAMESPACE (scope);
3040 /* It is ok for friends to be qualified in parallel space. */
3041 if (!friendp && !is_ancestor (current_namespace, scope))
3042 error ("declaration of %qD not in a namespace surrounding %qD",
3044 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3046 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3047 if (scope == current_namespace)
3049 if (at_namespace_scope_p ())
3050 error ("explicit qualification in declaration of %qD",
3055 /* See whether this has been declared in the namespace. */
3056 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3057 if (old == error_mark_node)
3058 /* No old declaration at all. */
3060 if (!is_overloaded_fn (decl))
3061 /* Don't compare non-function decls with decls_match here, since
3062 it can't check for the correct constness at this
3063 point. pushdecl will find those errors later. */
3065 /* Since decl is a function, old should contain a function decl. */
3066 if (!is_overloaded_fn (old))
3068 fn = OVL_CURRENT (old);
3069 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3071 /* A template can be explicitly specialized in any namespace. */
3072 if (processing_explicit_instantiation)
3074 if (processing_template_decl || processing_specialization)
3075 /* We have not yet called push_template_decl to turn a
3076 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3077 match. But, we'll check later, when we construct the
3080 /* Instantiations or specializations of templates may be declared as
3081 friends in any namespace. */
3082 if (friendp && DECL_USE_TEMPLATE (decl))
3084 if (is_overloaded_fn (old))
3086 for (; old; old = OVL_NEXT (old))
3087 if (decls_match (decl, OVL_CURRENT (old)))
3090 else if (decls_match (decl, old))
3093 error ("%qD should have been declared inside %qD", decl, scope);
3096 /* Return the namespace where the current declaration is declared. */
3099 current_decl_namespace (void)
3102 /* If we have been pushed into a different namespace, use it. */
3103 if (decl_namespace_list)
3104 return TREE_PURPOSE (decl_namespace_list);
3106 if (current_class_type)
3107 result = decl_namespace_context (current_class_type);
3108 else if (current_function_decl)
3109 result = decl_namespace_context (current_function_decl);
3111 result = current_namespace;
3115 /* Process any ATTRIBUTES on a namespace definition. Currently only
3116 attribute visibility is meaningful, which is a property of the syntactic
3117 block rather than the namespace as a whole, so we don't touch the
3118 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3121 handle_namespace_attrs (tree ns, tree attributes)
3124 bool saw_vis = false;
3126 for (d = attributes; d; d = TREE_CHAIN (d))
3128 tree name = TREE_PURPOSE (d);
3129 tree args = TREE_VALUE (d);
3131 #ifdef HANDLE_PRAGMA_VISIBILITY
3132 if (is_attribute_p ("visibility", name))
3134 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3135 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3137 warning (OPT_Wattributes,
3138 "%qD attribute requires a single NTBS argument",
3143 if (!TREE_PUBLIC (ns))
3144 warning (OPT_Wattributes,
3145 "%qD attribute is meaningless since members of the "
3146 "anonymous namespace get local symbols", name);
3148 push_visibility (TREE_STRING_POINTER (x));
3154 warning (OPT_Wattributes, "%qD attribute directive ignored",
3163 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3164 select a name that is unique to this compilation unit. */
3167 push_namespace (tree name)
3171 int implicit_use = 0;
3174 timevar_push (TV_NAME_LOOKUP);
3176 /* We should not get here if the global_namespace is not yet constructed
3177 nor if NAME designates the global namespace: The global scope is
3178 constructed elsewhere. */
3179 gcc_assert (global_namespace != NULL && name != global_scope_name);
3183 name = get_anonymous_namespace_name();
3184 d = IDENTIFIER_NAMESPACE_VALUE (name);
3186 /* Reopening anonymous namespace. */
3192 /* Check whether this is an extended namespace definition. */
3193 d = IDENTIFIER_NAMESPACE_VALUE (name);
3194 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3197 if (DECL_NAMESPACE_ALIAS (d))
3199 error ("namespace alias %qD not allowed here, assuming %qD",
3200 d, DECL_NAMESPACE_ALIAS (d));
3201 d = DECL_NAMESPACE_ALIAS (d);
3208 /* Make a new namespace, binding the name to it. */
3209 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3210 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3211 /* The name of this namespace is not visible to other translation
3212 units if it is an anonymous namespace or member thereof. */
3213 if (anon || decl_anon_ns_mem_p (current_namespace))
3214 TREE_PUBLIC (d) = 0;
3216 TREE_PUBLIC (d) = 1;
3220 /* Clear DECL_NAME for the benefit of debugging back ends. */
3221 SET_DECL_ASSEMBLER_NAME (d, name);
3222 DECL_NAME (d) = NULL_TREE;
3224 begin_scope (sk_namespace, d);
3227 resume_scope (NAMESPACE_LEVEL (d));
3230 do_using_directive (d);
3231 /* Enter the name space. */
3232 current_namespace = d;
3234 timevar_pop (TV_NAME_LOOKUP);
3237 /* Pop from the scope of the current namespace. */
3240 pop_namespace (void)
3242 gcc_assert (current_namespace != global_namespace);
3243 current_namespace = CP_DECL_CONTEXT (current_namespace);
3244 /* The binding level is not popped, as it might be re-opened later. */
3248 /* Push into the scope of the namespace NS, even if it is deeply
3249 nested within another namespace. */
3252 push_nested_namespace (tree ns)
3254 if (ns == global_namespace)
3255 push_to_top_level ();
3258 push_nested_namespace (CP_DECL_CONTEXT (ns));
3259 push_namespace (DECL_NAME (ns));
3263 /* Pop back from the scope of the namespace NS, which was previously
3264 entered with push_nested_namespace. */
3267 pop_nested_namespace (tree ns)
3269 timevar_push (TV_NAME_LOOKUP);
3270 while (ns != global_namespace)
3273 ns = CP_DECL_CONTEXT (ns);
3276 pop_from_top_level ();
3277 timevar_pop (TV_NAME_LOOKUP);
3280 /* Temporarily set the namespace for the current declaration. */
3283 push_decl_namespace (tree decl)
3285 if (TREE_CODE (decl) != NAMESPACE_DECL)
3286 decl = decl_namespace_context (decl);
3287 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3288 NULL_TREE, decl_namespace_list);
3291 /* [namespace.memdef]/2 */
3294 pop_decl_namespace (void)
3296 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3299 /* Return the namespace that is the common ancestor
3300 of two given namespaces. */
3303 namespace_ancestor (tree ns1, tree ns2)
3305 timevar_push (TV_NAME_LOOKUP);
3306 if (is_ancestor (ns1, ns2))
3307 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3308 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3309 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3312 /* Process a namespace-alias declaration. */
3315 do_namespace_alias (tree alias, tree name_space)
3317 if (name_space == error_mark_node)
3320 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3322 name_space = ORIGINAL_NAMESPACE (name_space);
3324 /* Build the alias. */
3325 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3326 DECL_NAMESPACE_ALIAS (alias) = name_space;
3327 DECL_EXTERNAL (alias) = 1;
3328 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3331 /* Emit debug info for namespace alias. */
3332 (*debug_hooks->global_decl) (alias);
3335 /* Like pushdecl, only it places X in the current namespace,
3339 pushdecl_namespace_level (tree x, bool is_friend)
3341 struct cp_binding_level *b = current_binding_level;
3344 timevar_push (TV_NAME_LOOKUP);
3345 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3347 /* Now, the type_shadowed stack may screw us. Munge it so it does
3349 if (TREE_CODE (t) == TYPE_DECL)
3351 tree name = DECL_NAME (t);
3353 tree *ptr = (tree *)0;
3354 for (; !global_scope_p (b); b = b->level_chain)
3356 tree shadowed = b->type_shadowed;
3357 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3358 if (TREE_PURPOSE (shadowed) == name)
3360 ptr = &TREE_VALUE (shadowed);
3361 /* Can't break out of the loop here because sometimes
3362 a binding level will have duplicate bindings for
3363 PT names. It's gross, but I haven't time to fix it. */
3366 newval = TREE_TYPE (t);
3367 if (ptr == (tree *)0)
3369 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3370 up here if this is changed to an assertion. --KR */
3371 SET_IDENTIFIER_TYPE_VALUE (name, t);
3378 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3381 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3382 directive is not directly from the source. Also find the common
3383 ancestor and let our users know about the new namespace */
3385 add_using_namespace (tree user, tree used, bool indirect)
3388 timevar_push (TV_NAME_LOOKUP);
3389 /* Using oneself is a no-op. */
3392 timevar_pop (TV_NAME_LOOKUP);
3395 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3396 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3397 /* Check if we already have this. */
3398 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3402 /* Promote to direct usage. */
3403 TREE_INDIRECT_USING (t) = 0;
3404 timevar_pop (TV_NAME_LOOKUP);
3408 /* Add used to the user's using list. */
3409 DECL_NAMESPACE_USING (user)
3410 = tree_cons (used, namespace_ancestor (user, used),
3411 DECL_NAMESPACE_USING (user));
3413 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3415 /* Add user to the used's users list. */
3416 DECL_NAMESPACE_USERS (used)
3417 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3419 /* Recursively add all namespaces used. */
3420 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3421 /* indirect usage */
3422 add_using_namespace (user, TREE_PURPOSE (t), 1);
3424 /* Tell everyone using us about the new used namespaces. */
3425 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3426 add_using_namespace (TREE_PURPOSE (t), used, 1);
3427 timevar_pop (TV_NAME_LOOKUP);
3430 /* Process a using-declaration not appearing in class or local scope. */
3433 do_toplevel_using_decl (tree decl, tree scope, tree name)
3435 tree oldval, oldtype, newval, newtype;
3436 tree orig_decl = decl;
3437 cxx_binding *binding;
3439 decl = validate_nonmember_using_decl (decl, scope, name);
3440 if (decl == NULL_TREE)
3443 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3445 oldval = binding->value;
3446 oldtype = binding->type;
3448 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3450 /* Emit debug info. */
3451 if (!processing_template_decl)
3452 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3454 /* Copy declarations found. */
3456 binding->value = newval;
3458 binding->type = newtype;
3461 /* Process a using-directive. */
3464 do_using_directive (tree name_space)
3466 tree context = NULL_TREE;
3468 if (name_space == error_mark_node)
3471 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3473 if (building_stmt_tree ())
3474 add_stmt (build_stmt (USING_STMT, name_space));
3475 name_space = ORIGINAL_NAMESPACE (name_space);
3477 if (!toplevel_bindings_p ())
3479 push_using_directive (name_space);
3480 context = current_scope ();
3485 add_using_namespace (current_namespace, name_space, 0);
3486 if (current_namespace != global_namespace)
3487 context = current_namespace;
3490 /* Emit debugging info. */
3491 if (!processing_template_decl)
3492 (*debug_hooks->imported_module_or_decl) (name_space, context);
3495 /* Deal with a using-directive seen by the parser. Currently we only
3496 handle attributes here, since they cannot appear inside a template. */
3499 parse_using_directive (tree name_space, tree attribs)
3503 do_using_directive (name_space);
3505 for (a = attribs; a; a = TREE_CHAIN (a))
3507 tree name = TREE_PURPOSE (a);
3508 if (is_attribute_p ("strong", name))
3510 if (!toplevel_bindings_p ())
3511 error ("strong using only meaningful at namespace scope");
3512 else if (name_space != error_mark_node)
3514 if (!is_ancestor (current_namespace, name_space))
3515 error ("current namespace %qD does not enclose strongly used namespace %qD",
3516 current_namespace, name_space);
3517 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3518 = tree_cons (current_namespace, 0,
3519 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3523 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3527 /* Like pushdecl, only it places X in the global scope if appropriate.
3528 Calls cp_finish_decl to register the variable, initializing it with
3529 *INIT, if INIT is non-NULL. */
3532 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3534 timevar_push (TV_NAME_LOOKUP);
3535 push_to_top_level ();
3536 x = pushdecl_namespace_level (x, is_friend);
3538 finish_decl (x, *init, NULL_TREE);
3539 pop_from_top_level ();
3540 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3543 /* Like pushdecl, only it places X in the global scope if appropriate. */
3546 pushdecl_top_level (tree x)
3548 return pushdecl_top_level_1 (x, NULL, false);
3551 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3554 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3556 return pushdecl_top_level_1 (x, NULL, is_friend);
3559 /* Like pushdecl, only it places X in the global scope if
3560 appropriate. Calls cp_finish_decl to register the variable,
3561 initializing it with INIT. */
3564 pushdecl_top_level_and_finish (tree x, tree init)
3566 return pushdecl_top_level_1 (x, &init, false);
3569 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3570 duplicates. The first list becomes the tail of the result.
3572 The algorithm is O(n^2). We could get this down to O(n log n) by
3573 doing a sort on the addresses of the functions, if that becomes
3577 merge_functions (tree s1, tree s2)
3579 for (; s2; s2 = OVL_NEXT (s2))
3581 tree fn2 = OVL_CURRENT (s2);
3584 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3586 tree fn1 = OVL_CURRENT (fns1);
3588 /* If the function from S2 is already in S1, there is no
3589 need to add it again. For `extern "C"' functions, we
3590 might have two FUNCTION_DECLs for the same function, in
3591 different namespaces; again, we only need one of them. */
3593 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3594 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3598 /* If we exhausted all of the functions in S1, FN2 is new. */
3600 s1 = build_overload (fn2, s1);
3605 /* This should return an error not all definitions define functions.
3606 It is not an error if we find two functions with exactly the
3607 same signature, only if these are selected in overload resolution.
3608 old is the current set of bindings, new_binding the freshly-found binding.
3609 XXX Do we want to give *all* candidates in case of ambiguity?
3610 XXX In what way should I treat extern declarations?
3611 XXX I don't want to repeat the entire duplicate_decls here */
3614 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3617 gcc_assert (old != NULL);
3619 /* Copy the type. */
3620 type = new_binding->type;
3621 if (LOOKUP_NAMESPACES_ONLY (flags)
3622 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3625 /* Copy the value. */
3626 val = new_binding->value;
3629 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3632 switch (TREE_CODE (val))
3635 /* If we expect types or namespaces, and not templates,
3636 or this is not a template class. */
3637 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3638 && !DECL_CLASS_TEMPLATE_P (val)))
3642 if (LOOKUP_NAMESPACES_ONLY (flags)
3643 || (type && (flags & LOOKUP_PREFER_TYPES)))
3646 case NAMESPACE_DECL:
3647 if (LOOKUP_TYPES_ONLY (flags))
3651 /* Ignore built-in functions that are still anticipated. */
3652 if (LOOKUP_QUALIFIERS_ONLY (flags))
3656 if (LOOKUP_QUALIFIERS_ONLY (flags))
3661 /* If val is hidden, shift down any class or enumeration name. */
3670 else if (val && val != old->value)
3672 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3673 old->value = merge_functions (old->value, val);
3676 old->value = tree_cons (NULL_TREE, old->value,
3677 build_tree_list (NULL_TREE, val));
3678 TREE_TYPE (old->value) = error_mark_node;
3684 else if (type && old->type != type)
3686 old->type = tree_cons (NULL_TREE, old->type,
3687 build_tree_list (NULL_TREE, type));
3688 TREE_TYPE (old->type) = error_mark_node;
3692 /* Return the declarations that are members of the namespace NS. */
3695 cp_namespace_decls (tree ns)
3697 return NAMESPACE_LEVEL (ns)->names;
3700 /* Combine prefer_type and namespaces_only into flags. */
3703 lookup_flags (int prefer_type, int namespaces_only)
3705 if (namespaces_only)
3706 return LOOKUP_PREFER_NAMESPACES;
3707 if (prefer_type > 1)
3708 return LOOKUP_PREFER_TYPES;
3709 if (prefer_type > 0)
3710 return LOOKUP_PREFER_BOTH;
3714 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3715 ignore it or not. Subroutine of lookup_name_real and
3716 lookup_type_scope. */
3719 qualify_lookup (tree val, int flags)
3721 if (val == NULL_TREE)
3723 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3725 if ((flags & LOOKUP_PREFER_TYPES)
3726 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3728 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3733 /* Given a lookup that returned VAL, decide if we want to ignore it or
3734 not based on DECL_ANTICIPATED. */
3737 hidden_name_p (tree val)
3740 && DECL_LANG_SPECIFIC (val)
3741 && DECL_ANTICIPATED (val))
3746 /* Remove any hidden friend functions from a possibly overloaded set
3750 remove_hidden_names (tree fns)
3755 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3757 else if (TREE_CODE (fns) == OVERLOAD)
3761 for (o = fns; o; o = OVL_NEXT (o))
3762 if (hidden_name_p (OVL_CURRENT (o)))
3768 for (o = fns; o; o = OVL_NEXT (o))
3769 if (!hidden_name_p (OVL_CURRENT (o)))
3770 n = build_overload (OVL_CURRENT (o), n);
3778 /* Unscoped lookup of a global: iterate over current namespaces,
3779 considering using-directives. */
3782 unqualified_namespace_lookup (tree name, int flags)
3784 tree initial = current_decl_namespace ();
3785 tree scope = initial;
3787 struct cp_binding_level *level;
3788 tree val = NULL_TREE;
3790 timevar_push (TV_NAME_LOOKUP);
3792 for (; !val; scope = CP_DECL_CONTEXT (scope))
3794 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3796 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3799 ambiguous_decl (&binding, b, flags);
3801 /* Add all _DECLs seen through local using-directives. */
3802 for (level = current_binding_level;
3803 level->kind != sk_namespace;
3804 level = level->level_chain)
3805 if (!lookup_using_namespace (name, &binding, level->using_directives,
3807 /* Give up because of error. */
3808 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3810 /* Add all _DECLs seen through global using-directives. */
3811 /* XXX local and global using lists should work equally. */
3815 if (!lookup_using_namespace (name, &binding,
3816 DECL_NAMESPACE_USING (siter),
3818 /* Give up because of error. */
3819 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3820 if (siter == scope) break;
3821 siter = CP_DECL_CONTEXT (siter);
3824 val = binding.value;
3825 if (scope == global_namespace)
3828 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3831 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3832 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3835 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3836 declaration found. If no suitable declaration can be found,
3837 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3838 neither a class-type nor a namespace a diagnostic is issued. */
3841 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3846 if (TREE_CODE (scope) == NAMESPACE_DECL)
3848 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3850 flags |= LOOKUP_COMPLAIN;
3852 flags |= LOOKUP_PREFER_TYPES;
3853 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3856 else if (is_class_type (scope, complain))
3857 t = lookup_member (scope, name, 2, is_type_p);
3860 return error_mark_node;
3864 /* Subroutine of unqualified_namespace_lookup:
3865 Add the bindings of NAME in used namespaces to VAL.
3866 We are currently looking for names in namespace SCOPE, so we
3867 look through USINGS for using-directives of namespaces
3868 which have SCOPE as a common ancestor with the current scope.
3869 Returns false on errors. */
3872 lookup_using_namespace (tree name, struct scope_binding *val,
3873 tree usings, tree scope, int flags)
3876 timevar_push (TV_NAME_LOOKUP);
3877 /* Iterate over all used namespaces in current, searching for using
3878 directives of scope. */
3879 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3880 if (TREE_VALUE (iter) == scope)
3882 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3884 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3885 /* Resolve ambiguities. */
3887 ambiguous_decl (val, val1, flags);
3889 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3893 Accepts the NAME to lookup and its qualifying SCOPE.
3894 Returns the name/type pair found into the cxx_binding *RESULT,
3895 or false on error. */
3898 qualified_lookup_using_namespace (tree name, tree scope,
3899 struct scope_binding *result, int flags)
3901 /* Maintain a list of namespaces visited... */
3902 tree seen = NULL_TREE;
3903 /* ... and a list of namespace yet to see. */
3904 tree todo = NULL_TREE;
3905 tree todo_maybe = NULL_TREE;
3907 timevar_push (TV_NAME_LOOKUP);
3908 /* Look through namespace aliases. */
3909 scope = ORIGINAL_NAMESPACE (scope);
3910 while (scope && result->value != error_mark_node)
3912 cxx_binding *binding =
3913 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3914 seen = tree_cons (scope, NULL_TREE, seen);
3916 ambiguous_decl (result, binding, flags);
3918 /* Consider strong using directives always, and non-strong ones
3919 if we haven't found a binding yet. ??? Shouldn't we consider
3920 non-strong ones if the initial RESULT is non-NULL, but the
3921 binding in the given namespace is? */
3922 for (usings = DECL_NAMESPACE_USING (scope); usings;
3923 usings = TREE_CHAIN (usings))
3924 /* If this was a real directive, and we have not seen it. */
3925 if (!TREE_INDIRECT_USING (usings))
3927 /* Try to avoid queuing the same namespace more than once,
3928 the exception being when a namespace was already
3929 enqueued for todo_maybe and then a strong using is
3930 found for it. We could try to remove it from
3931 todo_maybe, but it's probably not worth the effort. */
3932 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3933 && !purpose_member (TREE_PURPOSE (usings), seen)
3934 && !purpose_member (TREE_PURPOSE (usings), todo))
3935 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3936 else if ((!result->value && !result->type)
3937 && !purpose_member (TREE_PURPOSE (usings), seen)
3938 && !purpose_member (TREE_PURPOSE (usings), todo)
3939 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3940 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3945 scope = TREE_PURPOSE (todo);
3946 todo = TREE_CHAIN (todo);
3949 && (!result->value && !result->type))
3951 scope = TREE_PURPOSE (todo_maybe);
3952 todo = TREE_CHAIN (todo_maybe);
3953 todo_maybe = NULL_TREE;
3956 scope = NULL_TREE; /* If there never was a todo list. */
3958 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3961 /* Return the innermost non-namespace binding for NAME from a scope
3962 containing BINDING, or, if BINDING is NULL, the current scope. If
3963 CLASS_P is false, then class bindings are ignored. */
3966 outer_binding (tree name,
3967 cxx_binding *binding,
3972 cxx_scope *outer_scope;
3976 scope = binding->scope->level_chain;
3977 outer = binding->previous;
3981 scope = current_binding_level;
3982 outer = IDENTIFIER_BINDING (name);
3984 outer_scope = outer ? outer->scope : NULL;
3986 /* Because we create class bindings lazily, we might be missing a
3987 class binding for NAME. If there are any class binding levels
3988 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3989 declared, we must lookup NAME in those class scopes. */
3991 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3993 if (scope->kind == sk_class)
3995 cxx_binding *class_binding;
3997 class_binding = get_class_binding (name, scope);
4000 /* Thread this new class-scope binding onto the
4001 IDENTIFIER_BINDING list so that future lookups
4003 class_binding->previous = outer;
4005 binding->previous = class_binding;
4007 IDENTIFIER_BINDING (name) = class_binding;
4008 return class_binding;
4011 scope = scope->level_chain;
4017 /* Return the innermost block-scope or class-scope value binding for
4018 NAME, or NULL_TREE if there is no such binding. */
4021 innermost_non_namespace_value (tree name)
4023 cxx_binding *binding;
4024 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4025 return binding ? binding->value : NULL_TREE;
4028 /* Look up NAME in the current binding level and its superiors in the
4029 namespace of variables, functions and typedefs. Return a ..._DECL
4030 node of some kind representing its definition if there is only one
4031 such declaration, or return a TREE_LIST with all the overloaded
4032 definitions if there are many, or return 0 if it is undefined.
4033 Hidden name, either friend declaration or built-in function, are
4036 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4037 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4038 Otherwise we prefer non-TYPE_DECLs.
4040 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4041 BLOCK_P is false, bindings in block scopes are ignored. */
4044 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4045 int namespaces_only, int flags)
4048 tree val = NULL_TREE;
4050 timevar_push (TV_NAME_LOOKUP);
4051 /* Conversion operators are handled specially because ordinary
4052 unqualified name lookup will not find template conversion
4054 if (IDENTIFIER_TYPENAME_P (name))
4056 struct cp_binding_level *level;
4058 for (level = current_binding_level;
4059 level && level->kind != sk_namespace;
4060 level = level->level_chain)
4065 /* A conversion operator can only be declared in a class
4067 if (level->kind != sk_class)
4070 /* Lookup the conversion operator in the class. */
4071 class_type = level->this_entity;
4072 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4074 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4077 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4080 flags |= lookup_flags (prefer_type, namespaces_only);
4082 /* First, look in non-namespace scopes. */
4084 if (current_class_type == NULL_TREE)
4087 if (block_p || !nonclass)
4088 for (iter = outer_binding (name, NULL, !nonclass);
4090 iter = outer_binding (name, iter, !nonclass))
4094 /* Skip entities we don't want. */
4095 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4098 /* If this is the kind of thing we're looking for, we're done. */
4099 if (qualify_lookup (iter->value, flags))
4100 binding = iter->value;
4101 else if ((flags & LOOKUP_PREFER_TYPES)
4102 && qualify_lookup (iter->type, flags))
4103 binding = iter->type;
4105 binding = NULL_TREE;
4109 if (hidden_name_p (binding))
4111 /* A non namespace-scope binding can only be hidden if
4112 we are in a local class, due to friend declarations.
4113 In particular, consider:
4118 void g() { B* b; } // error: B is hidden
4123 The standard says that "B" is a local class in "f"
4124 (but not nested within "A") -- but that name lookup
4125 for "B" does not find this declaration until it is
4126 declared directly with "f".
4132 If a friend declaration appears in a local class and
4133 the name specified is an unqualified name, a prior
4134 declaration is looked up without considering scopes
4135 that are outside the innermost enclosing non-class
4136 scope. For a friend class declaration, if there is no
4137 prior declaration, the class that is specified
4138 belongs to the innermost enclosing non-class scope,
4139 but if it is subsequently referenced, its name is not
4140 found by name lookup until a matching declaration is
4141 provided in the innermost enclosing nonclass scope.
4143 gcc_assert (current_class_type &&
4144 LOCAL_CLASS_P (current_class_type));
4146 /* This binding comes from a friend declaration in the local
4147 class. The standard (11.4.8) states that the lookup can
4148 only succeed if there is a non-hidden declaration in the
4149 current scope, which is not the case here. */
4150 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4157 /* Now lookup in namespace scopes. */
4159 val = unqualified_namespace_lookup (name, flags);
4161 /* If we have a single function from a using decl, pull it out. */
4162 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4163 val = OVL_FUNCTION (val);
4165 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4169 lookup_name_nonclass (tree name)
4171 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4175 lookup_function_nonclass (tree name, tree args, bool block_p)
4178 lookup_arg_dependent (name,
4179 lookup_name_real (name, 0, 1, block_p, 0,
4185 lookup_name (tree name)
4187 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4191 lookup_name_prefer_type (tree name, int prefer_type)
4193 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4194 0, LOOKUP_COMPLAIN);
4197 /* Look up NAME for type used in elaborated name specifier in
4198 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4199 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4200 name, more scopes are checked if cleanup or template parameter
4201 scope is encountered.
4203 Unlike lookup_name_real, we make sure that NAME is actually
4204 declared in the desired scope, not from inheritance, nor using
4205 directive. For using declaration, there is DR138 still waiting
4206 to be resolved. Hidden name coming from an earlier friend
4207 declaration is also returned.
4209 A TYPE_DECL best matching the NAME is returned. Catching error
4210 and issuing diagnostics are caller's responsibility. */
4213 lookup_type_scope (tree name, tag_scope scope)
4215 cxx_binding *iter = NULL;
4216 tree val = NULL_TREE;
4218 timevar_push (TV_NAME_LOOKUP);
4220 /* Look in non-namespace scope first. */
4221 if (current_binding_level->kind != sk_namespace)
4222 iter = outer_binding (name, NULL, /*class_p=*/ true);
4223 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4225 /* Check if this is the kind of thing we're looking for.
4226 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4227 base class. For ITER->VALUE, we can simply use
4228 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4231 We check ITER->TYPE before ITER->VALUE in order to handle
4232 typedef struct C {} C;
4235 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4236 && (scope != ts_current
4237 || LOCAL_BINDING_P (iter)
4238 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4240 else if ((scope != ts_current
4241 || !INHERITED_VALUE_BINDING_P (iter))
4242 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4249 /* Look in namespace scope. */
4252 iter = cxx_scope_find_binding_for_name
4253 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4257 /* If this is the kind of thing we're looking for, we're done. */
4258 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4260 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4266 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4267 and template parameter scopes. */
4270 struct cp_binding_level *b = current_binding_level;
4273 if (iter->scope == b)
4274 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4276 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4278 else if (b->kind == sk_class
4279 && scope == ts_within_enclosing_non_class)
4286 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4289 /* Similar to `lookup_name' but look only in the innermost non-class
4293 lookup_name_innermost_nonclass_level (tree name)
4295 struct cp_binding_level *b;
4298 timevar_push (TV_NAME_LOOKUP);
4299 b = innermost_nonclass_level ();
4301 if (b->kind == sk_namespace)
4303 t = IDENTIFIER_NAMESPACE_VALUE (name);
4305 /* extern "C" function() */
4306 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4309 else if (IDENTIFIER_BINDING (name)
4310 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4312 cxx_binding *binding;
4313 binding = IDENTIFIER_BINDING (name);
4316 if (binding->scope == b
4317 && !(TREE_CODE (binding->value) == VAR_DECL
4318 && DECL_DEAD_FOR_LOCAL (binding->value)))
4319 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4321 if (b->kind == sk_cleanup)
4328 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4331 /* Like lookup_name_innermost_nonclass_level, but for types. */
4334 lookup_type_current_level (tree name)
4338 timevar_push (TV_NAME_LOOKUP);
4339 gcc_assert (current_binding_level->kind != sk_namespace);
4341 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4342 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4344 struct cp_binding_level *b = current_binding_level;
4347 if (purpose_member (name, b->type_shadowed))
4348 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4349 REAL_IDENTIFIER_TYPE_VALUE (name));
4350 if (b->kind == sk_cleanup)
4357 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4360 /* [basic.lookup.koenig] */
4361 /* A nonzero return value in the functions below indicates an error. */
4372 static bool arg_assoc (struct arg_lookup*, tree);
4373 static bool arg_assoc_args (struct arg_lookup*, tree);
4374 static bool arg_assoc_type (struct arg_lookup*, tree);
4375 static bool add_function (struct arg_lookup *, tree);
4376 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4377 static bool arg_assoc_class (struct arg_lookup *, tree);
4378 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4380 /* Add a function to the lookup structure.
4381 Returns true on error. */
4384 add_function (struct arg_lookup *k, tree fn)
4386 /* We used to check here to see if the function was already in the list,
4387 but that's O(n^2), which is just too expensive for function lookup.
4388 Now we deal with the occasional duplicate in joust. In doing this, we
4389 assume that the number of duplicates will be small compared to the
4390 total number of functions being compared, which should usually be the
4393 /* We must find only functions, or exactly one non-function. */
4396 else if (fn == k->functions)
4398 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4399 k->functions = build_overload (fn, k->functions);
4402 tree f1 = OVL_CURRENT (k->functions);
4404 if (is_overloaded_fn (f1))
4406 fn = f1; f1 = f2; f2 = fn;
4408 error ("%q+D is not a function,", f1);
4409 error (" conflict with %q+D", f2);
4410 error (" in call to %qD", k->name);
4417 /* Returns true iff CURRENT has declared itself to be an associated
4418 namespace of SCOPE via a strong using-directive (or transitive chain
4419 thereof). Both are namespaces. */
4422 is_associated_namespace (tree current, tree scope)
4424 tree seen = NULL_TREE;
4425 tree todo = NULL_TREE;
4429 if (scope == current)
4431 seen = tree_cons (scope, NULL_TREE, seen);
4432 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4433 if (!purpose_member (TREE_PURPOSE (t), seen))
4434 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4437 scope = TREE_PURPOSE (todo);
4438 todo = TREE_CHAIN (todo);
4445 /* Return whether FN is a friend of an associated class of ARG. */
4448 friend_of_associated_class_p (tree arg, tree fn)
4454 else if (type_unknown_p (arg))
4457 type = TREE_TYPE (arg);
4459 /* If TYPE is a class, the class itself and all base classes are
4460 associated classes. */
4461 if (CLASS_TYPE_P (type))
4463 if (is_friend (type, fn))
4466 if (TYPE_BINFO (type))
4468 tree binfo, base_binfo;
4471 for (binfo = TYPE_BINFO (type), i = 0;
4472 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4474 if (is_friend (BINFO_TYPE (base_binfo), fn))
4479 /* If TYPE is a class member, the class of which it is a member is
4480 an associated class. */
4481 if ((CLASS_TYPE_P (type)
4482 || TREE_CODE (type) == UNION_TYPE
4483 || TREE_CODE (type) == ENUMERAL_TYPE)
4484 && TYPE_CONTEXT (type)
4485 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4486 && is_friend (TYPE_CONTEXT (type), fn))
4492 /* Add functions of a namespace to the lookup structure.
4493 Returns true on error. */
4496 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4500 if (purpose_member (scope, k->namespaces))
4502 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4504 /* Check out our super-users. */
4505 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4506 value = TREE_CHAIN (value))
4507 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4510 /* Also look down into inline namespaces. */
4511 for (value = DECL_NAMESPACE_USING (scope); value;
4512 value = TREE_CHAIN (value))
4513 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4514 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4517 value = namespace_binding (k->name, scope);
4521 for (; value; value = OVL_NEXT (value))
4523 /* We don't want to find arbitrary hidden functions via argument
4524 dependent lookup. We only want to find friends of associated
4526 if (hidden_name_p (OVL_CURRENT (value)))
4530 for (args = k->args; args; args = TREE_CHAIN (args))
4531 if (friend_of_associated_class_p (TREE_VALUE (args),
4532 OVL_CURRENT (value)))
4538 if (add_function (k, OVL_CURRENT (value)))
4545 /* Adds everything associated with a template argument to the lookup
4546 structure. Returns true on error. */
4549 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4551 /* [basic.lookup.koenig]
4553 If T is a template-id, its associated namespaces and classes are
4554 ... the namespaces and classes associated with the types of the
4555 template arguments provided for template type parameters
4556 (excluding template template parameters); the namespaces in which
4557 any template template arguments are defined; and the classes in
4558 which any member templates used as template template arguments
4559 are defined. [Note: non-type template arguments do not
4560 contribute to the set of associated namespaces. ] */
4562 /* Consider first template template arguments. */
4563 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4564 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4566 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4568 tree ctx = CP_DECL_CONTEXT (arg);
4570 /* It's not a member template. */
4571 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4572 return arg_assoc_namespace (k, ctx);
4573 /* Otherwise, it must be member template. */
4575 return arg_assoc_class (k, ctx);
4577 /* It's an argument pack; handle it recursively. */
4578 else if (ARGUMENT_PACK_P (arg))
4580 tree args = ARGUMENT_PACK_ARGS (arg);
4581 int i, len = TREE_VEC_LENGTH (args);
4582 for (i = 0; i < len; ++i)
4583 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4588 /* It's not a template template argument, but it is a type template
4590 else if (TYPE_P (arg))
4591 return arg_assoc_type (k, arg);
4592 /* It's a non-type template argument. */
4597 /* Adds everything associated with class to the lookup structure.
4598 Returns true on error. */
4601 arg_assoc_class (struct arg_lookup *k, tree type)
4603 tree list, friends, context;
4606 /* Backend build structures, such as __builtin_va_list, aren't
4607 affected by all this. */
4608 if (!CLASS_TYPE_P (type))
4611 if (purpose_member (type, k->classes))
4613 k->classes = tree_cons (type, NULL_TREE, k->classes);
4615 context = decl_namespace_context (type);
4616 if (arg_assoc_namespace (k, context))
4619 if (TYPE_BINFO (type))
4621 /* Process baseclasses. */
4622 tree binfo, base_binfo;
4624 for (binfo = TYPE_BINFO (type), i = 0;
4625 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4626 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4630 /* Process friends. */
4631 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4632 list = TREE_CHAIN (list))
4633 if (k->name == FRIEND_NAME (list))
4634 for (friends = FRIEND_DECLS (list); friends;
4635 friends = TREE_CHAIN (friends))
4637 tree fn = TREE_VALUE (friends);
4639 /* Only interested in global functions with potentially hidden
4640 (i.e. unqualified) declarations. */
4641 if (CP_DECL_CONTEXT (fn) != context)
4643 /* Template specializations are never found by name lookup.
4644 (Templates themselves can be found, but not template
4645 specializations.) */
4646 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4648 if (add_function (k, fn))
4652 /* Process template arguments. */
4653 if (CLASSTYPE_TEMPLATE_INFO (type)
4654 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4656 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4657 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4658 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4664 /* Adds everything associated with a given type.
4665 Returns 1 on error. */
4668 arg_assoc_type (struct arg_lookup *k, tree type)
4670 /* As we do not get the type of non-type dependent expressions
4671 right, we can end up with such things without a type. */
4675 if (TYPE_PTRMEM_P (type))
4677 /* Pointer to member: associate class type and value type. */
4678 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4680 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4682 else switch (TREE_CODE (type))
4692 case FIXED_POINT_TYPE:
4695 if (TYPE_PTRMEMFUNC_P (type))
4696 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4697 return arg_assoc_class (k, type);
4699 case REFERENCE_TYPE:
4701 return arg_assoc_type (k, TREE_TYPE (type));
4704 return arg_assoc_namespace (k, decl_namespace_context (type));
4706 /* The basetype is referenced in the first arg type, so just
4709 /* Associate the parameter types. */
4710 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4712 /* Associate the return type. */
4713 return arg_assoc_type (k, TREE_TYPE (type));
4714 case TEMPLATE_TYPE_PARM:
4715 case BOUND_TEMPLATE_TEMPLATE_PARM:
4720 gcc_assert (type == unknown_type_node
4721 || type == init_list_type_node);
4723 case TYPE_PACK_EXPANSION:
4724 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4732 /* Adds everything associated with arguments. Returns true on error. */
4735 arg_assoc_args (struct arg_lookup *k, tree args)
4737 for (; args; args = TREE_CHAIN (args))
4738 if (arg_assoc (k, TREE_VALUE (args)))
4743 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4746 arg_assoc (struct arg_lookup *k, tree n)
4748 if (n == error_mark_node)
4752 return arg_assoc_type (k, n);
4754 if (! type_unknown_p (n))
4755 return arg_assoc_type (k, TREE_TYPE (n));
4757 if (TREE_CODE (n) == ADDR_EXPR)
4758 n = TREE_OPERAND (n, 0);
4759 if (TREE_CODE (n) == COMPONENT_REF)
4760 n = TREE_OPERAND (n, 1);
4761 if (TREE_CODE (n) == OFFSET_REF)
4762 n = TREE_OPERAND (n, 1);
4763 while (TREE_CODE (n) == TREE_LIST)
4765 if (TREE_CODE (n) == BASELINK)
4766 n = BASELINK_FUNCTIONS (n);
4768 if (TREE_CODE (n) == FUNCTION_DECL)
4769 return arg_assoc_type (k, TREE_TYPE (n));
4770 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4772 /* [basic.lookup.koenig]
4774 If T is a template-id, its associated namespaces and classes
4775 are the namespace in which the template is defined; for
4776 member templates, the member template's class... */
4777 tree templ = TREE_OPERAND (n, 0);
4778 tree args = TREE_OPERAND (n, 1);
4782 if (TREE_CODE (templ) == COMPONENT_REF)
4783 templ = TREE_OPERAND (templ, 1);
4785 /* First, the template. There may actually be more than one if
4786 this is an overloaded function template. But, in that case,
4787 we only need the first; all the functions will be in the same
4789 templ = OVL_CURRENT (templ);
4791 ctx = CP_DECL_CONTEXT (templ);
4793 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4795 if (arg_assoc_namespace (k, ctx) == 1)
4798 /* It must be a member template. */
4799 else if (arg_assoc_class (k, ctx) == 1)
4802 /* Now the arguments. */
4804 for (ix = TREE_VEC_LENGTH (args); ix--;)
4805 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4808 else if (TREE_CODE (n) == OVERLOAD)
4810 for (; n; n = OVL_CHAIN (n))
4811 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4818 /* Performs Koenig lookup depending on arguments, where fns
4819 are the functions found in normal lookup. */
4822 lookup_arg_dependent (tree name, tree fns, tree args)
4824 struct arg_lookup k;
4826 timevar_push (TV_NAME_LOOKUP);
4828 /* Remove any hidden friend functions from the list of functions
4829 found so far. They will be added back by arg_assoc_class as
4831 fns = remove_hidden_names (fns);
4836 k.classes = NULL_TREE;
4838 /* We previously performed an optimization here by setting
4839 NAMESPACES to the current namespace when it was safe. However, DR
4840 164 says that namespaces that were already searched in the first
4841 stage of template processing are searched again (potentially
4842 picking up later definitions) in the second stage. */
4843 k.namespaces = NULL_TREE;
4845 arg_assoc_args (&k, args);
4850 && TREE_CODE (fns) != VAR_DECL
4851 && !is_overloaded_fn (fns))
4853 error ("argument dependent lookup finds %q+D", fns);
4854 error (" in call to %qD", name);
4855 fns = error_mark_node;
4858 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4861 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4862 changed (i.e. there was already a directive), or the fresh
4863 TREE_LIST otherwise. */
4866 push_using_directive (tree used)
4868 tree ud = current_binding_level->using_directives;
4869 tree iter, ancestor;
4871 timevar_push (TV_NAME_LOOKUP);
4872 /* Check if we already have this. */
4873 if (purpose_member (used, ud) != NULL_TREE)
4874 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4876 ancestor = namespace_ancestor (current_decl_namespace (), used);
4877 ud = current_binding_level->using_directives;
4878 ud = tree_cons (used, ancestor, ud);
4879 current_binding_level->using_directives = ud;
4881 /* Recursively add all namespaces used. */
4882 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4883 push_using_directive (TREE_PURPOSE (iter));
4885 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4888 /* The type TYPE is being declared. If it is a class template, or a
4889 specialization of a class template, do any processing required and
4890 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4891 being declared a friend. B is the binding level at which this TYPE
4894 Returns the TYPE_DECL for TYPE, which may have been altered by this
4898 maybe_process_template_type_declaration (tree type, int is_friend,
4901 tree decl = TYPE_NAME (type);
4903 if (processing_template_parmlist)
4904 /* You can't declare a new template type in a template parameter
4905 list. But, you can declare a non-template type:
4907 template <class A*> struct S;
4909 is a forward-declaration of `A'. */
4911 else if (b->kind == sk_namespace
4912 && current_binding_level->kind != sk_namespace)
4913 /* If this new type is being injected into a containing scope,
4914 then it's not a template type. */
4918 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4919 || TREE_CODE (type) == ENUMERAL_TYPE);
4921 if (processing_template_decl)
4923 /* This may change after the call to
4924 push_template_decl_real, but we want the original value. */
4925 tree name = DECL_NAME (decl);
4927 decl = push_template_decl_real (decl, is_friend);
4928 /* If the current binding level is the binding level for the
4929 template parameters (see the comment in
4930 begin_template_parm_list) and the enclosing level is a class
4931 scope, and we're not looking at a friend, push the
4932 declaration of the member class into the class scope. In the
4933 friend case, push_template_decl will already have put the
4934 friend into global scope, if appropriate. */
4935 if (TREE_CODE (type) != ENUMERAL_TYPE
4936 && !is_friend && b->kind == sk_template_parms
4937 && b->level_chain->kind == sk_class)
4939 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4941 if (!COMPLETE_TYPE_P (current_class_type))
4943 maybe_add_class_template_decl_list (current_class_type,
4944 type, /*friend_p=*/0);
4945 /* Put this UTD in the table of UTDs for the class. */
4946 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4947 CLASSTYPE_NESTED_UTDS (current_class_type) =
4948 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4950 binding_table_insert
4951 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4960 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4961 that the NAME is a class template, the tag is processed but not pushed.
4963 The pushed scope depend on the SCOPE parameter:
4964 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4966 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4967 non-template-parameter scope. This case is needed for forward
4969 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4970 TS_GLOBAL case except that names within template-parameter scopes
4971 are not pushed at all.
4973 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4976 pushtag (tree name, tree type, tag_scope scope)
4978 struct cp_binding_level *b;
4981 timevar_push (TV_NAME_LOOKUP);
4982 b = current_binding_level;
4983 while (/* Cleanup scopes are not scopes from the point of view of
4985 b->kind == sk_cleanup
4986 /* Neither are the scopes used to hold template parameters
4987 for an explicit specialization. For an ordinary template
4988 declaration, these scopes are not scopes from the point of
4989 view of the language. */
4990 || (b->kind == sk_template_parms
4991 && (b->explicit_spec_p || scope == ts_global))
4992 || (b->kind == sk_class
4993 && (scope != ts_current
4994 /* We may be defining a new type in the initializer
4995 of a static member variable. We allow this when
4996 not pedantic, and it is particularly useful for
4997 type punning via an anonymous union. */
4998 || COMPLETE_TYPE_P (b->this_entity))))
5001 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5003 /* Do C++ gratuitous typedefing. */
5004 if (IDENTIFIER_TYPE_VALUE (name) != type)
5008 tree context = TYPE_CONTEXT (type);
5012 tree cs = current_scope ();
5014 if (scope == ts_current)
5016 else if (cs != NULL_TREE && TYPE_P (cs))
5017 /* When declaring a friend class of a local class, we want
5018 to inject the newly named class into the scope
5019 containing the local class, not the namespace
5021 context = decl_function_context (get_type_decl (cs));
5024 context = current_namespace;
5026 if (b->kind == sk_class
5027 || (b->kind == sk_template_parms
5028 && b->level_chain->kind == sk_class))
5031 if (current_lang_name == lang_name_java)
5032 TYPE_FOR_JAVA (type) = 1;
5034 tdef = create_implicit_typedef (name, type);
5035 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5036 if (scope == ts_within_enclosing_non_class)
5038 /* This is a friend. Make this TYPE_DECL node hidden from
5039 ordinary name lookup. Its corresponding TEMPLATE_DECL
5040 will be marked in push_template_decl_real. */
5041 retrofit_lang_decl (tdef);
5042 DECL_ANTICIPATED (tdef) = 1;
5043 DECL_FRIEND_P (tdef) = 1;
5046 decl = maybe_process_template_type_declaration
5047 (type, scope == ts_within_enclosing_non_class, b);
5048 if (decl == error_mark_node)
5049 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5051 if (b->kind == sk_class)
5053 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5054 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5055 class. But if it's a member template class, we want
5056 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5058 finish_member_declaration (decl);
5060 pushdecl_class_level (decl);
5062 else if (b->kind != sk_template_parms)
5064 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5065 if (decl == error_mark_node)
5066 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5070 set_identifier_type_value_with_scope (name, tdef, b);
5072 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5074 /* If this is a local class, keep track of it. We need this
5075 information for name-mangling, and so that it is possible to
5076 find all function definitions in a translation unit in a
5077 convenient way. (It's otherwise tricky to find a member
5078 function definition it's only pointed to from within a local
5080 if (TYPE_CONTEXT (type)
5081 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5082 VEC_safe_push (tree, gc, local_classes, type);
5084 if (b->kind == sk_class
5085 && !COMPLETE_TYPE_P (current_class_type))
5087 maybe_add_class_template_decl_list (current_class_type,
5088 type, /*friend_p=*/0);
5090 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5091 CLASSTYPE_NESTED_UTDS (current_class_type)
5092 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5094 binding_table_insert
5095 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5098 decl = TYPE_NAME (type);
5099 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5100 TYPE_STUB_DECL (type) = decl;
5102 /* Set type visibility now if this is a forward declaration. */
5103 TREE_PUBLIC (decl) = 1;
5104 determine_visibility (decl);
5106 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5109 /* Subroutines for reverting temporarily to top-level for instantiation
5110 of templates and such. We actually need to clear out the class- and
5111 local-value slots of all identifiers, so that only the global values
5112 are at all visible. Simply setting current_binding_level to the global
5113 scope isn't enough, because more binding levels may be pushed. */
5114 struct saved_scope *scope_chain;
5116 /* If ID has not already been marked, add an appropriate binding to
5120 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5122 cxx_saved_binding *saved;
5124 if (!id || !IDENTIFIER_BINDING (id))
5127 if (IDENTIFIER_MARKED (id))
5130 IDENTIFIER_MARKED (id) = 1;
5132 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5133 saved->identifier = id;
5134 saved->binding = IDENTIFIER_BINDING (id);
5135 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5136 IDENTIFIER_BINDING (id) = NULL;
5140 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5144 timevar_push (TV_NAME_LOOKUP);
5145 for (t = names; t; t = TREE_CHAIN (t))
5149 if (TREE_CODE (t) == TREE_LIST)
5150 id = TREE_PURPOSE (t);
5154 store_binding (id, old_bindings);
5156 timevar_pop (TV_NAME_LOOKUP);
5159 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5160 objects, rather than a TREE_LIST. */
5163 store_class_bindings (VEC(cp_class_binding,gc) *names,
5164 VEC(cxx_saved_binding,gc) **old_bindings)
5167 cp_class_binding *cb;
5169 timevar_push (TV_NAME_LOOKUP);
5170 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5171 store_binding (cb->identifier, old_bindings);
5172 timevar_pop (TV_NAME_LOOKUP);
5176 push_to_top_level (void)
5178 struct saved_scope *s;
5179 struct cp_binding_level *b;
5180 cxx_saved_binding *sb;
5184 timevar_push (TV_NAME_LOOKUP);
5185 s = GGC_CNEW (struct saved_scope);
5187 b = scope_chain ? current_binding_level : 0;
5189 /* If we're in the middle of some function, save our state. */
5193 push_function_context ();
5198 if (scope_chain && previous_class_level)
5199 store_class_bindings (previous_class_level->class_shadowed,
5202 /* Have to include the global scope, because class-scope decls
5203 aren't listed anywhere useful. */
5204 for (; b; b = b->level_chain)
5208 /* Template IDs are inserted into the global level. If they were
5209 inserted into namespace level, finish_file wouldn't find them
5210 when doing pending instantiations. Therefore, don't stop at
5211 namespace level, but continue until :: . */
5212 if (global_scope_p (b))
5215 store_bindings (b->names, &s->old_bindings);
5216 /* We also need to check class_shadowed to save class-level type
5217 bindings, since pushclass doesn't fill in b->names. */
5218 if (b->kind == sk_class)
5219 store_class_bindings (b->class_shadowed, &s->old_bindings);
5221 /* Unwind type-value slots back to top level. */
5222 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5223 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5226 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5227 IDENTIFIER_MARKED (sb->identifier) = 0;
5229 s->prev = scope_chain;
5231 s->need_pop_function_context = need_pop;
5232 s->function_decl = current_function_decl;
5233 s->skip_evaluation = skip_evaluation;
5236 current_function_decl = NULL_TREE;
5237 current_lang_base = VEC_alloc (tree, gc, 10);
5238 current_lang_name = lang_name_cplusplus;
5239 current_namespace = global_namespace;
5240 push_class_stack ();
5241 skip_evaluation = 0;
5242 timevar_pop (TV_NAME_LOOKUP);
5246 pop_from_top_level (void)
5248 struct saved_scope *s = scope_chain;
5249 cxx_saved_binding *saved;
5252 timevar_push (TV_NAME_LOOKUP);
5253 /* Clear out class-level bindings cache. */
5254 if (previous_class_level)
5255 invalidate_class_lookup_cache ();
5258 current_lang_base = 0;
5260 scope_chain = s->prev;
5261 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5263 tree id = saved->identifier;
5265 IDENTIFIER_BINDING (id) = saved->binding;
5266 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5269 /* If we were in the middle of compiling a function, restore our
5271 if (s->need_pop_function_context)
5272 pop_function_context ();
5273 current_function_decl = s->function_decl;
5274 skip_evaluation = s->skip_evaluation;
5275 timevar_pop (TV_NAME_LOOKUP);
5278 /* Pop off extraneous binding levels left over due to syntax errors.
5280 We don't pop past namespaces, as they might be valid. */
5283 pop_everything (void)
5285 if (ENABLE_SCOPE_CHECKING)
5286 verbatim ("XXX entering pop_everything ()\n");
5287 while (!toplevel_bindings_p ())
5289 if (current_binding_level->kind == sk_class)
5290 pop_nested_class ();
5294 if (ENABLE_SCOPE_CHECKING)
5295 verbatim ("XXX leaving pop_everything ()\n");
5298 /* Emit debugging information for using declarations and directives.
5299 If input tree is overloaded fn then emit debug info for all
5303 cp_emit_debug_info_for_using (tree t, tree context)
5305 /* Don't try to emit any debug information if we have errors. */
5306 if (sorrycount || errorcount)
5309 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5310 of a builtin function. */
5311 if (TREE_CODE (t) == FUNCTION_DECL
5312 && DECL_EXTERNAL (t)
5313 && DECL_BUILT_IN (t))
5316 /* Do not supply context to imported_module_or_decl, if
5317 it is a global namespace. */
5318 if (context == global_namespace)
5319 context = NULL_TREE;
5322 t = BASELINK_FUNCTIONS (t);
5324 /* FIXME: Handle TEMPLATE_DECLs. */
5325 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5326 if (TREE_CODE (t) != TEMPLATE_DECL)
5327 (*debug_hooks->imported_module_or_decl) (t, context);
5330 #include "gt-cp-name-lookup.h"