1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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"
31 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
36 #include "pointer-set.h"
38 /* The bindings for a particular name in a particular scope. */
40 struct scope_binding {
44 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
46 static cxx_scope *innermost_nonclass_level (void);
47 static cxx_binding *binding_for_name (cxx_scope *, tree);
48 static tree push_overloaded_decl (tree, int, bool);
49 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
51 static bool qualified_lookup_using_namespace (tree, tree,
52 struct scope_binding *, int);
53 static tree lookup_type_current_level (tree);
54 static tree push_using_directive (tree);
55 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
57 /* The :: namespace. */
59 tree global_namespace;
61 /* The name of the anonymous namespace, throughout this translation
63 static GTY(()) tree anonymous_namespace_name;
65 /* Initialize anonymous_namespace_name if necessary, and return it. */
68 get_anonymous_namespace_name (void)
70 if (!anonymous_namespace_name)
72 /* The anonymous namespace has to have a unique name
73 if typeinfo objects are being compared by name. */
74 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
75 anonymous_namespace_name = get_file_function_name ("N");
77 /* The demangler expects anonymous namespaces to be called
78 something starting with '_GLOBAL__N_'. */
79 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
81 return anonymous_namespace_name;
84 /* Compute the chain index of a binding_entry given the HASH value of its
85 name and the total COUNT of chains. COUNT is assumed to be a power
88 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
90 /* A free list of "binding_entry"s awaiting for re-use. */
92 static GTY((deletable)) binding_entry free_binding_entry = NULL;
94 /* Create a binding_entry object for (NAME, TYPE). */
96 static inline binding_entry
97 binding_entry_make (tree name, tree type)
101 if (free_binding_entry)
103 entry = free_binding_entry;
104 free_binding_entry = entry->chain;
107 entry = ggc_alloc_binding_entry_s ();
116 /* Put ENTRY back on the free list. */
119 binding_entry_free (binding_entry entry)
123 entry->chain = free_binding_entry;
124 free_binding_entry = entry;
128 /* The datatype used to implement the mapping from names to types at
130 struct GTY(()) binding_table_s {
131 /* Array of chains of "binding_entry"s */
132 binding_entry * GTY((length ("%h.chain_count"))) chain;
134 /* The number of chains in this table. This is the length of the
135 member "chain" considered as an array. */
138 /* Number of "binding_entry"s in this table. */
142 /* Construct TABLE with an initial CHAIN_COUNT. */
145 binding_table_construct (binding_table table, size_t chain_count)
147 table->chain_count = chain_count;
148 table->entry_count = 0;
149 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
152 /* Make TABLE's entries ready for reuse. */
155 binding_table_free (binding_table table)
163 for (i = 0, count = table->chain_count; i < count; ++i)
165 binding_entry temp = table->chain[i];
168 binding_entry entry = temp;
170 binding_entry_free (entry);
172 table->chain[i] = NULL;
174 table->entry_count = 0;
178 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
180 static inline binding_table
181 binding_table_new (size_t chain_count)
183 binding_table table = ggc_alloc_binding_table_s ();
185 binding_table_construct (table, chain_count);
189 /* Expand TABLE to twice its current chain_count. */
192 binding_table_expand (binding_table table)
194 const size_t old_chain_count = table->chain_count;
195 const size_t old_entry_count = table->entry_count;
196 const size_t new_chain_count = 2 * old_chain_count;
197 binding_entry *old_chains = table->chain;
200 binding_table_construct (table, new_chain_count);
201 for (i = 0; i < old_chain_count; ++i)
203 binding_entry entry = old_chains[i];
204 for (; entry != NULL; entry = old_chains[i])
206 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
207 const size_t j = ENTRY_INDEX (hash, new_chain_count);
209 old_chains[i] = entry->chain;
210 entry->chain = table->chain[j];
211 table->chain[j] = entry;
214 table->entry_count = old_entry_count;
217 /* Insert a binding for NAME to TYPE into TABLE. */
220 binding_table_insert (binding_table table, tree name, tree type)
222 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
223 const size_t i = ENTRY_INDEX (hash, table->chain_count);
224 binding_entry entry = binding_entry_make (name, type);
226 entry->chain = table->chain[i];
227 table->chain[i] = entry;
228 ++table->entry_count;
230 if (3 * table->chain_count < 5 * table->entry_count)
231 binding_table_expand (table);
234 /* Return the binding_entry, if any, that maps NAME. */
237 binding_table_find (binding_table table, tree name)
239 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
240 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
242 while (entry != NULL && entry->name != name)
243 entry = entry->chain;
248 /* Apply PROC -- with DATA -- to all entries in TABLE. */
251 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
253 const size_t chain_count = table->chain_count;
256 for (i = 0; i < chain_count; ++i)
258 binding_entry entry = table->chain[i];
259 for (; entry != NULL; entry = entry->chain)
264 #ifndef ENABLE_SCOPE_CHECKING
265 # define ENABLE_SCOPE_CHECKING 0
267 # define ENABLE_SCOPE_CHECKING 1
270 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
272 static GTY((deletable)) cxx_binding *free_bindings;
274 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
278 cxx_binding_init (cxx_binding *binding, tree value, tree type)
280 binding->value = value;
281 binding->type = type;
282 binding->previous = NULL;
285 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
288 cxx_binding_make (tree value, tree type)
290 cxx_binding *binding;
293 binding = free_bindings;
294 free_bindings = binding->previous;
297 binding = ggc_alloc_cxx_binding ();
299 cxx_binding_init (binding, value, type);
304 /* Put BINDING back on the free list. */
307 cxx_binding_free (cxx_binding *binding)
309 binding->scope = NULL;
310 binding->previous = free_bindings;
311 free_bindings = binding;
314 /* Create a new binding for NAME (with the indicated VALUE and TYPE
315 bindings) in the class scope indicated by SCOPE. */
318 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
320 cp_class_binding *cb;
321 cxx_binding *binding;
323 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
325 cb->identifier = name;
326 cb->base = binding = cxx_binding_make (value, type);
327 binding->scope = scope;
331 /* Make DECL the innermost binding for ID. The LEVEL is the binding
332 level at which this declaration is being bound. */
335 push_binding (tree id, tree decl, cxx_scope* level)
337 cxx_binding *binding;
339 if (level != class_binding_level)
341 binding = cxx_binding_make (decl, NULL_TREE);
342 binding->scope = level;
345 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
347 /* Now, fill in the binding information. */
348 binding->previous = IDENTIFIER_BINDING (id);
349 INHERITED_VALUE_BINDING_P (binding) = 0;
350 LOCAL_BINDING_P (binding) = (level != class_binding_level);
352 /* And put it on the front of the list of bindings for ID. */
353 IDENTIFIER_BINDING (id) = binding;
356 /* Remove the binding for DECL which should be the innermost binding
360 pop_binding (tree id, tree decl)
362 cxx_binding *binding;
365 /* It's easiest to write the loops that call this function without
366 checking whether or not the entities involved have names. We
367 get here for such an entity. */
370 /* Get the innermost binding for ID. */
371 binding = IDENTIFIER_BINDING (id);
373 /* The name should be bound. */
374 gcc_assert (binding != NULL);
376 /* The DECL will be either the ordinary binding or the type
377 binding for this identifier. Remove that binding. */
378 if (binding->value == decl)
379 binding->value = NULL_TREE;
382 gcc_assert (binding->type == decl);
383 binding->type = NULL_TREE;
386 if (!binding->value && !binding->type)
388 /* We're completely done with the innermost binding for this
389 identifier. Unhook it from the list of bindings. */
390 IDENTIFIER_BINDING (id) = binding->previous;
392 /* Add it to the free list. */
393 cxx_binding_free (binding);
397 /* BINDING records an existing declaration for a name in the current scope.
398 But, DECL is another declaration for that same identifier in the
399 same scope. This is the `struct stat' hack whereby a non-typedef
400 class name or enum-name can be bound at the same level as some other
404 A class name (9.1) or enumeration name (7.2) can be hidden by the
405 name of an object, function, or enumerator declared in the same scope.
406 If a class or enumeration name and an object, function, or enumerator
407 are declared in the same scope (in any order) with the same name, the
408 class or enumeration name is hidden wherever the object, function, or
409 enumerator name is visible.
411 It's the responsibility of the caller to check that
412 inserting this name is valid here. Returns nonzero if the new binding
416 supplement_binding_1 (cxx_binding *binding, tree decl)
418 tree bval = binding->value;
421 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
422 /* The new name is the type name. */
423 binding->type = decl;
424 else if (/* BVAL is null when push_class_level_binding moves an
425 inherited type-binding out of the way to make room for a
426 new value binding. */
428 /* BVAL is error_mark_node when DECL's name has been used
429 in a non-class scope prior declaration. In that case,
430 we should have already issued a diagnostic; for graceful
431 error recovery purpose, pretend this was the intended
432 declaration for that name. */
433 || bval == error_mark_node
434 /* If BVAL is anticipated but has not yet been declared,
435 pretend it is not there at all. */
436 || (TREE_CODE (bval) == FUNCTION_DECL
437 && DECL_ANTICIPATED (bval)
438 && !DECL_HIDDEN_FRIEND_P (bval)))
439 binding->value = decl;
440 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
441 && (TREE_CODE (decl) != TYPE_DECL
442 || same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))))
444 /* The old binding was a type name. It was placed in
445 VALUE field because it was thought, at the point it was
446 declared, to be the only entity with such a name. Move the
447 type name into the type slot; it is now hidden by the new
449 binding->type = bval;
450 binding->value = decl;
451 binding->value_is_inherited = false;
453 else if (TREE_CODE (bval) == TYPE_DECL
454 && TREE_CODE (decl) == TYPE_DECL
455 && DECL_NAME (decl) == DECL_NAME (bval)
456 && binding->scope->kind != sk_class
457 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
458 /* If either type involves template parameters, we must
459 wait until instantiation. */
460 || uses_template_parms (TREE_TYPE (decl))
461 || uses_template_parms (TREE_TYPE (bval))))
462 /* We have two typedef-names, both naming the same type to have
463 the same name. In general, this is OK because of:
467 In a given scope, a typedef specifier can be used to redefine
468 the name of any type declared in that scope to refer to the
469 type to which it already refers.
471 However, in class scopes, this rule does not apply due to the
472 stricter language in [class.mem] prohibiting redeclarations of
475 /* There can be two block-scope declarations of the same variable,
476 so long as they are `extern' declarations. However, there cannot
477 be two declarations of the same static data member:
481 A member shall not be declared twice in the
482 member-specification. */
483 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
484 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
485 && !DECL_CLASS_SCOPE_P (decl))
487 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
490 else if (TREE_CODE (decl) == NAMESPACE_DECL
491 && TREE_CODE (bval) == NAMESPACE_DECL
492 && DECL_NAMESPACE_ALIAS (decl)
493 && DECL_NAMESPACE_ALIAS (bval)
494 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
497 In a declarative region, a namespace-alias-definition can be
498 used to redefine a namespace-alias declared in that declarative
499 region to refer only to the namespace to which it already
504 error ("declaration of %q#D", decl);
505 error ("conflicts with previous declaration %q+#D", bval);
512 /* Wrapper for supplement_binding_1. */
515 supplement_binding (cxx_binding *binding, tree decl)
518 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
519 ret = supplement_binding_1 (binding, decl);
520 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
524 /* Add DECL to the list of things declared in B. */
527 add_decl_to_level (tree decl, cxx_scope *b)
529 /* We used to record virtual tables as if they were ordinary
530 variables, but no longer do so. */
531 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
533 if (TREE_CODE (decl) == NAMESPACE_DECL
534 && !DECL_NAMESPACE_ALIAS (decl))
536 DECL_CHAIN (decl) = b->namespaces;
537 b->namespaces = decl;
541 /* We build up the list in reverse order, and reverse it later if
543 TREE_CHAIN (decl) = b->names;
546 /* If appropriate, add decl to separate list of statics. We
547 include extern variables because they might turn out to be
548 static later. It's OK for this list to contain a few false
550 if (b->kind == sk_namespace)
551 if ((TREE_CODE (decl) == VAR_DECL
552 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
553 || (TREE_CODE (decl) == FUNCTION_DECL
554 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
555 VEC_safe_push (tree, gc, b->static_decls, decl);
559 /* Record a decl-node X as belonging to the current lexical scope.
560 Check for errors (such as an incompatible declaration for the same
561 name already seen in the same scope). IS_FRIEND is true if X is
562 declared as a friend.
564 Returns either X or an old decl for the same name.
565 If an old decl is returned, it may have been smashed
566 to agree with what X says. */
569 pushdecl_maybe_friend_1 (tree x, bool is_friend)
573 int need_new_binding;
575 if (x == error_mark_node)
576 return error_mark_node;
578 need_new_binding = 1;
580 if (DECL_TEMPLATE_PARM_P (x))
581 /* Template parameters have no context; they are not X::T even
582 when declared within a class or namespace. */
586 if (current_function_decl && x != current_function_decl
587 /* A local declaration for a function doesn't constitute
589 && TREE_CODE (x) != FUNCTION_DECL
590 /* A local declaration for an `extern' variable is in the
591 scope of the current namespace, not the current
593 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
594 /* When parsing the parameter list of a function declarator,
595 don't set DECL_CONTEXT to an enclosing function. When we
596 push the PARM_DECLs in order to process the function body,
597 current_binding_level->this_entity will be set. */
598 && !(TREE_CODE (x) == PARM_DECL
599 && current_binding_level->kind == sk_function_parms
600 && current_binding_level->this_entity == NULL)
601 && !DECL_CONTEXT (x))
602 DECL_CONTEXT (x) = current_function_decl;
604 /* If this is the declaration for a namespace-scope function,
605 but the declaration itself is in a local scope, mark the
607 if (TREE_CODE (x) == FUNCTION_DECL
608 && DECL_NAMESPACE_SCOPE_P (x)
609 && current_function_decl
610 && x != current_function_decl)
611 DECL_LOCAL_FUNCTION_P (x) = 1;
614 name = DECL_NAME (x);
617 int different_binding_level = 0;
619 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
620 name = TREE_OPERAND (name, 0);
622 /* In case this decl was explicitly namespace-qualified, look it
623 up in its namespace context. */
624 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
625 t = namespace_binding (name, DECL_CONTEXT (x));
627 t = lookup_name_innermost_nonclass_level (name);
629 /* [basic.link] If there is a visible declaration of an entity
630 with linkage having the same name and type, ignoring entities
631 declared outside the innermost enclosing namespace scope, the
632 block scope declaration declares that same entity and
633 receives the linkage of the previous declaration. */
634 if (! t && current_function_decl && x != current_function_decl
635 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
636 && DECL_EXTERNAL (x))
638 /* Look in block scope. */
639 t = innermost_non_namespace_value (name);
640 /* Or in the innermost namespace. */
642 t = namespace_binding (name, DECL_CONTEXT (x));
643 /* Does it have linkage? Note that if this isn't a DECL, it's an
644 OVERLOAD, which is OK. */
645 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
648 different_binding_level = 1;
651 /* If we are declaring a function, and the result of name-lookup
652 was an OVERLOAD, look for an overloaded instance that is
653 actually the same as the function we are declaring. (If
654 there is one, we have to merge our declaration with the
655 previous declaration.) */
656 if (t && TREE_CODE (t) == OVERLOAD)
660 if (TREE_CODE (x) == FUNCTION_DECL)
661 for (match = t; match; match = OVL_NEXT (match))
663 if (decls_match (OVL_CURRENT (match), x))
667 /* Just choose one. */
671 t = OVL_CURRENT (match);
676 if (t && t != error_mark_node)
678 if (different_binding_level)
680 if (decls_match (x, t))
681 /* The standard only says that the local extern
682 inherits linkage from the previous decl; in
683 particular, default args are not shared. Add
684 the decl into a hash table to make sure only
685 the previous decl in this case is seen by the
688 struct cxx_int_tree_map *h;
691 TREE_PUBLIC (x) = TREE_PUBLIC (t);
693 if (cp_function_chain->extern_decl_map == NULL)
694 cp_function_chain->extern_decl_map
695 = htab_create_ggc (20, cxx_int_tree_map_hash,
696 cxx_int_tree_map_eq, NULL);
698 h = ggc_alloc_cxx_int_tree_map ();
699 h->uid = DECL_UID (x);
701 loc = htab_find_slot_with_hash
702 (cp_function_chain->extern_decl_map, h,
704 *(struct cxx_int_tree_map **) loc = h;
707 else if (TREE_CODE (t) == PARM_DECL)
709 /* Check for duplicate params. */
710 tree d = duplicate_decls (x, t, is_friend);
714 else if ((DECL_EXTERN_C_FUNCTION_P (x)
715 || DECL_FUNCTION_TEMPLATE_P (x))
716 && is_overloaded_fn (t))
717 /* Don't do anything just yet. */;
718 else if (t == wchar_decl_node)
720 if (! DECL_IN_SYSTEM_HEADER (x))
721 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
724 /* Throw away the redeclaration. */
729 tree olddecl = duplicate_decls (x, t, is_friend);
731 /* If the redeclaration failed, we can stop at this
733 if (olddecl == error_mark_node)
734 return error_mark_node;
738 if (TREE_CODE (t) == TYPE_DECL)
739 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
743 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
745 /* A redeclaration of main, but not a duplicate of the
750 This function shall not be overloaded. */
751 error ("invalid redeclaration of %q+D", t);
753 /* We don't try to push this declaration since that
760 /* If x has C linkage-specification, (extern "C"),
761 lookup its binding, in case it's already bound to an object.
762 The lookup is done in all namespaces.
763 If we find an existing binding, make sure it has the same
764 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
765 if ((TREE_CODE (x) == FUNCTION_DECL)
766 && DECL_EXTERN_C_P (x)
767 /* We should ignore declarations happening in system headers. */
768 && !DECL_ARTIFICIAL (x)
769 && !DECL_IN_SYSTEM_HEADER (x))
771 cxx_binding *function_binding =
772 lookup_extern_c_fun_binding_in_all_ns (x);
773 tree previous = (function_binding
774 ? function_binding->value
777 && !DECL_ARTIFICIAL (previous)
778 && !DECL_IN_SYSTEM_HEADER (previous)
779 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
781 tree previous = function_binding->value;
783 /* In case either x or previous is declared to throw an exception,
784 make sure both exception specifications are equal. */
785 if (decls_match (x, previous))
787 tree x_exception_spec = NULL_TREE;
788 tree previous_exception_spec = NULL_TREE;
791 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
792 previous_exception_spec =
793 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
794 if (!comp_except_specs (previous_exception_spec,
798 pedwarn (input_location, 0,
799 "declaration of %q#D with C language linkage",
801 pedwarn (input_location, 0,
802 "conflicts with previous declaration %q+#D",
804 pedwarn (input_location, 0,
805 "due to different exception specifications");
806 return error_mark_node;
811 pedwarn (input_location, 0,
812 "declaration of %q#D with C language linkage", x);
813 pedwarn (input_location, 0,
814 "conflicts with previous declaration %q+#D",
820 check_template_shadow (x);
822 /* If this is a function conjured up by the back end, massage it
823 so it looks friendly. */
824 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
826 retrofit_lang_decl (x);
827 SET_DECL_LANGUAGE (x, lang_c);
831 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
833 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
834 if (!namespace_bindings_p ())
835 /* We do not need to create a binding for this name;
836 push_overloaded_decl will have already done so if
838 need_new_binding = 0;
840 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
842 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
844 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
847 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
848 check_default_args (t);
850 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
853 /* If declaring a type as a typedef, copy the type (unless we're
854 at line 0), and install this TYPE_DECL as the new type's typedef
855 name. See the extensive comment of set_underlying_type (). */
856 if (TREE_CODE (x) == TYPE_DECL)
858 tree type = TREE_TYPE (x);
860 if (DECL_IS_BUILTIN (x)
861 || (TREE_TYPE (x) != error_mark_node
862 && TYPE_NAME (type) != x
863 /* We don't want to copy the type when all we're
864 doing is making a TYPE_DECL for the purposes of
866 && (!TYPE_NAME (type)
867 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
868 set_underlying_type (x);
870 if (type != error_mark_node
872 && TYPE_IDENTIFIER (type))
873 set_identifier_type_value (DECL_NAME (x), x);
876 /* Multiple external decls of the same identifier ought to match.
878 We get warnings about inline functions where they are defined.
879 We get warnings about other functions from push_overloaded_decl.
881 Avoid duplicate warnings where they are used. */
882 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
886 decl = IDENTIFIER_NAMESPACE_VALUE (name);
887 if (decl && TREE_CODE (decl) == OVERLOAD)
888 decl = OVL_FUNCTION (decl);
890 if (decl && decl != error_mark_node
891 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
892 /* If different sort of thing, we already gave an error. */
893 && TREE_CODE (decl) == TREE_CODE (x)
894 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
896 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
897 permerror (input_location, "previous external decl of %q+#D", decl);
901 if (TREE_CODE (x) == FUNCTION_DECL
903 && !flag_friend_injection)
905 /* This is a new declaration of a friend function, so hide
906 it from ordinary function lookup. */
907 DECL_ANTICIPATED (x) = 1;
908 DECL_HIDDEN_FRIEND_P (x) = 1;
911 /* This name is new in its binding level.
912 Install the new declaration and return it. */
913 if (namespace_bindings_p ())
915 /* Install a global value. */
917 /* If the first global decl has external linkage,
918 warn if we later see static one. */
919 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
920 TREE_PUBLIC (name) = 1;
922 /* Bind the name for the entity. */
923 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
925 && (TREE_CODE (x) == TYPE_DECL
926 || TREE_CODE (x) == VAR_DECL
927 || TREE_CODE (x) == NAMESPACE_DECL
928 || TREE_CODE (x) == CONST_DECL
929 || TREE_CODE (x) == TEMPLATE_DECL))
930 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
932 /* If new decl is `static' and an `extern' was seen previously,
934 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
935 warn_extern_redeclared_static (x, t);
939 /* Here to install a non-global value. */
940 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
941 tree oldlocal = NULL_TREE;
942 cxx_scope *oldscope = NULL;
943 cxx_binding *oldbinding = outer_binding (name, NULL, true);
946 oldlocal = oldbinding->value;
947 oldscope = oldbinding->scope;
950 if (need_new_binding)
952 push_local_binding (name, x, 0);
953 /* Because push_local_binding will hook X on to the
954 current_binding_level's name list, we don't want to
955 do that again below. */
956 need_new_binding = 0;
959 /* If this is a TYPE_DECL, push it into the type value slot. */
960 if (TREE_CODE (x) == TYPE_DECL)
961 set_identifier_type_value (name, x);
963 /* Clear out any TYPE_DECL shadowed by a namespace so that
964 we won't think this is a type. The C struct hack doesn't
965 go through namespaces. */
966 if (TREE_CODE (x) == NAMESPACE_DECL)
967 set_identifier_type_value (name, NULL_TREE);
974 && TREE_CODE (oldlocal) == VAR_DECL
975 && DECL_DEAD_FOR_LOCAL (oldlocal))
976 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
978 if (oldlocal == NULL_TREE)
979 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
982 /* If this is an extern function declaration, see if we
983 have a global definition or declaration for the function. */
984 if (oldlocal == NULL_TREE
986 && oldglobal != NULL_TREE
987 && TREE_CODE (x) == FUNCTION_DECL
988 && TREE_CODE (oldglobal) == FUNCTION_DECL)
990 /* We have one. Their types must agree. */
991 if (decls_match (x, oldglobal))
995 warning (0, "extern declaration of %q#D doesn%'t match", x);
996 warning (0, "global declaration %q+#D", oldglobal);
999 /* If we have a local external declaration,
1000 and no file-scope declaration has yet been seen,
1001 then if we later have a file-scope decl it must not be static. */
1002 if (oldlocal == NULL_TREE
1003 && oldglobal == NULL_TREE
1004 && DECL_EXTERNAL (x)
1006 TREE_PUBLIC (name) = 1;
1008 /* Don't complain about the parms we push and then pop
1009 while tentatively parsing a function declarator. */
1010 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1013 /* Warn if shadowing an argument at the top level of the body. */
1014 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1015 /* Inline decls shadow nothing. */
1016 && !DECL_FROM_INLINE (x)
1017 && (TREE_CODE (oldlocal) == PARM_DECL
1018 || TREE_CODE (oldlocal) == VAR_DECL
1019 /* If the old decl is a type decl, only warn if the
1020 old decl is an explicit typedef or if both the old
1021 and new decls are type decls. */
1022 || (TREE_CODE (oldlocal) == TYPE_DECL
1023 && (!DECL_ARTIFICIAL (oldlocal)
1024 || TREE_CODE (x) == TYPE_DECL)))
1025 /* Don't check for internally generated vars unless
1026 it's an implicit typedef (see create_implicit_typedef
1028 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1030 bool nowarn = false;
1032 /* Don't complain if it's from an enclosing function. */
1033 if (DECL_CONTEXT (oldlocal) == current_function_decl
1034 && TREE_CODE (x) != PARM_DECL
1035 && TREE_CODE (oldlocal) == PARM_DECL)
1037 /* Go to where the parms should be and see if we find
1039 struct cp_binding_level *b = current_binding_level->level_chain;
1041 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1042 /* Skip the ctor/dtor cleanup level. */
1046 if (b->kind == sk_function_parms)
1048 error ("declaration of %q#D shadows a parameter", x);
1053 /* The local structure or class can't use parameters of
1054 the containing function anyway. */
1055 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1057 cxx_scope *scope = current_binding_level;
1058 tree context = DECL_CONTEXT (oldlocal);
1059 for (; scope; scope = scope->level_chain)
1061 if (scope->kind == sk_function_parms
1062 && scope->this_entity == context)
1064 if (scope->kind == sk_class
1065 && !LAMBDA_TYPE_P (scope->this_entity))
1072 /* Error if redeclaring a local declared in a
1073 for-init-statement or in the condition of an if or
1074 switch statement when the new declaration is in the
1075 outermost block of the controlled statement.
1076 Redeclaring a variable from a for or while condition is
1077 detected elsewhere. */
1078 else if (TREE_CODE (oldlocal) == VAR_DECL
1079 && oldscope == current_binding_level->level_chain
1080 && (oldscope->kind == sk_cond
1081 || oldscope->kind == sk_for))
1083 error ("redeclaration of %q#D", x);
1084 error ("%q+#D previously declared here", oldlocal);
1087 if (warn_shadow && !nowarn)
1089 if (TREE_CODE (oldlocal) == PARM_DECL)
1090 warning_at (input_location, OPT_Wshadow,
1091 "declaration of %q#D shadows a parameter", x);
1092 else if (is_capture_proxy (oldlocal))
1093 warning_at (input_location, OPT_Wshadow,
1094 "declaration of %qD shadows a lambda capture",
1097 warning_at (input_location, OPT_Wshadow,
1098 "declaration of %qD shadows a previous local",
1100 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1101 "shadowed declaration is here");
1105 /* Maybe warn if shadowing something else. */
1106 else if (warn_shadow && !DECL_EXTERNAL (x)
1107 /* No shadow warnings for internally generated vars unless
1108 it's an implicit typedef (see create_implicit_typedef
1110 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1111 /* No shadow warnings for vars made for inlining. */
1112 && ! DECL_FROM_INLINE (x))
1116 if (current_class_ptr)
1117 member = lookup_member (current_class_type,
1120 /*want_type=*/false);
1124 if (member && !TREE_STATIC (member))
1126 /* Location of previous decl is not useful in this case. */
1127 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1130 else if (oldglobal != NULL_TREE
1131 && (TREE_CODE (oldglobal) == VAR_DECL
1132 /* If the old decl is a type decl, only warn if the
1133 old decl is an explicit typedef or if both the
1134 old and new decls are type decls. */
1135 || (TREE_CODE (oldglobal) == TYPE_DECL
1136 && (!DECL_ARTIFICIAL (oldglobal)
1137 || TREE_CODE (x) == TYPE_DECL))))
1138 /* XXX shadow warnings in outer-more namespaces */
1140 warning_at (input_location, OPT_Wshadow,
1141 "declaration of %qD shadows a global declaration", x);
1142 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1143 "shadowed declaration is here");
1148 if (TREE_CODE (x) == VAR_DECL)
1149 maybe_register_incomplete_var (x);
1152 if (need_new_binding)
1153 add_decl_to_level (x,
1154 DECL_NAMESPACE_SCOPE_P (x)
1155 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1156 : current_binding_level);
1161 /* Wrapper for pushdecl_maybe_friend_1. */
1164 pushdecl_maybe_friend (tree x, bool is_friend)
1167 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1168 ret = pushdecl_maybe_friend_1 (x, is_friend);
1169 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1173 /* Record a decl-node X as belonging to the current lexical scope. */
1178 return pushdecl_maybe_friend (x, false);
1181 /* Enter DECL into the symbol table, if that's appropriate. Returns
1182 DECL, or a modified version thereof. */
1185 maybe_push_decl (tree decl)
1187 tree type = TREE_TYPE (decl);
1189 /* Add this decl to the current binding level, but not if it comes
1190 from another scope, e.g. a static member variable. TEM may equal
1191 DECL or it may be a previous decl of the same name. */
1192 if (decl == error_mark_node
1193 || (TREE_CODE (decl) != PARM_DECL
1194 && DECL_CONTEXT (decl) != NULL_TREE
1195 /* Definitions of namespace members outside their namespace are
1197 && !DECL_NAMESPACE_SCOPE_P (decl))
1198 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1199 || type == unknown_type_node
1200 /* The declaration of a template specialization does not affect
1201 the functions available for overload resolution, so we do not
1203 || (TREE_CODE (decl) == FUNCTION_DECL
1204 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1207 return pushdecl (decl);
1210 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1211 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1212 doesn't really belong to this binding level, that it got here
1213 through a using-declaration. */
1216 push_local_binding (tree id, tree decl, int flags)
1218 struct cp_binding_level *b;
1220 /* Skip over any local classes. This makes sense if we call
1221 push_local_binding with a friend decl of a local class. */
1222 b = innermost_nonclass_level ();
1224 if (lookup_name_innermost_nonclass_level (id))
1226 /* Supplement the existing binding. */
1227 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1228 /* It didn't work. Something else must be bound at this
1229 level. Do not add DECL to the list of things to pop
1234 /* Create a new binding. */
1235 push_binding (id, decl, b);
1237 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1238 /* We must put the OVERLOAD into a TREE_LIST since the
1239 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1240 decls that got here through a using-declaration. */
1241 decl = build_tree_list (NULL_TREE, decl);
1243 /* And put DECL on the list of things declared by the current
1245 add_decl_to_level (decl, b);
1248 /* Check to see whether or not DECL is a variable that would have been
1249 in scope under the ARM, but is not in scope under the ANSI/ISO
1250 standard. If so, issue an error message. If name lookup would
1251 work in both cases, but return a different result, this function
1252 returns the result of ANSI/ISO lookup. Otherwise, it returns
1256 check_for_out_of_scope_variable (tree decl)
1260 /* We only care about out of scope variables. */
1261 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1264 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1265 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1266 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1267 && DECL_DEAD_FOR_LOCAL (shadowed))
1268 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1269 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1271 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1274 if (!DECL_ERROR_REPORTED (decl))
1276 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1277 warning (0, " matches this %q+D under ISO standard rules",
1279 warning (0, " matches this %q+D under old rules", decl);
1280 DECL_ERROR_REPORTED (decl) = 1;
1285 /* If we have already complained about this declaration, there's no
1286 need to do it again. */
1287 if (DECL_ERROR_REPORTED (decl))
1290 DECL_ERROR_REPORTED (decl) = 1;
1292 if (TREE_TYPE (decl) == error_mark_node)
1295 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1297 error ("name lookup of %qD changed for ISO %<for%> scoping",
1299 error (" cannot use obsolete binding at %q+D because "
1300 "it has a destructor", decl);
1301 return error_mark_node;
1305 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1307 if (flag_permissive)
1308 permerror (input_location, " using obsolete binding at %q+D", decl);
1314 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1323 /* true means unconditionally make a BLOCK for the next level pushed. */
1325 static bool keep_next_level_flag;
1327 static int binding_depth = 0;
1334 for (i = 0; i < depth * 2; i++)
1338 /* Return a string describing the kind of SCOPE we have. */
1340 cxx_scope_descriptor (cxx_scope *scope)
1342 /* The order of this table must match the "scope_kind"
1344 static const char* scope_kind_names[] = {
1350 "function-parameter-scope",
1353 "template-parameter-scope",
1354 "template-explicit-spec-scope"
1356 const scope_kind kind = scope->explicit_spec_p
1357 ? sk_template_spec : scope->kind;
1359 return scope_kind_names[kind];
1362 /* Output a debugging information about SCOPE when performing
1365 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1367 const char *desc = cxx_scope_descriptor (scope);
1368 if (scope->this_entity)
1369 verbatim ("%s %s(%E) %p %d\n", action, desc,
1370 scope->this_entity, (void *) scope, line);
1372 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1375 /* Return the estimated initial size of the hashtable of a NAMESPACE
1378 static inline size_t
1379 namespace_scope_ht_size (tree ns)
1381 tree name = DECL_NAME (ns);
1383 return name == std_identifier
1384 ? NAMESPACE_STD_HT_SIZE
1385 : (name == global_scope_name
1386 ? GLOBAL_SCOPE_HT_SIZE
1387 : NAMESPACE_ORDINARY_HT_SIZE);
1390 /* A chain of binding_level structures awaiting reuse. */
1392 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1394 /* Insert SCOPE as the innermost binding level. */
1397 push_binding_level (struct cp_binding_level *scope)
1399 /* Add it to the front of currently active scopes stack. */
1400 scope->level_chain = current_binding_level;
1401 current_binding_level = scope;
1402 keep_next_level_flag = false;
1404 if (ENABLE_SCOPE_CHECKING)
1406 scope->binding_depth = binding_depth;
1407 indent (binding_depth);
1408 cxx_scope_debug (scope, input_line, "push");
1413 /* Create a new KIND scope and make it the top of the active scopes stack.
1414 ENTITY is the scope of the associated C++ entity (namespace, class,
1415 function, C++0x enumeration); it is NULL otherwise. */
1418 begin_scope (scope_kind kind, tree entity)
1422 /* Reuse or create a struct for this binding level. */
1423 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1425 scope = free_binding_level;
1426 memset (scope, 0, sizeof (cxx_scope));
1427 free_binding_level = scope->level_chain;
1430 scope = ggc_alloc_cleared_cxx_scope ();
1432 scope->this_entity = entity;
1433 scope->more_cleanups_ok = true;
1440 case sk_template_spec:
1441 scope->explicit_spec_p = true;
1442 kind = sk_template_parms;
1444 case sk_template_parms:
1451 case sk_scoped_enum:
1452 case sk_function_parms:
1454 scope->keep = keep_next_level_flag;
1458 NAMESPACE_LEVEL (entity) = scope;
1459 scope->static_decls =
1460 VEC_alloc (tree, gc,
1461 DECL_NAME (entity) == std_identifier
1462 || DECL_NAME (entity) == global_scope_name
1467 /* Should not happen. */
1473 push_binding_level (scope);
1478 /* We're about to leave current scope. Pop the top of the stack of
1479 currently active scopes. Return the enclosing scope, now active. */
1484 cxx_scope *scope = current_binding_level;
1486 if (scope->kind == sk_namespace && class_binding_level)
1487 current_binding_level = class_binding_level;
1489 /* We cannot leave a scope, if there are none left. */
1490 if (NAMESPACE_LEVEL (global_namespace))
1491 gcc_assert (!global_scope_p (scope));
1493 if (ENABLE_SCOPE_CHECKING)
1495 indent (--binding_depth);
1496 cxx_scope_debug (scope, input_line, "leave");
1499 /* Move one nesting level up. */
1500 current_binding_level = scope->level_chain;
1502 /* Namespace-scopes are left most probably temporarily, not
1503 completely; they can be reopened later, e.g. in namespace-extension
1504 or any name binding activity that requires us to resume a
1505 namespace. For classes, we cache some binding levels. For other
1506 scopes, we just make the structure available for reuse. */
1507 if (scope->kind != sk_namespace
1508 && scope->kind != sk_class)
1510 scope->level_chain = free_binding_level;
1511 gcc_assert (!ENABLE_SCOPE_CHECKING
1512 || scope->binding_depth == binding_depth);
1513 free_binding_level = scope;
1516 /* Find the innermost enclosing class scope, and reset
1517 CLASS_BINDING_LEVEL appropriately. */
1518 if (scope->kind == sk_class)
1520 class_binding_level = NULL;
1521 for (scope = current_binding_level; scope; scope = scope->level_chain)
1522 if (scope->kind == sk_class)
1524 class_binding_level = scope;
1529 return current_binding_level;
1533 resume_scope (struct cp_binding_level* b)
1535 /* Resuming binding levels is meant only for namespaces,
1536 and those cannot nest into classes. */
1537 gcc_assert (!class_binding_level);
1538 /* Also, resuming a non-directly nested namespace is a no-no. */
1539 gcc_assert (b->level_chain == current_binding_level);
1540 current_binding_level = b;
1541 if (ENABLE_SCOPE_CHECKING)
1543 b->binding_depth = binding_depth;
1544 indent (binding_depth);
1545 cxx_scope_debug (b, input_line, "resume");
1550 /* Return the innermost binding level that is not for a class scope. */
1553 innermost_nonclass_level (void)
1557 b = current_binding_level;
1558 while (b->kind == sk_class)
1564 /* We're defining an object of type TYPE. If it needs a cleanup, but
1565 we're not allowed to add any more objects with cleanups to the current
1566 scope, create a new binding level. */
1569 maybe_push_cleanup_level (tree type)
1571 if (type != error_mark_node
1572 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1573 && current_binding_level->more_cleanups_ok == 0)
1575 begin_scope (sk_cleanup, NULL);
1576 current_binding_level->statement_list = push_stmt_list ();
1580 /* Return true if we are in the global binding level. */
1583 global_bindings_p (void)
1585 return global_scope_p (current_binding_level);
1588 /* True if we are currently in a toplevel binding level. This
1589 means either the global binding level or a namespace in a toplevel
1590 binding level. Since there are no non-toplevel namespace levels,
1591 this really means any namespace or template parameter level. We
1592 also include a class whose context is toplevel. */
1595 toplevel_bindings_p (void)
1597 struct cp_binding_level *b = innermost_nonclass_level ();
1599 return b->kind == sk_namespace || b->kind == sk_template_parms;
1602 /* True if this is a namespace scope, or if we are defining a class
1603 which is itself at namespace scope, or whose enclosing class is
1604 such a class, etc. */
1607 namespace_bindings_p (void)
1609 struct cp_binding_level *b = innermost_nonclass_level ();
1611 return b->kind == sk_namespace;
1614 /* True if the current level needs to have a BLOCK made. */
1619 return (current_binding_level->blocks != NULL_TREE
1620 || current_binding_level->keep
1621 || current_binding_level->kind == sk_cleanup
1622 || current_binding_level->names != NULL_TREE
1623 || current_binding_level->using_directives);
1626 /* Returns the kind of the innermost scope. */
1629 innermost_scope_kind (void)
1631 return current_binding_level->kind;
1634 /* Returns true if this scope was created to store template parameters. */
1637 template_parm_scope_p (void)
1639 return innermost_scope_kind () == sk_template_parms;
1642 /* If KEEP is true, make a BLOCK node for the next binding level,
1643 unconditionally. Otherwise, use the normal logic to decide whether
1644 or not to create a BLOCK. */
1647 keep_next_level (bool keep)
1649 keep_next_level_flag = keep;
1652 /* Return the list of declarations of the current level.
1653 Note that this list is in reverse order unless/until
1654 you nreverse it; and when you do nreverse it, you must
1655 store the result back using `storedecls' or you will lose. */
1660 return current_binding_level->names;
1663 /* Return how many function prototypes we are currently nested inside. */
1666 function_parm_depth (void)
1669 struct cp_binding_level *b;
1671 for (b = current_binding_level;
1672 b->kind == sk_function_parms;
1679 /* For debugging. */
1680 static int no_print_functions = 0;
1681 static int no_print_builtins = 0;
1684 print_binding_level (struct cp_binding_level* lvl)
1688 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1689 if (lvl->more_cleanups_ok)
1690 fprintf (stderr, " more-cleanups-ok");
1691 if (lvl->have_cleanups)
1692 fprintf (stderr, " have-cleanups");
1693 fprintf (stderr, "\n");
1696 fprintf (stderr, " names:\t");
1697 /* We can probably fit 3 names to a line? */
1698 for (t = lvl->names; t; t = TREE_CHAIN (t))
1700 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1702 if (no_print_builtins
1703 && (TREE_CODE (t) == TYPE_DECL)
1704 && DECL_IS_BUILTIN (t))
1707 /* Function decls tend to have longer names. */
1708 if (TREE_CODE (t) == FUNCTION_DECL)
1715 fprintf (stderr, "\n\t");
1718 print_node_brief (stderr, "", t, 0);
1719 if (t == error_mark_node)
1723 fprintf (stderr, "\n");
1725 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1728 cp_class_binding *b;
1729 fprintf (stderr, " class-shadowed:");
1730 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1731 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1732 fprintf (stderr, "\n");
1734 if (lvl->type_shadowed)
1736 fprintf (stderr, " type-shadowed:");
1737 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1739 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1741 fprintf (stderr, "\n");
1746 print_other_binding_stack (struct cp_binding_level *stack)
1748 struct cp_binding_level *level;
1749 for (level = stack; !global_scope_p (level); level = level->level_chain)
1751 fprintf (stderr, "binding level %p\n", (void *) level);
1752 print_binding_level (level);
1757 print_binding_stack (void)
1759 struct cp_binding_level *b;
1760 fprintf (stderr, "current_binding_level=%p\n"
1761 "class_binding_level=%p\n"
1762 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1763 (void *) current_binding_level, (void *) class_binding_level,
1764 (void *) NAMESPACE_LEVEL (global_namespace));
1765 if (class_binding_level)
1767 for (b = class_binding_level; b; b = b->level_chain)
1768 if (b == current_binding_level)
1771 b = class_binding_level;
1773 b = current_binding_level;
1776 b = current_binding_level;
1777 print_other_binding_stack (b);
1778 fprintf (stderr, "global:\n");
1779 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1782 /* Return the type associated with ID. */
1785 identifier_type_value_1 (tree id)
1787 /* There is no type with that name, anywhere. */
1788 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1790 /* This is not the type marker, but the real thing. */
1791 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1792 return REAL_IDENTIFIER_TYPE_VALUE (id);
1793 /* Have to search for it. It must be on the global level, now.
1794 Ask lookup_name not to return non-types. */
1795 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1797 return TREE_TYPE (id);
1801 /* Wrapper for identifier_type_value_1. */
1804 identifier_type_value (tree id)
1807 timevar_start (TV_NAME_LOOKUP);
1808 ret = identifier_type_value_1 (id);
1809 timevar_stop (TV_NAME_LOOKUP);
1814 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1815 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1818 identifier_global_value (tree t)
1820 return IDENTIFIER_GLOBAL_VALUE (t);
1823 /* Push a definition of struct, union or enum tag named ID. into
1824 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1825 the tag ID is not already defined. */
1828 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1832 if (b->kind != sk_namespace)
1834 /* Shadow the marker, not the real thing, so that the marker
1835 gets restored later. */
1836 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1838 = tree_cons (id, old_type_value, b->type_shadowed);
1839 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1840 TREE_TYPE (b->type_shadowed) = type;
1844 cxx_binding *binding =
1845 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1848 supplement_binding (binding, decl);
1850 binding->value = decl;
1852 /* Store marker instead of real type. */
1853 type = global_type_node;
1855 SET_IDENTIFIER_TYPE_VALUE (id, type);
1858 /* As set_identifier_type_value_with_scope, but using
1859 current_binding_level. */
1862 set_identifier_type_value (tree id, tree decl)
1864 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1867 /* Return the name for the constructor (or destructor) for the
1868 specified class TYPE. When given a template, this routine doesn't
1869 lose the specialization. */
1872 constructor_name_full (tree type)
1874 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1877 /* Return the name for the constructor (or destructor) for the
1878 specified class. When given a template, return the plain
1879 unspecialized name. */
1882 constructor_name (tree type)
1885 name = constructor_name_full (type);
1886 if (IDENTIFIER_TEMPLATE (name))
1887 name = IDENTIFIER_TEMPLATE (name);
1891 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1892 which must be a class type. */
1895 constructor_name_p (tree name, tree type)
1899 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1904 if (TREE_CODE (name) != IDENTIFIER_NODE)
1907 ctor_name = constructor_name_full (type);
1908 if (name == ctor_name)
1910 if (IDENTIFIER_TEMPLATE (ctor_name)
1911 && name == IDENTIFIER_TEMPLATE (ctor_name))
1916 /* Counter used to create anonymous type names. */
1918 static GTY(()) int anon_cnt;
1920 /* Return an IDENTIFIER which can be used as a name for
1921 anonymous structs and unions. */
1924 make_anon_name (void)
1928 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1929 return get_identifier (buf);
1932 /* This code is practically identical to that for creating
1933 anonymous names, but is just used for lambdas instead. This is necessary
1934 because anonymous names are recognized and cannot be passed to template
1936 /* FIXME is this still necessary? */
1938 static GTY(()) int lambda_cnt = 0;
1941 make_lambda_name (void)
1945 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1946 return get_identifier (buf);
1949 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1951 static inline cxx_binding *
1952 find_binding (cxx_scope *scope, cxx_binding *binding)
1954 for (; binding != NULL; binding = binding->previous)
1955 if (binding->scope == scope)
1958 return (cxx_binding *)0;
1961 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1963 static inline cxx_binding *
1964 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1966 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1969 /* Fold-in case where NAME is used only once. */
1970 if (scope == b->scope && b->previous == NULL)
1972 return find_binding (scope, b);
1977 /* Always returns a binding for name in scope. If no binding is
1978 found, make a new one. */
1980 static cxx_binding *
1981 binding_for_name (cxx_scope *scope, tree name)
1983 cxx_binding *result;
1985 result = cxx_scope_find_binding_for_name (scope, name);
1988 /* Not found, make a new one. */
1989 result = cxx_binding_make (NULL, NULL);
1990 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1991 result->scope = scope;
1992 result->is_local = false;
1993 result->value_is_inherited = false;
1994 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1998 /* Walk through the bindings associated to the name of FUNCTION,
1999 and return the first binding that declares a function with a
2000 "C" linkage specification, a.k.a 'extern "C"'.
2001 This function looks for the binding, regardless of which scope it
2002 has been defined in. It basically looks in all the known scopes.
2003 Note that this function does not lookup for bindings of builtin functions
2004 or for functions declared in system headers. */
2006 lookup_extern_c_fun_binding_in_all_ns (tree function)
2011 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2013 name = DECL_NAME (function);
2014 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2016 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2018 iter = iter->previous)
2021 && TREE_CODE (iter->value) == FUNCTION_DECL
2022 && DECL_EXTERN_C_P (iter->value)
2023 && !DECL_ARTIFICIAL (iter->value))
2031 /* Insert another USING_DECL into the current binding level, returning
2032 this declaration. If this is a redeclaration, do nothing, and
2033 return NULL_TREE if this not in namespace scope (in namespace
2034 scope, a using decl might extend any previous bindings). */
2037 push_using_decl_1 (tree scope, tree name)
2041 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2042 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2043 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2044 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2047 return namespace_bindings_p () ? decl : NULL_TREE;
2048 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2049 USING_DECL_SCOPE (decl) = scope;
2050 DECL_CHAIN (decl) = current_binding_level->usings;
2051 current_binding_level->usings = decl;
2055 /* Wrapper for push_using_decl_1. */
2058 push_using_decl (tree scope, tree name)
2061 timevar_start (TV_NAME_LOOKUP);
2062 ret = push_using_decl_1 (scope, name);
2063 timevar_stop (TV_NAME_LOOKUP);
2067 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2068 caller to set DECL_CONTEXT properly.
2070 Note that this must only be used when X will be the new innermost
2071 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2072 without checking to see if the current IDENTIFIER_BINDING comes from a
2073 closer binding level than LEVEL. */
2076 pushdecl_with_scope_1 (tree x, cxx_scope *level, bool is_friend)
2078 struct cp_binding_level *b;
2079 tree function_decl = current_function_decl;
2081 current_function_decl = NULL_TREE;
2082 if (level->kind == sk_class)
2084 b = class_binding_level;
2085 class_binding_level = level;
2086 pushdecl_class_level (x);
2087 class_binding_level = b;
2091 b = current_binding_level;
2092 current_binding_level = level;
2093 x = pushdecl_maybe_friend (x, is_friend);
2094 current_binding_level = b;
2096 current_function_decl = function_decl;
2100 /* Wrapper for pushdecl_with_scope_1. */
2103 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
2106 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2107 ret = pushdecl_with_scope_1 (x, level, is_friend);
2108 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2113 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2114 other definitions already in place. We get around this by making
2115 the value of the identifier point to a list of all the things that
2116 want to be referenced by that name. It is then up to the users of
2117 that name to decide what to do with that list.
2119 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2120 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2122 FLAGS is a bitwise-or of the following values:
2123 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2125 PUSH_USING: DECL is being pushed as the result of a using
2128 IS_FRIEND is true if this is a friend declaration.
2130 The value returned may be a previous declaration if we guessed wrong
2131 about what language DECL should belong to (C or C++). Otherwise,
2132 it's always DECL (and never something that's not a _DECL). */
2135 push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2137 tree name = DECL_NAME (decl);
2140 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2143 old = namespace_binding (name, DECL_CONTEXT (decl));
2145 old = lookup_name_innermost_nonclass_level (name);
2149 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2151 tree t = TREE_TYPE (old);
2152 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2153 && (! DECL_IN_SYSTEM_HEADER (decl)
2154 || ! DECL_IN_SYSTEM_HEADER (old)))
2155 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2158 else if (is_overloaded_fn (old))
2162 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2164 tree fn = OVL_CURRENT (tmp);
2167 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2168 && !(flags & PUSH_USING)
2169 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2170 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2171 && ! decls_match (fn, decl))
2172 error ("%q#D conflicts with previous using declaration %q#D",
2175 dup = duplicate_decls (decl, fn, is_friend);
2176 /* If DECL was a redeclaration of FN -- even an invalid
2177 one -- pass that information along to our caller. */
2178 if (dup == fn || dup == error_mark_node)
2182 /* We don't overload implicit built-ins. duplicate_decls()
2183 may fail to merge the decls if the new decl is e.g. a
2184 template function. */
2185 if (TREE_CODE (old) == FUNCTION_DECL
2186 && DECL_ANTICIPATED (old)
2187 && !DECL_HIDDEN_FRIEND_P (old))
2190 else if (old == error_mark_node)
2191 /* Ignore the undefined symbol marker. */
2195 error ("previous non-function declaration %q+#D", old);
2196 error ("conflicts with function declaration %q#D", decl);
2201 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2202 /* If it's a using declaration, we always need to build an OVERLOAD,
2203 because it's the only way to remember that the declaration comes
2204 from 'using', and have the lookup behave correctly. */
2205 || (flags & PUSH_USING))
2207 if (old && TREE_CODE (old) != OVERLOAD)
2208 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2210 new_binding = ovl_cons (decl, old);
2211 if (flags & PUSH_USING)
2212 OVL_USED (new_binding) = 1;
2215 /* NAME is not ambiguous. */
2219 set_namespace_binding (name, current_namespace, new_binding);
2222 /* We only create an OVERLOAD if there was a previous binding at
2223 this level, or if decl is a template. In the former case, we
2224 need to remove the old binding and replace it with the new
2225 binding. We must also run through the NAMES on the binding
2226 level where the name was bound to update the chain. */
2228 if (TREE_CODE (new_binding) == OVERLOAD && old)
2232 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2234 d = &TREE_CHAIN (*d))
2236 || (TREE_CODE (*d) == TREE_LIST
2237 && TREE_VALUE (*d) == old))
2239 if (TREE_CODE (*d) == TREE_LIST)
2240 /* Just replace the old binding with the new. */
2241 TREE_VALUE (*d) = new_binding;
2243 /* Build a TREE_LIST to wrap the OVERLOAD. */
2244 *d = tree_cons (NULL_TREE, new_binding,
2247 /* And update the cxx_binding node. */
2248 IDENTIFIER_BINDING (name)->value = new_binding;
2252 /* We should always find a previous binding in this case. */
2256 /* Install the new binding. */
2257 push_local_binding (name, new_binding, flags);
2263 /* Wrapper for push_overloaded_decl_1. */
2266 push_overloaded_decl (tree decl, int flags, bool is_friend)
2269 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2270 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2271 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2275 /* Check a non-member using-declaration. Return the name and scope
2276 being used, and the USING_DECL, or NULL_TREE on failure. */
2279 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2281 /* [namespace.udecl]
2282 A using-declaration for a class member shall be a
2283 member-declaration. */
2286 error ("%qT is not a namespace", scope);
2289 else if (scope == error_mark_node)
2292 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2295 A using-declaration shall not name a template-id. */
2296 error ("a using-declaration cannot specify a template-id. "
2297 "Try %<using %D%>", name);
2301 if (TREE_CODE (decl) == NAMESPACE_DECL)
2303 error ("namespace %qD not allowed in using-declaration", decl);
2307 if (TREE_CODE (decl) == SCOPE_REF)
2309 /* It's a nested name with template parameter dependent scope.
2310 This can only be using-declaration for class member. */
2311 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2315 if (is_overloaded_fn (decl))
2316 decl = get_first_fn (decl);
2318 gcc_assert (DECL_P (decl));
2320 /* Make a USING_DECL. */
2321 return push_using_decl (scope, name);
2324 /* Process local and global using-declarations. */
2327 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2328 tree *newval, tree *newtype)
2330 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2332 *newval = *newtype = NULL_TREE;
2333 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2337 if (!decls.value && !decls.type)
2339 error ("%qD not declared", name);
2343 /* Shift the old and new bindings around so we're comparing class and
2344 enumeration names to each other. */
2345 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2351 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2353 decls.type = decls.value;
2354 decls.value = NULL_TREE;
2357 /* It is impossible to overload a built-in function; any explicit
2358 declaration eliminates the built-in declaration. So, if OLDVAL
2359 is a built-in, then we can just pretend it isn't there. */
2361 && TREE_CODE (oldval) == FUNCTION_DECL
2362 && DECL_ANTICIPATED (oldval)
2363 && !DECL_HIDDEN_FRIEND_P (oldval))
2368 /* Check for using functions. */
2369 if (is_overloaded_fn (decls.value))
2373 if (oldval && !is_overloaded_fn (oldval))
2375 error ("%qD is already declared in this scope", name);
2380 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2382 tree new_fn = OVL_CURRENT (tmp);
2384 /* [namespace.udecl]
2386 If a function declaration in namespace scope or block
2387 scope has the same name and the same parameter types as a
2388 function introduced by a using declaration the program is
2390 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2392 tree old_fn = OVL_CURRENT (tmp1);
2394 if (new_fn == old_fn)
2395 /* The function already exists in the current namespace. */
2397 else if (OVL_USED (tmp1))
2398 continue; /* this is a using decl */
2399 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2400 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2402 gcc_assert (!DECL_ANTICIPATED (old_fn)
2403 || DECL_HIDDEN_FRIEND_P (old_fn));
2405 /* There was already a non-using declaration in
2406 this scope with the same parameter types. If both
2407 are the same extern "C" functions, that's ok. */
2408 if (decls_match (new_fn, old_fn))
2412 error ("%qD is already declared in this scope", name);
2418 /* If we broke out of the loop, there's no reason to add
2419 this function to the using declarations for this
2424 /* If we are adding to an existing OVERLOAD, then we no
2425 longer know the type of the set of functions. */
2426 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2427 TREE_TYPE (*newval) = unknown_type_node;
2428 /* Add this new function to the set. */
2429 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2430 /* If there is only one function, then we use its type. (A
2431 using-declaration naming a single function can be used in
2432 contexts where overload resolution cannot be
2434 if (TREE_CODE (*newval) != OVERLOAD)
2436 *newval = ovl_cons (*newval, NULL_TREE);
2437 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2439 OVL_USED (*newval) = 1;
2444 *newval = decls.value;
2445 if (oldval && !decls_match (*newval, oldval))
2446 error ("%qD is already declared in this scope", name);
2452 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2454 error ("reference to %qD is ambiguous", name);
2455 print_candidates (decls.type);
2459 *newtype = decls.type;
2460 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2461 error ("%qD is already declared in this scope", name);
2464 /* If *newval is empty, shift any class or enumeration name down. */
2468 *newtype = NULL_TREE;
2472 /* Process a using-declaration at function scope. */
2475 do_local_using_decl (tree decl, tree scope, tree name)
2477 tree oldval, oldtype, newval, newtype;
2478 tree orig_decl = decl;
2480 decl = validate_nonmember_using_decl (decl, scope, name);
2481 if (decl == NULL_TREE)
2484 if (building_stmt_list_p ()
2485 && at_function_scope_p ())
2486 add_decl_expr (decl);
2488 oldval = lookup_name_innermost_nonclass_level (name);
2489 oldtype = lookup_type_current_level (name);
2491 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2495 if (is_overloaded_fn (newval))
2499 /* We only need to push declarations for those functions
2500 that were not already bound in the current level.
2501 The old value might be NULL_TREE, it might be a single
2502 function, or an OVERLOAD. */
2503 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2504 term = OVL_FUNCTION (oldval);
2507 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2509 push_overloaded_decl (OVL_CURRENT (fn),
2510 PUSH_LOCAL | PUSH_USING,
2514 push_local_binding (name, newval, PUSH_USING);
2518 push_local_binding (name, newtype, PUSH_USING);
2519 set_identifier_type_value (name, newtype);
2522 /* Emit debug info. */
2523 if (!processing_template_decl)
2524 cp_emit_debug_info_for_using (orig_decl, current_scope());
2527 /* Returns true if ROOT (a namespace, class, or function) encloses
2528 CHILD. CHILD may be either a class type or a namespace. */
2531 is_ancestor (tree root, tree child)
2533 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2534 || TREE_CODE (root) == FUNCTION_DECL
2535 || CLASS_TYPE_P (root)));
2536 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2537 || CLASS_TYPE_P (child)));
2539 /* The global namespace encloses everything. */
2540 if (root == global_namespace)
2545 /* If we've run out of scopes, stop. */
2548 /* If we've reached the ROOT, it encloses CHILD. */
2551 /* Go out one level. */
2553 child = TYPE_NAME (child);
2554 child = DECL_CONTEXT (child);
2558 /* Enter the class or namespace scope indicated by T suitable for name
2559 lookup. T can be arbitrary scope, not necessary nested inside the
2560 current scope. Returns a non-null scope to pop iff pop_scope
2561 should be called later to exit this scope. */
2566 if (TREE_CODE (t) == NAMESPACE_DECL)
2567 push_decl_namespace (t);
2568 else if (CLASS_TYPE_P (t))
2570 if (!at_class_scope_p ()
2571 || !same_type_p (current_class_type, t))
2572 push_nested_class (t);
2574 /* T is the same as the current scope. There is therefore no
2575 need to re-enter the scope. Since we are not actually
2576 pushing a new scope, our caller should not call
2584 /* Leave scope pushed by push_scope. */
2591 if (TREE_CODE (t) == NAMESPACE_DECL)
2592 pop_decl_namespace ();
2593 else if CLASS_TYPE_P (t)
2594 pop_nested_class ();
2597 /* Subroutine of push_inner_scope. */
2600 push_inner_scope_r (tree outer, tree inner)
2605 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2608 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2610 push_inner_scope_r (outer, prev);
2611 if (TREE_CODE (inner) == NAMESPACE_DECL)
2613 struct cp_binding_level *save_template_parm = 0;
2614 /* Temporary take out template parameter scopes. They are saved
2615 in reversed order in save_template_parm. */
2616 while (current_binding_level->kind == sk_template_parms)
2618 struct cp_binding_level *b = current_binding_level;
2619 current_binding_level = b->level_chain;
2620 b->level_chain = save_template_parm;
2621 save_template_parm = b;
2624 resume_scope (NAMESPACE_LEVEL (inner));
2625 current_namespace = inner;
2627 /* Restore template parameter scopes. */
2628 while (save_template_parm)
2630 struct cp_binding_level *b = save_template_parm;
2631 save_template_parm = b->level_chain;
2632 b->level_chain = current_binding_level;
2633 current_binding_level = b;
2640 /* Enter the scope INNER from current scope. INNER must be a scope
2641 nested inside current scope. This works with both name lookup and
2642 pushing name into scope. In case a template parameter scope is present,
2643 namespace is pushed under the template parameter scope according to
2644 name lookup rule in 14.6.1/6.
2646 Return the former current scope suitable for pop_inner_scope. */
2649 push_inner_scope (tree inner)
2651 tree outer = current_scope ();
2653 outer = current_namespace;
2655 push_inner_scope_r (outer, inner);
2659 /* Exit the current scope INNER back to scope OUTER. */
2662 pop_inner_scope (tree outer, tree inner)
2665 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2668 while (outer != inner)
2670 if (TREE_CODE (inner) == NAMESPACE_DECL)
2672 struct cp_binding_level *save_template_parm = 0;
2673 /* Temporary take out template parameter scopes. They are saved
2674 in reversed order in save_template_parm. */
2675 while (current_binding_level->kind == sk_template_parms)
2677 struct cp_binding_level *b = current_binding_level;
2678 current_binding_level = b->level_chain;
2679 b->level_chain = save_template_parm;
2680 save_template_parm = b;
2685 /* Restore template parameter scopes. */
2686 while (save_template_parm)
2688 struct cp_binding_level *b = save_template_parm;
2689 save_template_parm = b->level_chain;
2690 b->level_chain = current_binding_level;
2691 current_binding_level = b;
2697 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2701 /* Do a pushlevel for class declarations. */
2704 pushlevel_class (void)
2706 class_binding_level = begin_scope (sk_class, current_class_type);
2709 /* ...and a poplevel for class declarations. */
2712 poplevel_class (void)
2714 struct cp_binding_level *level = class_binding_level;
2715 cp_class_binding *cb;
2719 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2720 gcc_assert (level != 0);
2722 /* If we're leaving a toplevel class, cache its binding level. */
2723 if (current_class_depth == 1)
2724 previous_class_level = level;
2725 for (shadowed = level->type_shadowed;
2727 shadowed = TREE_CHAIN (shadowed))
2728 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2730 /* Remove the bindings for all of the class-level declarations. */
2731 if (level->class_shadowed)
2733 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2735 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2736 cxx_binding_free (cb->base);
2738 ggc_free (level->class_shadowed);
2739 level->class_shadowed = NULL;
2742 /* Now, pop out of the binding level which we created up in the
2743 `pushlevel_class' routine. */
2744 gcc_assert (current_binding_level == level);
2746 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2749 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2750 appropriate. DECL is the value to which a name has just been
2751 bound. CLASS_TYPE is the class in which the lookup occurred. */
2754 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2757 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2761 if (TREE_CODE (decl) == OVERLOAD)
2762 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2765 gcc_assert (DECL_P (decl));
2766 context = context_for_name_lookup (decl);
2769 if (is_properly_derived_from (class_type, context))
2770 INHERITED_VALUE_BINDING_P (binding) = 1;
2772 INHERITED_VALUE_BINDING_P (binding) = 0;
2774 else if (binding->value == decl)
2775 /* We only encounter a TREE_LIST when there is an ambiguity in the
2776 base classes. Such an ambiguity can be overridden by a
2777 definition in this class. */
2778 INHERITED_VALUE_BINDING_P (binding) = 1;
2780 INHERITED_VALUE_BINDING_P (binding) = 0;
2783 /* Make the declaration of X appear in CLASS scope. */
2786 pushdecl_class_level (tree x)
2789 bool is_valid = true;
2792 /* Do nothing if we're adding to an outer lambda closure type,
2793 outer_binding will add it later if it's needed. */
2794 if (current_class_type != class_binding_level->this_entity)
2797 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2798 /* Get the name of X. */
2799 if (TREE_CODE (x) == OVERLOAD)
2800 name = DECL_NAME (get_first_fn (x));
2802 name = DECL_NAME (x);
2806 is_valid = push_class_level_binding (name, x);
2807 if (TREE_CODE (x) == TYPE_DECL)
2808 set_identifier_type_value (name, x);
2810 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2812 /* If X is an anonymous aggregate, all of its members are
2813 treated as if they were members of the class containing the
2814 aggregate, for naming purposes. */
2817 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2819 location_t save_location = input_location;
2820 input_location = DECL_SOURCE_LOCATION (f);
2821 if (!pushdecl_class_level (f))
2823 input_location = save_location;
2826 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2830 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2831 scope. If the value returned is non-NULL, and the PREVIOUS field
2832 is not set, callers must set the PREVIOUS field explicitly. */
2834 static cxx_binding *
2835 get_class_binding (tree name, cxx_scope *scope)
2840 cxx_binding *binding;
2842 class_type = scope->this_entity;
2844 /* Get the type binding. */
2845 type_binding = lookup_member (class_type, name,
2846 /*protect=*/2, /*want_type=*/true);
2847 /* Get the value binding. */
2848 value_binding = lookup_member (class_type, name,
2849 /*protect=*/2, /*want_type=*/false);
2852 && (TREE_CODE (value_binding) == TYPE_DECL
2853 || DECL_CLASS_TEMPLATE_P (value_binding)
2854 || (TREE_CODE (value_binding) == TREE_LIST
2855 && TREE_TYPE (value_binding) == error_mark_node
2856 && (TREE_CODE (TREE_VALUE (value_binding))
2858 /* We found a type binding, even when looking for a non-type
2859 binding. This means that we already processed this binding
2862 else if (value_binding)
2864 if (TREE_CODE (value_binding) == TREE_LIST
2865 && TREE_TYPE (value_binding) == error_mark_node)
2866 /* NAME is ambiguous. */
2868 else if (BASELINK_P (value_binding))
2869 /* NAME is some overloaded functions. */
2870 value_binding = BASELINK_FUNCTIONS (value_binding);
2873 /* If we found either a type binding or a value binding, create a
2874 new binding object. */
2875 if (type_binding || value_binding)
2877 binding = new_class_binding (name,
2881 /* This is a class-scope binding, not a block-scope binding. */
2882 LOCAL_BINDING_P (binding) = 0;
2883 set_inherited_value_binding_p (binding, value_binding, class_type);
2891 /* Make the declaration(s) of X appear in CLASS scope under the name
2892 NAME. Returns true if the binding is valid. */
2895 push_class_level_binding_1 (tree name, tree x)
2897 cxx_binding *binding;
2901 /* The class_binding_level will be NULL if x is a template
2902 parameter name in a member template. */
2903 if (!class_binding_level)
2906 if (name == error_mark_node)
2909 /* Check for invalid member names. */
2910 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2911 /* Check that we're pushing into the right binding level. */
2912 gcc_assert (current_class_type == class_binding_level->this_entity);
2914 /* We could have been passed a tree list if this is an ambiguous
2915 declaration. If so, pull the declaration out because
2916 check_template_shadow will not handle a TREE_LIST. */
2917 if (TREE_CODE (decl) == TREE_LIST
2918 && TREE_TYPE (decl) == error_mark_node)
2919 decl = TREE_VALUE (decl);
2921 if (!check_template_shadow (decl))
2926 If T is the name of a class, then each of the following shall
2927 have a name different from T:
2929 -- every static data member of class T;
2931 -- every member of class T that is itself a type;
2933 -- every enumerator of every member of class T that is an
2936 -- every member of every anonymous union that is a member of
2939 (Non-static data members were also forbidden to have the same
2940 name as T until TC1.) */
2941 if ((TREE_CODE (x) == VAR_DECL
2942 || TREE_CODE (x) == CONST_DECL
2943 || (TREE_CODE (x) == TYPE_DECL
2944 && !DECL_SELF_REFERENCE_P (x))
2945 /* A data member of an anonymous union. */
2946 || (TREE_CODE (x) == FIELD_DECL
2947 && DECL_CONTEXT (x) != current_class_type))
2948 && DECL_NAME (x) == constructor_name (current_class_type))
2950 tree scope = context_for_name_lookup (x);
2951 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2953 error ("%qD has the same name as the class in which it is "
2960 /* Get the current binding for NAME in this class, if any. */
2961 binding = IDENTIFIER_BINDING (name);
2962 if (!binding || binding->scope != class_binding_level)
2964 binding = get_class_binding (name, class_binding_level);
2965 /* If a new binding was created, put it at the front of the
2966 IDENTIFIER_BINDING list. */
2969 binding->previous = IDENTIFIER_BINDING (name);
2970 IDENTIFIER_BINDING (name) = binding;
2974 /* If there is already a binding, then we may need to update the
2976 if (binding && binding->value)
2978 tree bval = binding->value;
2979 tree old_decl = NULL_TREE;
2981 if (INHERITED_VALUE_BINDING_P (binding))
2983 /* If the old binding was from a base class, and was for a
2984 tag name, slide it over to make room for the new binding.
2985 The old binding is still visible if explicitly qualified
2986 with a class-key. */
2987 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2988 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2990 old_decl = binding->type;
2991 binding->type = bval;
2992 binding->value = NULL_TREE;
2993 INHERITED_VALUE_BINDING_P (binding) = 0;
2998 /* Any inherited type declaration is hidden by the type
2999 declaration in the derived class. */
3000 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
3001 binding->type = NULL_TREE;
3004 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
3006 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
3008 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
3010 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
3013 if (old_decl && binding->scope == class_binding_level)
3016 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3017 here. This function is only used to register bindings
3018 from with the class definition itself. */
3019 INHERITED_VALUE_BINDING_P (binding) = 0;
3024 /* Note that we declared this value so that we can issue an error if
3025 this is an invalid redeclaration of a name already used for some
3027 note_name_declared_in_class (name, decl);
3029 /* If we didn't replace an existing binding, put the binding on the
3030 stack of bindings for the identifier, and update the shadowed
3032 if (binding && binding->scope == class_binding_level)
3033 /* Supplement the existing binding. */
3034 ok = supplement_binding (binding, decl);
3037 /* Create a new binding. */
3038 push_binding (name, decl, class_binding_level);
3045 /* Wrapper for push_class_level_binding_1. */
3048 push_class_level_binding (tree name, tree x)
3051 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3052 ret = push_class_level_binding_1 (name, x);
3053 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3057 /* Process "using SCOPE::NAME" in a class scope. Return the
3058 USING_DECL created. */
3061 do_class_using_decl (tree scope, tree name)
3063 /* The USING_DECL returned by this function. */
3065 /* The declaration (or declarations) name by this using
3066 declaration. NULL if we are in a template and cannot figure out
3067 what has been named. */
3069 /* True if SCOPE is a dependent type. */
3070 bool scope_dependent_p;
3071 /* True if SCOPE::NAME is dependent. */
3072 bool name_dependent_p;
3073 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3074 bool bases_dependent_p;
3079 if (name == error_mark_node)
3082 if (!scope || !TYPE_P (scope))
3084 error ("using-declaration for non-member at class scope");
3088 /* Make sure the name is not invalid */
3089 if (TREE_CODE (name) == BIT_NOT_EXPR)
3091 error ("%<%T::%D%> names destructor", scope, name);
3094 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3096 error ("%<%T::%D%> names constructor", scope, name);
3099 if (constructor_name_p (name, current_class_type))
3101 error ("%<%T::%D%> names constructor in %qT",
3102 scope, name, current_class_type);
3106 scope_dependent_p = dependent_type_p (scope);
3107 name_dependent_p = (scope_dependent_p
3108 || (IDENTIFIER_TYPENAME_P (name)
3109 && dependent_type_p (TREE_TYPE (name))));
3111 bases_dependent_p = false;
3112 if (processing_template_decl)
3113 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3114 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3116 if (dependent_type_p (TREE_TYPE (base_binfo)))
3118 bases_dependent_p = true;
3124 /* From [namespace.udecl]:
3126 A using-declaration used as a member-declaration shall refer to a
3127 member of a base class of the class being defined.
3129 In general, we cannot check this constraint in a template because
3130 we do not know the entire set of base classes of the current
3131 class type. However, if all of the base classes are
3132 non-dependent, then we can avoid delaying the check until
3134 if (!scope_dependent_p)
3137 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3138 if (b_kind < bk_proper_base)
3140 if (!bases_dependent_p)
3142 error_not_base_type (scope, current_class_type);
3146 else if (!name_dependent_p)
3148 decl = lookup_member (binfo, name, 0, false);
3151 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3155 /* The binfo from which the functions came does not matter. */
3156 if (BASELINK_P (decl))
3157 decl = BASELINK_FUNCTIONS (decl);
3161 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3162 USING_DECL_DECLS (value) = decl;
3163 USING_DECL_SCOPE (value) = scope;
3164 DECL_DEPENDENT_P (value) = !decl;
3170 /* Return the binding value for name in scope. */
3174 namespace_binding_1 (tree name, tree scope)
3176 cxx_binding *binding;
3178 if (SCOPE_FILE_SCOPE_P (scope))
3179 scope = global_namespace;
3181 /* Unnecessary for the global namespace because it can't be an alias. */
3182 scope = ORIGINAL_NAMESPACE (scope);
3184 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3186 return binding ? binding->value : NULL_TREE;
3190 namespace_binding (tree name, tree scope)
3193 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3194 ret = namespace_binding_1 (name, scope);
3195 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3199 /* Set the binding value for name in scope. */
3202 set_namespace_binding_1 (tree name, tree scope, tree val)
3206 if (scope == NULL_TREE)
3207 scope = global_namespace;
3208 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3209 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3212 supplement_binding (b, val);
3215 /* Wrapper for set_namespace_binding_1. */
3218 set_namespace_binding (tree name, tree scope, tree val)
3220 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3221 set_namespace_binding_1 (name, scope, val);
3222 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3225 /* Set the context of a declaration to scope. Complain if we are not
3229 set_decl_namespace (tree decl, tree scope, bool friendp)
3233 /* Get rid of namespace aliases. */
3234 scope = ORIGINAL_NAMESPACE (scope);
3236 /* It is ok for friends to be qualified in parallel space. */
3237 if (!friendp && !is_ancestor (current_namespace, scope))
3238 error ("declaration of %qD not in a namespace surrounding %qD",
3240 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3242 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3243 if (scope == current_namespace)
3245 if (at_namespace_scope_p ())
3246 error ("explicit qualification in declaration of %qD",
3251 /* See whether this has been declared in the namespace. */
3252 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3253 if (old == error_mark_node)
3254 /* No old declaration at all. */
3256 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3257 if (TREE_CODE (old) == TREE_LIST)
3259 error ("reference to %qD is ambiguous", decl);
3260 print_candidates (old);
3263 if (!is_overloaded_fn (decl))
3265 /* We might have found OLD in an inline namespace inside SCOPE. */
3266 if (TREE_CODE (decl) == TREE_CODE (old))
3267 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3268 /* Don't compare non-function decls with decls_match here, since
3269 it can't check for the correct constness at this
3270 point. pushdecl will find those errors later. */
3273 /* Since decl is a function, old should contain a function decl. */
3274 if (!is_overloaded_fn (old))
3276 /* A template can be explicitly specialized in any namespace. */
3277 if (processing_explicit_instantiation)
3279 if (processing_template_decl || processing_specialization)
3280 /* We have not yet called push_template_decl to turn a
3281 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3282 match. But, we'll check later, when we construct the
3285 /* Instantiations or specializations of templates may be declared as
3286 friends in any namespace. */
3287 if (friendp && DECL_USE_TEMPLATE (decl))
3289 if (is_overloaded_fn (old))
3291 tree found = NULL_TREE;
3293 for (; elt; elt = OVL_NEXT (elt))
3295 tree ofn = OVL_CURRENT (elt);
3296 /* Adjust DECL_CONTEXT first so decls_match will return true
3297 if DECL will match a declaration in an inline namespace. */
3298 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3299 if (decls_match (decl, ofn))
3301 if (found && !decls_match (found, ofn))
3303 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3304 error ("reference to %qD is ambiguous", decl);
3305 print_candidates (old);
3313 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3315 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3321 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3322 if (decls_match (decl, old))
3326 /* It didn't work, go back to the explicit scope. */
3327 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3329 error ("%qD should have been declared inside %qD", decl, scope);
3332 /* Return the namespace where the current declaration is declared. */
3335 current_decl_namespace (void)
3338 /* If we have been pushed into a different namespace, use it. */
3339 if (!VEC_empty (tree, decl_namespace_list))
3340 return VEC_last (tree, decl_namespace_list);
3342 if (current_class_type)
3343 result = decl_namespace_context (current_class_type);
3344 else if (current_function_decl)
3345 result = decl_namespace_context (current_function_decl);
3347 result = current_namespace;
3351 /* Process any ATTRIBUTES on a namespace definition. Currently only
3352 attribute visibility is meaningful, which is a property of the syntactic
3353 block rather than the namespace as a whole, so we don't touch the
3354 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3357 handle_namespace_attrs (tree ns, tree attributes)
3360 bool saw_vis = false;
3362 for (d = attributes; d; d = TREE_CHAIN (d))
3364 tree name = TREE_PURPOSE (d);
3365 tree args = TREE_VALUE (d);
3367 if (is_attribute_p ("visibility", name))
3369 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3370 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3372 warning (OPT_Wattributes,
3373 "%qD attribute requires a single NTBS argument",
3378 if (!TREE_PUBLIC (ns))
3379 warning (OPT_Wattributes,
3380 "%qD attribute is meaningless since members of the "
3381 "anonymous namespace get local symbols", name);
3383 push_visibility (TREE_STRING_POINTER (x), 1);
3388 warning (OPT_Wattributes, "%qD attribute directive ignored",
3397 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3398 select a name that is unique to this compilation unit. */
3401 push_namespace (tree name)
3405 int implicit_use = 0;
3408 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3410 /* We should not get here if the global_namespace is not yet constructed
3411 nor if NAME designates the global namespace: The global scope is
3412 constructed elsewhere. */
3413 gcc_assert (global_namespace != NULL && name != global_scope_name);
3417 name = get_anonymous_namespace_name();
3418 d = IDENTIFIER_NAMESPACE_VALUE (name);
3420 /* Reopening anonymous namespace. */
3426 /* Check whether this is an extended namespace definition. */
3427 d = IDENTIFIER_NAMESPACE_VALUE (name);
3428 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3431 if (DECL_NAMESPACE_ALIAS (d))
3433 error ("namespace alias %qD not allowed here, assuming %qD",
3434 d, DECL_NAMESPACE_ALIAS (d));
3435 d = DECL_NAMESPACE_ALIAS (d);
3442 /* Make a new namespace, binding the name to it. */
3443 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3444 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3445 /* The name of this namespace is not visible to other translation
3446 units if it is an anonymous namespace or member thereof. */
3447 if (anon || decl_anon_ns_mem_p (current_namespace))
3448 TREE_PUBLIC (d) = 0;
3450 TREE_PUBLIC (d) = 1;
3454 /* Clear DECL_NAME for the benefit of debugging back ends. */
3455 SET_DECL_ASSEMBLER_NAME (d, name);
3456 DECL_NAME (d) = NULL_TREE;
3458 begin_scope (sk_namespace, d);
3461 resume_scope (NAMESPACE_LEVEL (d));
3464 do_using_directive (d);
3465 /* Enter the name space. */
3466 current_namespace = d;
3468 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3471 /* Pop from the scope of the current namespace. */
3474 pop_namespace (void)
3476 gcc_assert (current_namespace != global_namespace);
3477 current_namespace = CP_DECL_CONTEXT (current_namespace);
3478 /* The binding level is not popped, as it might be re-opened later. */
3482 /* Push into the scope of the namespace NS, even if it is deeply
3483 nested within another namespace. */
3486 push_nested_namespace (tree ns)
3488 if (ns == global_namespace)
3489 push_to_top_level ();
3492 push_nested_namespace (CP_DECL_CONTEXT (ns));
3493 push_namespace (DECL_NAME (ns));
3497 /* Pop back from the scope of the namespace NS, which was previously
3498 entered with push_nested_namespace. */
3501 pop_nested_namespace (tree ns)
3503 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3504 gcc_assert (current_namespace == ns);
3505 while (ns != global_namespace)
3508 ns = CP_DECL_CONTEXT (ns);
3511 pop_from_top_level ();
3512 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3515 /* Temporarily set the namespace for the current declaration. */
3518 push_decl_namespace (tree decl)
3520 if (TREE_CODE (decl) != NAMESPACE_DECL)
3521 decl = decl_namespace_context (decl);
3522 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3525 /* [namespace.memdef]/2 */
3528 pop_decl_namespace (void)
3530 VEC_pop (tree, decl_namespace_list);
3533 /* Return the namespace that is the common ancestor
3534 of two given namespaces. */
3537 namespace_ancestor_1 (tree ns1, tree ns2)
3540 if (is_ancestor (ns1, ns2))
3543 nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
3547 /* Wrapper for namespace_ancestor_1. */
3550 namespace_ancestor (tree ns1, tree ns2)
3553 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3554 nsr = namespace_ancestor_1 (ns1, ns2);
3555 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3559 /* Process a namespace-alias declaration. */
3562 do_namespace_alias (tree alias, tree name_space)
3564 if (name_space == error_mark_node)
3567 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3569 name_space = ORIGINAL_NAMESPACE (name_space);
3571 /* Build the alias. */
3572 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3573 DECL_NAMESPACE_ALIAS (alias) = name_space;
3574 DECL_EXTERNAL (alias) = 1;
3575 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3578 /* Emit debug info for namespace alias. */
3579 if (!building_stmt_list_p ())
3580 (*debug_hooks->global_decl) (alias);
3583 /* Like pushdecl, only it places X in the current namespace,
3587 pushdecl_namespace_level (tree x, bool is_friend)
3589 struct cp_binding_level *b = current_binding_level;
3592 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3593 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3595 /* Now, the type_shadowed stack may screw us. Munge it so it does
3597 if (TREE_CODE (t) == TYPE_DECL)
3599 tree name = DECL_NAME (t);
3601 tree *ptr = (tree *)0;
3602 for (; !global_scope_p (b); b = b->level_chain)
3604 tree shadowed = b->type_shadowed;
3605 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3606 if (TREE_PURPOSE (shadowed) == name)
3608 ptr = &TREE_VALUE (shadowed);
3609 /* Can't break out of the loop here because sometimes
3610 a binding level will have duplicate bindings for
3611 PT names. It's gross, but I haven't time to fix it. */
3614 newval = TREE_TYPE (t);
3615 if (ptr == (tree *)0)
3617 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3618 up here if this is changed to an assertion. --KR */
3619 SET_IDENTIFIER_TYPE_VALUE (name, t);
3626 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3630 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3631 directive is not directly from the source. Also find the common
3632 ancestor and let our users know about the new namespace */
3635 add_using_namespace_1 (tree user, tree used, bool indirect)
3638 /* Using oneself is a no-op. */
3641 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3642 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3643 /* Check if we already have this. */
3644 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3648 /* Promote to direct usage. */
3649 TREE_INDIRECT_USING (t) = 0;
3653 /* Add used to the user's using list. */
3654 DECL_NAMESPACE_USING (user)
3655 = tree_cons (used, namespace_ancestor (user, used),
3656 DECL_NAMESPACE_USING (user));
3658 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3660 /* Add user to the used's users list. */
3661 DECL_NAMESPACE_USERS (used)
3662 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3664 /* Recursively add all namespaces used. */
3665 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3666 /* indirect usage */
3667 add_using_namespace_1 (user, TREE_PURPOSE (t), 1);
3669 /* Tell everyone using us about the new used namespaces. */
3670 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3671 add_using_namespace_1 (TREE_PURPOSE (t), used, 1);
3674 /* Wrapper for add_using_namespace_1. */
3677 add_using_namespace (tree user, tree used, bool indirect)
3679 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3680 add_using_namespace_1 (user, used, indirect);
3681 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3684 /* Process a using-declaration not appearing in class or local scope. */
3687 do_toplevel_using_decl (tree decl, tree scope, tree name)
3689 tree oldval, oldtype, newval, newtype;
3690 tree orig_decl = decl;
3691 cxx_binding *binding;
3693 decl = validate_nonmember_using_decl (decl, scope, name);
3694 if (decl == NULL_TREE)
3697 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3699 oldval = binding->value;
3700 oldtype = binding->type;
3702 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3704 /* Emit debug info. */
3705 if (!processing_template_decl)
3706 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3708 /* Copy declarations found. */
3710 binding->value = newval;
3712 binding->type = newtype;
3715 /* Process a using-directive. */
3718 do_using_directive (tree name_space)
3720 tree context = NULL_TREE;
3722 if (name_space == error_mark_node)
3725 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3727 if (building_stmt_list_p ())
3728 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3729 name_space = ORIGINAL_NAMESPACE (name_space);
3731 if (!toplevel_bindings_p ())
3733 push_using_directive (name_space);
3738 add_using_namespace (current_namespace, name_space, 0);
3739 if (current_namespace != global_namespace)
3740 context = current_namespace;
3742 /* Emit debugging info. */
3743 if (!processing_template_decl)
3744 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3749 /* Deal with a using-directive seen by the parser. Currently we only
3750 handle attributes here, since they cannot appear inside a template. */
3753 parse_using_directive (tree name_space, tree attribs)
3757 do_using_directive (name_space);
3759 for (a = attribs; a; a = TREE_CHAIN (a))
3761 tree name = TREE_PURPOSE (a);
3762 if (is_attribute_p ("strong", name))
3764 if (!toplevel_bindings_p ())
3765 error ("strong using only meaningful at namespace scope");
3766 else if (name_space != error_mark_node)
3768 if (!is_ancestor (current_namespace, name_space))
3769 error ("current namespace %qD does not enclose strongly used namespace %qD",
3770 current_namespace, name_space);
3771 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3772 = tree_cons (current_namespace, 0,
3773 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3777 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3781 /* Like pushdecl, only it places X in the global scope if appropriate.
3782 Calls cp_finish_decl to register the variable, initializing it with
3783 *INIT, if INIT is non-NULL. */
3786 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3788 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3789 push_to_top_level ();
3790 x = pushdecl_namespace_level (x, is_friend);
3792 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3793 pop_from_top_level ();
3794 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3798 /* Like pushdecl, only it places X in the global scope if appropriate. */
3801 pushdecl_top_level (tree x)
3803 return pushdecl_top_level_1 (x, NULL, false);
3806 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3809 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3811 return pushdecl_top_level_1 (x, NULL, is_friend);
3814 /* Like pushdecl, only it places X in the global scope if
3815 appropriate. Calls cp_finish_decl to register the variable,
3816 initializing it with INIT. */
3819 pushdecl_top_level_and_finish (tree x, tree init)
3821 return pushdecl_top_level_1 (x, &init, false);
3824 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3825 duplicates. The first list becomes the tail of the result.
3827 The algorithm is O(n^2). We could get this down to O(n log n) by
3828 doing a sort on the addresses of the functions, if that becomes
3832 merge_functions (tree s1, tree s2)
3834 for (; s2; s2 = OVL_NEXT (s2))
3836 tree fn2 = OVL_CURRENT (s2);
3839 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3841 tree fn1 = OVL_CURRENT (fns1);
3843 /* If the function from S2 is already in S1, there is no
3844 need to add it again. For `extern "C"' functions, we
3845 might have two FUNCTION_DECLs for the same function, in
3846 different namespaces, but let's leave them in in case
3847 they have different default arguments. */
3852 /* If we exhausted all of the functions in S1, FN2 is new. */
3854 s1 = build_overload (fn2, s1);
3859 /* Returns TRUE iff OLD and NEW are the same entity.
3861 3 [basic]/3: An entity is a value, object, reference, function,
3862 enumerator, type, class member, template, template specialization,
3863 namespace, parameter pack, or this.
3865 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3866 in two different namespaces, and the declarations do not declare the
3867 same entity and do not declare functions, the use of the name is
3871 same_entity_p (tree one, tree two)
3877 if (TREE_CODE (one) == TYPE_DECL
3878 && TREE_CODE (two) == TYPE_DECL
3879 && same_type_p (TREE_TYPE (one), TREE_TYPE (two)))
3884 /* This should return an error not all definitions define functions.
3885 It is not an error if we find two functions with exactly the
3886 same signature, only if these are selected in overload resolution.
3887 old is the current set of bindings, new_binding the freshly-found binding.
3888 XXX Do we want to give *all* candidates in case of ambiguity?
3889 XXX In what way should I treat extern declarations?
3890 XXX I don't want to repeat the entire duplicate_decls here */
3893 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3896 gcc_assert (old != NULL);
3898 /* Copy the type. */
3899 type = new_binding->type;
3900 if (LOOKUP_NAMESPACES_ONLY (flags)
3901 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3904 /* Copy the value. */
3905 val = new_binding->value;
3908 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3911 switch (TREE_CODE (val))
3914 /* If we expect types or namespaces, and not templates,
3915 or this is not a template class. */
3916 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3917 && !DECL_CLASS_TEMPLATE_P (val)))
3921 if (LOOKUP_NAMESPACES_ONLY (flags)
3922 || (type && (flags & LOOKUP_PREFER_TYPES)))
3925 case NAMESPACE_DECL:
3926 if (LOOKUP_TYPES_ONLY (flags))
3930 /* Ignore built-in functions that are still anticipated. */
3931 if (LOOKUP_QUALIFIERS_ONLY (flags))
3935 if (LOOKUP_QUALIFIERS_ONLY (flags))
3940 /* If val is hidden, shift down any class or enumeration name. */
3949 else if (val && !same_entity_p (val, old->value))
3951 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3952 old->value = merge_functions (old->value, val);
3955 old->value = tree_cons (NULL_TREE, old->value,
3956 build_tree_list (NULL_TREE, val));
3957 TREE_TYPE (old->value) = error_mark_node;
3963 else if (type && old->type != type)
3965 old->type = tree_cons (NULL_TREE, old->type,
3966 build_tree_list (NULL_TREE, type));
3967 TREE_TYPE (old->type) = error_mark_node;
3971 /* Return the declarations that are members of the namespace NS. */
3974 cp_namespace_decls (tree ns)
3976 return NAMESPACE_LEVEL (ns)->names;
3979 /* Combine prefer_type and namespaces_only into flags. */
3982 lookup_flags (int prefer_type, int namespaces_only)
3984 if (namespaces_only)
3985 return LOOKUP_PREFER_NAMESPACES;
3986 if (prefer_type > 1)
3987 return LOOKUP_PREFER_TYPES;
3988 if (prefer_type > 0)
3989 return LOOKUP_PREFER_BOTH;
3993 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3994 ignore it or not. Subroutine of lookup_name_real and
3995 lookup_type_scope. */
3998 qualify_lookup (tree val, int flags)
4000 if (val == NULL_TREE)
4002 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
4004 if ((flags & LOOKUP_PREFER_TYPES)
4005 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
4007 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
4009 /* Look through lambda things that we shouldn't be able to see. */
4010 if (is_lambda_ignored_entity (val))
4015 /* Given a lookup that returned VAL, decide if we want to ignore it or
4016 not based on DECL_ANTICIPATED. */
4019 hidden_name_p (tree val)
4022 && DECL_LANG_SPECIFIC (val)
4023 && DECL_ANTICIPATED (val))
4028 /* Remove any hidden friend functions from a possibly overloaded set
4032 remove_hidden_names (tree fns)
4037 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
4039 else if (TREE_CODE (fns) == OVERLOAD)
4043 for (o = fns; o; o = OVL_NEXT (o))
4044 if (hidden_name_p (OVL_CURRENT (o)))
4050 for (o = fns; o; o = OVL_NEXT (o))
4051 if (!hidden_name_p (OVL_CURRENT (o)))
4052 n = build_overload (OVL_CURRENT (o), n);
4060 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4061 lookup failed. Search through all available namespaces and print out
4062 possible candidates. */
4065 suggest_alternatives_for (location_t location, tree name)
4067 VEC(tree,heap) *candidates = NULL;
4068 VEC(tree,heap) *namespaces_to_search = NULL;
4069 int max_to_search = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
4074 VEC_safe_push (tree, heap, namespaces_to_search, global_namespace);
4076 while (!VEC_empty (tree, namespaces_to_search)
4077 && n_searched < max_to_search)
4079 tree scope = VEC_pop (tree, namespaces_to_search);
4080 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4081 struct cp_binding_level *level = NAMESPACE_LEVEL (scope);
4083 /* Look in this namespace. */
4084 qualified_lookup_using_namespace (name, scope, &binding, 0);
4089 VEC_safe_push (tree, heap, candidates, binding.value);
4091 /* Add child namespaces. */
4092 for (t = level->namespaces; t; t = DECL_CHAIN (t))
4093 VEC_safe_push (tree, heap, namespaces_to_search, t);
4096 /* If we stopped before we could examine all namespaces, inform the
4097 user. Do this even if we don't have any candidates, since there
4098 might be more candidates further down that we weren't able to
4100 if (n_searched >= max_to_search
4101 && !VEC_empty (tree, namespaces_to_search))
4103 "maximum limit of %d namespaces searched for %qE",
4104 max_to_search, name);
4106 VEC_free (tree, heap, namespaces_to_search);
4108 /* Nothing useful to report. */
4109 if (VEC_empty (tree, candidates))
4112 inform_n (location, VEC_length (tree, candidates),
4113 "suggested alternative:",
4114 "suggested alternatives:");
4116 FOR_EACH_VEC_ELT (tree, candidates, ix, t)
4117 inform (location_of (t), " %qE", t);
4119 VEC_free (tree, heap, candidates);
4122 /* Unscoped lookup of a global: iterate over current namespaces,
4123 considering using-directives. */
4126 unqualified_namespace_lookup_1 (tree name, int flags)
4128 tree initial = current_decl_namespace ();
4129 tree scope = initial;
4131 struct cp_binding_level *level;
4132 tree val = NULL_TREE;
4134 for (; !val; scope = CP_DECL_CONTEXT (scope))
4136 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4138 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4141 ambiguous_decl (&binding, b, flags);
4143 /* Add all _DECLs seen through local using-directives. */
4144 for (level = current_binding_level;
4145 level->kind != sk_namespace;
4146 level = level->level_chain)
4147 if (!lookup_using_namespace (name, &binding, level->using_directives,
4149 /* Give up because of error. */
4150 return error_mark_node;
4152 /* Add all _DECLs seen through global using-directives. */
4153 /* XXX local and global using lists should work equally. */
4157 if (!lookup_using_namespace (name, &binding,
4158 DECL_NAMESPACE_USING (siter),
4160 /* Give up because of error. */
4161 return error_mark_node;
4162 if (siter == scope) break;
4163 siter = CP_DECL_CONTEXT (siter);
4166 val = binding.value;
4167 if (scope == global_namespace)
4173 /* Wrapper for unqualified_namespace_lookup_1. */
4176 unqualified_namespace_lookup (tree name, int flags)
4179 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4180 ret = unqualified_namespace_lookup_1 (name, flags);
4181 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4185 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4186 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4189 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4190 declaration found. If no suitable declaration can be found,
4191 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4192 neither a class-type nor a namespace a diagnostic is issued. */
4195 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
4200 if (TREE_CODE (scope) == NAMESPACE_DECL)
4202 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4204 flags |= LOOKUP_COMPLAIN;
4206 flags |= LOOKUP_PREFER_TYPES;
4207 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
4210 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
4211 t = lookup_enumerator (scope, name);
4212 else if (is_class_type (scope, complain))
4213 t = lookup_member (scope, name, 2, is_type_p);
4216 return error_mark_node;
4220 /* Subroutine of unqualified_namespace_lookup:
4221 Add the bindings of NAME in used namespaces to VAL.
4222 We are currently looking for names in namespace SCOPE, so we
4223 look through USINGS for using-directives of namespaces
4224 which have SCOPE as a common ancestor with the current scope.
4225 Returns false on errors. */
4228 lookup_using_namespace (tree name, struct scope_binding *val,
4229 tree usings, tree scope, int flags)
4232 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4233 /* Iterate over all used namespaces in current, searching for using
4234 directives of scope. */
4235 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4236 if (TREE_VALUE (iter) == scope)
4238 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
4240 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
4241 /* Resolve ambiguities. */
4243 ambiguous_decl (val, val1, flags);
4245 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4246 return val->value != error_mark_node;
4249 /* Returns true iff VEC contains TARGET. */
4252 tree_vec_contains (VEC(tree,gc)* vec, tree target)
4256 FOR_EACH_VEC_ELT (tree,vec,i,elt)
4263 Accepts the NAME to lookup and its qualifying SCOPE.
4264 Returns the name/type pair found into the cxx_binding *RESULT,
4265 or false on error. */
4268 qualified_lookup_using_namespace (tree name, tree scope,
4269 struct scope_binding *result, int flags)
4271 /* Maintain a list of namespaces visited... */
4272 VEC(tree,gc) *seen = NULL;
4273 VEC(tree,gc) *seen_inline = NULL;
4274 /* ... and a list of namespace yet to see. */
4275 VEC(tree,gc) *todo = NULL;
4276 VEC(tree,gc) *todo_maybe = NULL;
4277 VEC(tree,gc) *todo_inline = NULL;
4279 timevar_start (TV_NAME_LOOKUP);
4280 /* Look through namespace aliases. */
4281 scope = ORIGINAL_NAMESPACE (scope);
4283 /* Algorithm: Starting with SCOPE, walk through the set of used
4284 namespaces. For each used namespace, look through its inline
4285 namespace set for any bindings and usings. If no bindings are
4286 found, add any usings seen to the set of used namespaces. */
4287 VEC_safe_push (tree, gc, todo, scope);
4289 while (VEC_length (tree, todo))
4292 scope = VEC_pop (tree, todo);
4293 if (tree_vec_contains (seen, scope))
4295 VEC_safe_push (tree, gc, seen, scope);
4296 VEC_safe_push (tree, gc, todo_inline, scope);
4299 while (VEC_length (tree, todo_inline))
4301 cxx_binding *binding;
4303 scope = VEC_pop (tree, todo_inline);
4304 if (tree_vec_contains (seen_inline, scope))
4306 VEC_safe_push (tree, gc, seen_inline, scope);
4309 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4313 ambiguous_decl (result, binding, flags);
4316 for (usings = DECL_NAMESPACE_USING (scope); usings;
4317 usings = TREE_CHAIN (usings))
4318 if (!TREE_INDIRECT_USING (usings))
4320 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4321 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4323 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4328 VEC_truncate (tree, todo_maybe, 0);
4330 while (VEC_length (tree, todo_maybe))
4331 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4333 VEC_free (tree,gc,todo);
4334 VEC_free (tree,gc,todo_maybe);
4335 VEC_free (tree,gc,todo_inline);
4336 VEC_free (tree,gc,seen);
4337 VEC_free (tree,gc,seen_inline);
4338 timevar_stop (TV_NAME_LOOKUP);
4339 return result->value != error_mark_node;
4342 /* Subroutine of outer_binding.
4344 Returns TRUE if BINDING is a binding to a template parameter of
4345 SCOPE. In that case SCOPE is the scope of a primary template
4346 parameter -- in the sense of G++, i.e, a template that has its own
4349 Returns FALSE otherwise. */
4352 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4357 if (!binding || !scope)
4360 binding_value = binding->value ? binding->value : binding->type;
4363 && scope->this_entity
4364 && get_template_info (scope->this_entity)
4365 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4366 (get_template_info (scope->this_entity)))
4367 && parameter_of_template_p (binding_value,
4368 TI_TEMPLATE (get_template_info \
4369 (scope->this_entity))));
4372 /* Return the innermost non-namespace binding for NAME from a scope
4373 containing BINDING, or, if BINDING is NULL, the current scope.
4374 Please note that for a given template, the template parameters are
4375 considered to be in the scope containing the current scope.
4376 If CLASS_P is false, then class bindings are ignored. */
4379 outer_binding (tree name,
4380 cxx_binding *binding,
4385 cxx_scope *outer_scope;
4389 scope = binding->scope->level_chain;
4390 outer = binding->previous;
4394 scope = current_binding_level;
4395 outer = IDENTIFIER_BINDING (name);
4397 outer_scope = outer ? outer->scope : NULL;
4399 /* Because we create class bindings lazily, we might be missing a
4400 class binding for NAME. If there are any class binding levels
4401 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4402 declared, we must lookup NAME in those class scopes. */
4404 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4406 if (scope->kind == sk_class)
4408 cxx_binding *class_binding;
4410 class_binding = get_class_binding (name, scope);
4413 /* Thread this new class-scope binding onto the
4414 IDENTIFIER_BINDING list so that future lookups
4416 class_binding->previous = outer;
4418 binding->previous = class_binding;
4420 IDENTIFIER_BINDING (name) = class_binding;
4421 return class_binding;
4424 /* If we are in a member template, the template parms of the member
4425 template are considered to be inside the scope of the containing
4426 class, but within G++ the class bindings are all pushed between the
4427 template parms and the function body. So if the outer binding is
4428 a template parm for the current scope, return it now rather than
4429 look for a class binding. */
4430 if (outer_scope && outer_scope->kind == sk_template_parms
4431 && binding_to_template_parms_of_scope_p (outer, scope))
4434 scope = scope->level_chain;
4440 /* Return the innermost block-scope or class-scope value binding for
4441 NAME, or NULL_TREE if there is no such binding. */
4444 innermost_non_namespace_value (tree name)
4446 cxx_binding *binding;
4447 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4448 return binding ? binding->value : NULL_TREE;
4451 /* Look up NAME in the current binding level and its superiors in the
4452 namespace of variables, functions and typedefs. Return a ..._DECL
4453 node of some kind representing its definition if there is only one
4454 such declaration, or return a TREE_LIST with all the overloaded
4455 definitions if there are many, or return 0 if it is undefined.
4456 Hidden name, either friend declaration or built-in function, are
4459 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4460 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4461 Otherwise we prefer non-TYPE_DECLs.
4463 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4464 BLOCK_P is false, bindings in block scopes are ignored. */
4467 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
4468 int namespaces_only, int flags)
4471 tree val = NULL_TREE;
4473 /* Conversion operators are handled specially because ordinary
4474 unqualified name lookup will not find template conversion
4476 if (IDENTIFIER_TYPENAME_P (name))
4478 struct cp_binding_level *level;
4480 for (level = current_binding_level;
4481 level && level->kind != sk_namespace;
4482 level = level->level_chain)
4487 /* A conversion operator can only be declared in a class
4489 if (level->kind != sk_class)
4492 /* Lookup the conversion operator in the class. */
4493 class_type = level->this_entity;
4494 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4502 flags |= lookup_flags (prefer_type, namespaces_only);
4504 /* First, look in non-namespace scopes. */
4506 if (current_class_type == NULL_TREE)
4509 if (block_p || !nonclass)
4510 for (iter = outer_binding (name, NULL, !nonclass);
4512 iter = outer_binding (name, iter, !nonclass))
4516 /* Skip entities we don't want. */
4517 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4520 /* If this is the kind of thing we're looking for, we're done. */
4521 if (qualify_lookup (iter->value, flags))
4522 binding = iter->value;
4523 else if ((flags & LOOKUP_PREFER_TYPES)
4524 && qualify_lookup (iter->type, flags))
4525 binding = iter->type;
4527 binding = NULL_TREE;
4531 if (hidden_name_p (binding))
4533 /* A non namespace-scope binding can only be hidden in the
4534 presence of a local class, due to friend declarations.
4536 In particular, consider:
4544 B* b; // error: B is hidden
4545 C* c; // OK, finds ::C
4548 B *b; // error: B is hidden
4549 C *c; // OK, finds ::C
4554 The standard says that "B" is a local class in "f"
4555 (but not nested within "A") -- but that name lookup
4556 for "B" does not find this declaration until it is
4557 declared directly with "f".
4563 If a friend declaration appears in a local class and
4564 the name specified is an unqualified name, a prior
4565 declaration is looked up without considering scopes
4566 that are outside the innermost enclosing non-class
4567 scope. For a friend function declaration, if there is
4568 no prior declaration, the program is ill-formed. For a
4569 friend class declaration, if there is no prior
4570 declaration, the class that is specified belongs to the
4571 innermost enclosing non-class scope, but if it is
4572 subsequently referenced, its name is not found by name
4573 lookup until a matching declaration is provided in the
4574 innermost enclosing nonclass scope.
4576 So just keep looking for a non-hidden binding.
4578 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4586 /* Now lookup in namespace scopes. */
4588 val = unqualified_namespace_lookup (name, flags);
4590 /* If we have a single function from a using decl, pull it out. */
4591 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4592 val = OVL_FUNCTION (val);
4597 /* Wrapper for lookup_name_real_1. */
4600 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4601 int namespaces_only, int flags)
4604 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4605 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
4606 namespaces_only, flags);
4607 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4612 lookup_name_nonclass (tree name)
4614 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4618 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4621 lookup_arg_dependent (name,
4622 lookup_name_real (name, 0, 1, block_p, 0,
4628 lookup_name (tree name)
4630 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4634 lookup_name_prefer_type (tree name, int prefer_type)
4636 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4637 0, LOOKUP_COMPLAIN);
4640 /* Look up NAME for type used in elaborated name specifier in
4641 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4642 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4643 name, more scopes are checked if cleanup or template parameter
4644 scope is encountered.
4646 Unlike lookup_name_real, we make sure that NAME is actually
4647 declared in the desired scope, not from inheritance, nor using
4648 directive. For using declaration, there is DR138 still waiting
4649 to be resolved. Hidden name coming from an earlier friend
4650 declaration is also returned.
4652 A TYPE_DECL best matching the NAME is returned. Catching error
4653 and issuing diagnostics are caller's responsibility. */
4656 lookup_type_scope_1 (tree name, tag_scope scope)
4658 cxx_binding *iter = NULL;
4659 tree val = NULL_TREE;
4661 /* Look in non-namespace scope first. */
4662 if (current_binding_level->kind != sk_namespace)
4663 iter = outer_binding (name, NULL, /*class_p=*/ true);
4664 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4666 /* Check if this is the kind of thing we're looking for.
4667 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4668 base class. For ITER->VALUE, we can simply use
4669 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4672 We check ITER->TYPE before ITER->VALUE in order to handle
4673 typedef struct C {} C;
4676 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4677 && (scope != ts_current
4678 || LOCAL_BINDING_P (iter)
4679 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4681 else if ((scope != ts_current
4682 || !INHERITED_VALUE_BINDING_P (iter))
4683 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4690 /* Look in namespace scope. */
4693 iter = cxx_scope_find_binding_for_name
4694 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4698 /* If this is the kind of thing we're looking for, we're done. */
4699 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4701 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4707 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4708 and template parameter scopes. */
4711 struct cp_binding_level *b = current_binding_level;
4714 if (iter->scope == b)
4717 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4718 || b->kind == sk_function_parms)
4720 else if (b->kind == sk_class
4721 && scope == ts_within_enclosing_non_class)
4731 /* Wrapper for lookup_type_scope_1. */
4734 lookup_type_scope (tree name, tag_scope scope)
4737 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4738 ret = lookup_type_scope_1 (name, scope);
4739 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4744 /* Similar to `lookup_name' but look only in the innermost non-class
4748 lookup_name_innermost_nonclass_level_1 (tree name)
4750 struct cp_binding_level *b;
4753 b = innermost_nonclass_level ();
4755 if (b->kind == sk_namespace)
4757 t = IDENTIFIER_NAMESPACE_VALUE (name);
4759 /* extern "C" function() */
4760 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4763 else if (IDENTIFIER_BINDING (name)
4764 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4766 cxx_binding *binding;
4767 binding = IDENTIFIER_BINDING (name);
4770 if (binding->scope == b
4771 && !(TREE_CODE (binding->value) == VAR_DECL
4772 && DECL_DEAD_FOR_LOCAL (binding->value)))
4773 return binding->value;
4775 if (b->kind == sk_cleanup)
4785 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4788 lookup_name_innermost_nonclass_level (tree name)
4791 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4792 ret = lookup_name_innermost_nonclass_level_1 (name);
4793 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4798 /* Returns true iff DECL is a block-scope extern declaration of a function
4802 is_local_extern (tree decl)
4804 cxx_binding *binding;
4806 /* For functions, this is easy. */
4807 if (TREE_CODE (decl) == FUNCTION_DECL)
4808 return DECL_LOCAL_FUNCTION_P (decl);
4810 if (TREE_CODE (decl) != VAR_DECL)
4812 if (!current_function_decl)
4815 /* For variables, this is not easy. We need to look at the binding stack
4816 for the identifier to see whether the decl we have is a local. */
4817 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4818 binding && binding->scope->kind != sk_namespace;
4819 binding = binding->previous)
4820 if (binding->value == decl)
4821 return LOCAL_BINDING_P (binding);
4826 /* Like lookup_name_innermost_nonclass_level, but for types. */
4829 lookup_type_current_level (tree name)
4833 timevar_start (TV_NAME_LOOKUP);
4834 gcc_assert (current_binding_level->kind != sk_namespace);
4836 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4837 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4839 struct cp_binding_level *b = current_binding_level;
4842 if (purpose_member (name, b->type_shadowed))
4844 t = REAL_IDENTIFIER_TYPE_VALUE (name);
4847 if (b->kind == sk_cleanup)
4854 timevar_stop (TV_NAME_LOOKUP);
4858 /* [basic.lookup.koenig] */
4859 /* A nonzero return value in the functions below indicates an error. */
4865 VEC(tree,gc) *namespaces;
4866 VEC(tree,gc) *classes;
4868 struct pointer_set_t *fn_set;
4871 static bool arg_assoc (struct arg_lookup*, tree);
4872 static bool arg_assoc_args (struct arg_lookup*, tree);
4873 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4874 static bool arg_assoc_type (struct arg_lookup*, tree);
4875 static bool add_function (struct arg_lookup *, tree);
4876 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4877 static bool arg_assoc_class_only (struct arg_lookup *, tree);
4878 static bool arg_assoc_bases (struct arg_lookup *, tree);
4879 static bool arg_assoc_class (struct arg_lookup *, tree);
4880 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4882 /* Add a function to the lookup structure.
4883 Returns true on error. */
4886 add_function (struct arg_lookup *k, tree fn)
4888 if (!is_overloaded_fn (fn))
4889 /* All names except those of (possibly overloaded) functions and
4890 function templates are ignored. */;
4891 else if (k->fn_set && pointer_set_insert (k->fn_set, fn))
4892 /* It's already in the list. */;
4893 else if (!k->functions)
4895 else if (fn == k->functions)
4899 k->functions = build_overload (fn, k->functions);
4900 if (TREE_CODE (k->functions) == OVERLOAD)
4901 OVL_ARG_DEPENDENT (k->functions) = true;
4907 /* Returns true iff CURRENT has declared itself to be an associated
4908 namespace of SCOPE via a strong using-directive (or transitive chain
4909 thereof). Both are namespaces. */
4912 is_associated_namespace (tree current, tree scope)
4914 VEC(tree,gc) *seen = make_tree_vector ();
4915 VEC(tree,gc) *todo = make_tree_vector ();
4921 if (scope == current)
4926 VEC_safe_push (tree, gc, seen, scope);
4927 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4928 if (!vec_member (TREE_PURPOSE (t), seen))
4929 VEC_safe_push (tree, gc, todo, TREE_PURPOSE (t));
4930 if (!VEC_empty (tree, todo))
4932 scope = VEC_last (tree, todo);
4933 VEC_pop (tree, todo);
4942 release_tree_vector (seen);
4943 release_tree_vector (todo);
4948 /* Add functions of a namespace to the lookup structure.
4949 Returns true on error. */
4952 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4956 if (vec_member (scope, k->namespaces))
4958 VEC_safe_push (tree, gc, k->namespaces, scope);
4960 /* Check out our super-users. */
4961 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4962 value = TREE_CHAIN (value))
4963 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4966 /* Also look down into inline namespaces. */
4967 for (value = DECL_NAMESPACE_USING (scope); value;
4968 value = TREE_CHAIN (value))
4969 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4970 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4973 value = namespace_binding (k->name, scope);
4977 for (; value; value = OVL_NEXT (value))
4979 /* We don't want to find arbitrary hidden functions via argument
4980 dependent lookup. We only want to find friends of associated
4981 classes, which we'll do via arg_assoc_class. */
4982 if (hidden_name_p (OVL_CURRENT (value)))
4985 if (add_function (k, OVL_CURRENT (value)))
4992 /* Adds everything associated with a template argument to the lookup
4993 structure. Returns true on error. */
4996 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4998 /* [basic.lookup.koenig]
5000 If T is a template-id, its associated namespaces and classes are
5001 ... the namespaces and classes associated with the types of the
5002 template arguments provided for template type parameters
5003 (excluding template template parameters); the namespaces in which
5004 any template template arguments are defined; and the classes in
5005 which any member templates used as template template arguments
5006 are defined. [Note: non-type template arguments do not
5007 contribute to the set of associated namespaces. ] */
5009 /* Consider first template template arguments. */
5010 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5011 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
5013 else if (TREE_CODE (arg) == TEMPLATE_DECL)
5015 tree ctx = CP_DECL_CONTEXT (arg);
5017 /* It's not a member template. */
5018 if (TREE_CODE (ctx) == NAMESPACE_DECL)
5019 return arg_assoc_namespace (k, ctx);
5020 /* Otherwise, it must be member template. */
5022 return arg_assoc_class_only (k, ctx);
5024 /* It's an argument pack; handle it recursively. */
5025 else if (ARGUMENT_PACK_P (arg))
5027 tree args = ARGUMENT_PACK_ARGS (arg);
5028 int i, len = TREE_VEC_LENGTH (args);
5029 for (i = 0; i < len; ++i)
5030 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
5035 /* It's not a template template argument, but it is a type template
5037 else if (TYPE_P (arg))
5038 return arg_assoc_type (k, arg);
5039 /* It's a non-type template argument. */
5044 /* Adds the class and its friends to the lookup structure.
5045 Returns true on error. */
5048 arg_assoc_class_only (struct arg_lookup *k, tree type)
5050 tree list, friends, context;
5052 /* Backend-built structures, such as __builtin_va_list, aren't
5053 affected by all this. */
5054 if (!CLASS_TYPE_P (type))
5057 context = decl_namespace_context (type);
5058 if (arg_assoc_namespace (k, context))
5061 complete_type (type);
5063 /* Process friends. */
5064 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
5065 list = TREE_CHAIN (list))
5066 if (k->name == FRIEND_NAME (list))
5067 for (friends = FRIEND_DECLS (list); friends;
5068 friends = TREE_CHAIN (friends))
5070 tree fn = TREE_VALUE (friends);
5072 /* Only interested in global functions with potentially hidden
5073 (i.e. unqualified) declarations. */
5074 if (CP_DECL_CONTEXT (fn) != context)
5076 /* Template specializations are never found by name lookup.
5077 (Templates themselves can be found, but not template
5078 specializations.) */
5079 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
5081 if (add_function (k, fn))
5088 /* Adds the class and its bases to the lookup structure.
5089 Returns true on error. */
5092 arg_assoc_bases (struct arg_lookup *k, tree type)
5094 if (arg_assoc_class_only (k, type))
5097 if (TYPE_BINFO (type))
5099 /* Process baseclasses. */
5100 tree binfo, base_binfo;
5103 for (binfo = TYPE_BINFO (type), i = 0;
5104 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5105 if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
5112 /* Adds everything associated with a class argument type to the lookup
5113 structure. Returns true on error.
5115 If T is a class type (including unions), its associated classes are: the
5116 class itself; the class of which it is a member, if any; and its direct
5117 and indirect base classes. Its associated namespaces are the namespaces
5118 of which its associated classes are members. Furthermore, if T is a
5119 class template specialization, its associated namespaces and classes
5120 also include: the namespaces and classes associated with the types of
5121 the template arguments provided for template type parameters (excluding
5122 template template parameters); the namespaces of which any template
5123 template arguments are members; and the classes of which any member
5124 templates used as template template arguments are members. [ Note:
5125 non-type template arguments do not contribute to the set of associated
5126 namespaces. --end note] */
5129 arg_assoc_class (struct arg_lookup *k, tree type)
5134 /* Backend build structures, such as __builtin_va_list, aren't
5135 affected by all this. */
5136 if (!CLASS_TYPE_P (type))
5139 if (vec_member (type, k->classes))
5141 VEC_safe_push (tree, gc, k->classes, type);
5143 if (TYPE_CLASS_SCOPE_P (type)
5144 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5147 if (arg_assoc_bases (k, type))
5150 /* Process template arguments. */
5151 if (CLASSTYPE_TEMPLATE_INFO (type)
5152 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
5154 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
5155 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
5156 if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
5163 /* Adds everything associated with a given type.
5164 Returns 1 on error. */
5167 arg_assoc_type (struct arg_lookup *k, tree type)
5169 /* As we do not get the type of non-type dependent expressions
5170 right, we can end up with such things without a type. */
5174 if (TYPE_PTRMEM_P (type))
5176 /* Pointer to member: associate class type and value type. */
5177 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
5179 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
5181 else switch (TREE_CODE (type))
5191 case FIXED_POINT_TYPE:
5196 if (TYPE_PTRMEMFUNC_P (type))
5197 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
5199 return arg_assoc_class (k, type);
5201 case REFERENCE_TYPE:
5203 return arg_assoc_type (k, TREE_TYPE (type));
5205 if (TYPE_CLASS_SCOPE_P (type)
5206 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5208 return arg_assoc_namespace (k, decl_namespace_context (type));
5210 /* The basetype is referenced in the first arg type, so just
5213 /* Associate the parameter types. */
5214 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
5216 /* Associate the return type. */
5217 return arg_assoc_type (k, TREE_TYPE (type));
5218 case TEMPLATE_TYPE_PARM:
5219 case BOUND_TEMPLATE_TEMPLATE_PARM:
5224 gcc_assert (type == unknown_type_node
5225 || type == init_list_type_node);
5227 case TYPE_PACK_EXPANSION:
5228 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
5236 /* Adds everything associated with arguments. Returns true on error. */
5239 arg_assoc_args (struct arg_lookup *k, tree args)
5241 for (; args; args = TREE_CHAIN (args))
5242 if (arg_assoc (k, TREE_VALUE (args)))
5247 /* Adds everything associated with an argument vector. Returns true
5251 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
5256 FOR_EACH_VEC_ELT (tree, args, ix, arg)
5257 if (arg_assoc (k, arg))
5262 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5265 arg_assoc (struct arg_lookup *k, tree n)
5267 if (n == error_mark_node)
5271 return arg_assoc_type (k, n);
5273 if (! type_unknown_p (n))
5274 return arg_assoc_type (k, TREE_TYPE (n));
5276 if (TREE_CODE (n) == ADDR_EXPR)
5277 n = TREE_OPERAND (n, 0);
5278 if (TREE_CODE (n) == COMPONENT_REF)
5279 n = TREE_OPERAND (n, 1);
5280 if (TREE_CODE (n) == OFFSET_REF)
5281 n = TREE_OPERAND (n, 1);
5282 while (TREE_CODE (n) == TREE_LIST)
5284 if (TREE_CODE (n) == BASELINK)
5285 n = BASELINK_FUNCTIONS (n);
5287 if (TREE_CODE (n) == FUNCTION_DECL)
5288 return arg_assoc_type (k, TREE_TYPE (n));
5289 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
5291 /* The working paper doesn't currently say how to handle template-id
5292 arguments. The sensible thing would seem to be to handle the list
5293 of template candidates like a normal overload set, and handle the
5294 template arguments like we do for class template
5296 tree templ = TREE_OPERAND (n, 0);
5297 tree args = TREE_OPERAND (n, 1);
5300 /* First the templates. */
5301 if (arg_assoc (k, templ))
5304 /* Now the arguments. */
5306 for (ix = TREE_VEC_LENGTH (args); ix--;)
5307 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
5310 else if (TREE_CODE (n) == OVERLOAD)
5312 for (; n; n = OVL_NEXT (n))
5313 if (arg_assoc_type (k, TREE_TYPE (OVL_CURRENT (n))))
5320 /* Performs Koenig lookup depending on arguments, where fns
5321 are the functions found in normal lookup. */
5324 lookup_arg_dependent_1 (tree name, tree fns, VEC(tree,gc) *args,
5327 struct arg_lookup k;
5329 /* Remove any hidden friend functions from the list of functions
5330 found so far. They will be added back by arg_assoc_class as
5332 fns = remove_hidden_names (fns);
5337 k.classes = make_tree_vector ();
5339 /* We previously performed an optimization here by setting
5340 NAMESPACES to the current namespace when it was safe. However, DR
5341 164 says that namespaces that were already searched in the first
5342 stage of template processing are searched again (potentially
5343 picking up later definitions) in the second stage. */
5344 k.namespaces = make_tree_vector ();
5346 /* We used to allow duplicates and let joust discard them, but
5347 since the above change for DR 164 we end up with duplicates of
5348 all the functions found by unqualified lookup. So keep track
5349 of which ones we've seen. */
5353 /* We shouldn't be here if lookup found something other than
5354 namespace-scope functions. */
5355 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns)));
5356 k.fn_set = pointer_set_create ();
5357 for (ovl = fns; ovl; ovl = OVL_NEXT (ovl))
5358 pointer_set_insert (k.fn_set, OVL_CURRENT (ovl));
5364 arg_assoc_namespace (&k, std_node);
5365 arg_assoc_args_vec (&k, args);
5370 && TREE_CODE (fns) != VAR_DECL
5371 && !is_overloaded_fn (fns))
5373 error ("argument dependent lookup finds %q+D", fns);
5374 error (" in call to %qD", name);
5375 fns = error_mark_node;
5378 release_tree_vector (k.classes);
5379 release_tree_vector (k.namespaces);
5381 pointer_set_destroy (k.fn_set);
5386 /* Wrapper for lookup_arg_dependent_1. */
5389 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
5393 timevar_start (TV_NAME_LOOKUP);
5394 ret = lookup_arg_dependent_1 (name, fns, args, include_std);
5395 timevar_stop (TV_NAME_LOOKUP);
5400 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5401 changed (i.e. there was already a directive), or the fresh
5402 TREE_LIST otherwise. */
5405 push_using_directive_1 (tree used)
5407 tree ud = current_binding_level->using_directives;
5408 tree iter, ancestor;
5410 /* Check if we already have this. */
5411 if (purpose_member (used, ud) != NULL_TREE)
5414 ancestor = namespace_ancestor (current_decl_namespace (), used);
5415 ud = current_binding_level->using_directives;
5416 ud = tree_cons (used, ancestor, ud);
5417 current_binding_level->using_directives = ud;
5419 /* Recursively add all namespaces used. */
5420 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5421 push_using_directive (TREE_PURPOSE (iter));
5426 /* Wrapper for push_using_directive_1. */
5429 push_using_directive (tree used)
5432 timevar_start (TV_NAME_LOOKUP);
5433 ret = push_using_directive_1 (used);
5434 timevar_stop (TV_NAME_LOOKUP);
5438 /* The type TYPE is being declared. If it is a class template, or a
5439 specialization of a class template, do any processing required and
5440 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5441 being declared a friend. B is the binding level at which this TYPE
5444 Returns the TYPE_DECL for TYPE, which may have been altered by this
5448 maybe_process_template_type_declaration (tree type, int is_friend,
5451 tree decl = TYPE_NAME (type);
5453 if (processing_template_parmlist)
5454 /* You can't declare a new template type in a template parameter
5455 list. But, you can declare a non-template type:
5457 template <class A*> struct S;
5459 is a forward-declaration of `A'. */
5461 else if (b->kind == sk_namespace
5462 && current_binding_level->kind != sk_namespace)
5463 /* If this new type is being injected into a containing scope,
5464 then it's not a template type. */
5468 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5469 || TREE_CODE (type) == ENUMERAL_TYPE);
5471 if (processing_template_decl)
5473 /* This may change after the call to
5474 push_template_decl_real, but we want the original value. */
5475 tree name = DECL_NAME (decl);
5477 decl = push_template_decl_real (decl, is_friend);
5478 if (decl == error_mark_node)
5479 return error_mark_node;
5481 /* If the current binding level is the binding level for the
5482 template parameters (see the comment in
5483 begin_template_parm_list) and the enclosing level is a class
5484 scope, and we're not looking at a friend, push the
5485 declaration of the member class into the class scope. In the
5486 friend case, push_template_decl will already have put the
5487 friend into global scope, if appropriate. */
5488 if (TREE_CODE (type) != ENUMERAL_TYPE
5489 && !is_friend && b->kind == sk_template_parms
5490 && b->level_chain->kind == sk_class)
5492 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5494 if (!COMPLETE_TYPE_P (current_class_type))
5496 maybe_add_class_template_decl_list (current_class_type,
5497 type, /*friend_p=*/0);
5498 /* Put this UTD in the table of UTDs for the class. */
5499 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5500 CLASSTYPE_NESTED_UTDS (current_class_type) =
5501 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5503 binding_table_insert
5504 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5513 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5514 that the NAME is a class template, the tag is processed but not pushed.
5516 The pushed scope depend on the SCOPE parameter:
5517 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5519 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5520 non-template-parameter scope. This case is needed for forward
5522 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5523 TS_GLOBAL case except that names within template-parameter scopes
5524 are not pushed at all.
5526 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5529 pushtag_1 (tree name, tree type, tag_scope scope)
5531 struct cp_binding_level *b;
5534 b = current_binding_level;
5535 while (/* Cleanup scopes are not scopes from the point of view of
5537 b->kind == sk_cleanup
5538 /* Neither are function parameter scopes. */
5539 || b->kind == sk_function_parms
5540 /* Neither are the scopes used to hold template parameters
5541 for an explicit specialization. For an ordinary template
5542 declaration, these scopes are not scopes from the point of
5543 view of the language. */
5544 || (b->kind == sk_template_parms
5545 && (b->explicit_spec_p || scope == ts_global))
5546 || (b->kind == sk_class
5547 && (scope != ts_current
5548 /* We may be defining a new type in the initializer
5549 of a static member variable. We allow this when
5550 not pedantic, and it is particularly useful for
5551 type punning via an anonymous union. */
5552 || COMPLETE_TYPE_P (b->this_entity))))
5555 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5557 /* Do C++ gratuitous typedefing. */
5558 if (identifier_type_value_1 (name) != type)
5562 tree context = TYPE_CONTEXT (type);
5566 tree cs = current_scope ();
5568 if (scope == ts_current
5569 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5571 else if (cs != NULL_TREE && TYPE_P (cs))
5572 /* When declaring a friend class of a local class, we want
5573 to inject the newly named class into the scope
5574 containing the local class, not the namespace
5576 context = decl_function_context (get_type_decl (cs));
5579 context = current_namespace;
5581 if (b->kind == sk_class
5582 || (b->kind == sk_template_parms
5583 && b->level_chain->kind == sk_class))
5586 if (current_lang_name == lang_name_java)
5587 TYPE_FOR_JAVA (type) = 1;
5589 tdef = create_implicit_typedef (name, type);
5590 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5591 if (scope == ts_within_enclosing_non_class)
5593 /* This is a friend. Make this TYPE_DECL node hidden from
5594 ordinary name lookup. Its corresponding TEMPLATE_DECL
5595 will be marked in push_template_decl_real. */
5596 retrofit_lang_decl (tdef);
5597 DECL_ANTICIPATED (tdef) = 1;
5598 DECL_FRIEND_P (tdef) = 1;
5601 decl = maybe_process_template_type_declaration
5602 (type, scope == ts_within_enclosing_non_class, b);
5603 if (decl == error_mark_node)
5606 if (b->kind == sk_class)
5608 if (!TYPE_BEING_DEFINED (current_class_type))
5609 return error_mark_node;
5611 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5612 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5613 class. But if it's a member template class, we want
5614 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5616 finish_member_declaration (decl);
5618 pushdecl_class_level (decl);
5620 else if (b->kind != sk_template_parms)
5622 decl = pushdecl_with_scope_1 (decl, b, /*is_friend=*/false);
5623 if (decl == error_mark_node)
5628 set_identifier_type_value_with_scope (name, tdef, b);
5630 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5632 /* If this is a local class, keep track of it. We need this
5633 information for name-mangling, and so that it is possible to
5634 find all function definitions in a translation unit in a
5635 convenient way. (It's otherwise tricky to find a member
5636 function definition it's only pointed to from within a local
5638 if (TYPE_CONTEXT (type)
5639 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5640 VEC_safe_push (tree, gc, local_classes, type);
5642 if (b->kind == sk_class
5643 && !COMPLETE_TYPE_P (current_class_type))
5645 maybe_add_class_template_decl_list (current_class_type,
5646 type, /*friend_p=*/0);
5648 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5649 CLASSTYPE_NESTED_UTDS (current_class_type)
5650 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5652 binding_table_insert
5653 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5656 decl = TYPE_NAME (type);
5657 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5659 /* Set type visibility now if this is a forward declaration. */
5660 TREE_PUBLIC (decl) = 1;
5661 determine_visibility (decl);
5666 /* Wrapper for pushtag_1. */
5669 pushtag (tree name, tree type, tag_scope scope)
5672 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5673 ret = pushtag_1 (name, type, scope);
5674 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5678 /* Subroutines for reverting temporarily to top-level for instantiation
5679 of templates and such. We actually need to clear out the class- and
5680 local-value slots of all identifiers, so that only the global values
5681 are at all visible. Simply setting current_binding_level to the global
5682 scope isn't enough, because more binding levels may be pushed. */
5683 struct saved_scope *scope_chain;
5685 /* If ID has not already been marked, add an appropriate binding to
5689 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5691 cxx_saved_binding *saved;
5693 if (!id || !IDENTIFIER_BINDING (id))
5696 if (IDENTIFIER_MARKED (id))
5699 IDENTIFIER_MARKED (id) = 1;
5701 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5702 saved->identifier = id;
5703 saved->binding = IDENTIFIER_BINDING (id);
5704 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5705 IDENTIFIER_BINDING (id) = NULL;
5709 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5713 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5714 for (t = names; t; t = TREE_CHAIN (t))
5718 if (TREE_CODE (t) == TREE_LIST)
5719 id = TREE_PURPOSE (t);
5723 store_binding (id, old_bindings);
5725 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5728 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5729 objects, rather than a TREE_LIST. */
5732 store_class_bindings (VEC(cp_class_binding,gc) *names,
5733 VEC(cxx_saved_binding,gc) **old_bindings)
5736 cp_class_binding *cb;
5738 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5739 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5740 store_binding (cb->identifier, old_bindings);
5741 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5745 push_to_top_level (void)
5747 struct saved_scope *s;
5748 struct cp_binding_level *b;
5749 cxx_saved_binding *sb;
5753 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5754 s = ggc_alloc_cleared_saved_scope ();
5756 b = scope_chain ? current_binding_level : 0;
5758 /* If we're in the middle of some function, save our state. */
5762 push_function_context ();
5767 if (scope_chain && previous_class_level)
5768 store_class_bindings (previous_class_level->class_shadowed,
5771 /* Have to include the global scope, because class-scope decls
5772 aren't listed anywhere useful. */
5773 for (; b; b = b->level_chain)
5777 /* Template IDs are inserted into the global level. If they were
5778 inserted into namespace level, finish_file wouldn't find them
5779 when doing pending instantiations. Therefore, don't stop at
5780 namespace level, but continue until :: . */
5781 if (global_scope_p (b))
5784 store_bindings (b->names, &s->old_bindings);
5785 /* We also need to check class_shadowed to save class-level type
5786 bindings, since pushclass doesn't fill in b->names. */
5787 if (b->kind == sk_class)
5788 store_class_bindings (b->class_shadowed, &s->old_bindings);
5790 /* Unwind type-value slots back to top level. */
5791 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5792 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5795 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, sb)
5796 IDENTIFIER_MARKED (sb->identifier) = 0;
5798 s->prev = scope_chain;
5800 s->need_pop_function_context = need_pop;
5801 s->function_decl = current_function_decl;
5802 s->unevaluated_operand = cp_unevaluated_operand;
5803 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5806 current_function_decl = NULL_TREE;
5807 current_lang_base = VEC_alloc (tree, gc, 10);
5808 current_lang_name = lang_name_cplusplus;
5809 current_namespace = global_namespace;
5810 push_class_stack ();
5811 cp_unevaluated_operand = 0;
5812 c_inhibit_evaluation_warnings = 0;
5813 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5817 pop_from_top_level_1 (void)
5819 struct saved_scope *s = scope_chain;
5820 cxx_saved_binding *saved;
5823 /* Clear out class-level bindings cache. */
5824 if (previous_class_level)
5825 invalidate_class_lookup_cache ();
5828 current_lang_base = 0;
5830 scope_chain = s->prev;
5831 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, saved)
5833 tree id = saved->identifier;
5835 IDENTIFIER_BINDING (id) = saved->binding;
5836 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5839 /* If we were in the middle of compiling a function, restore our
5841 if (s->need_pop_function_context)
5842 pop_function_context ();
5843 current_function_decl = s->function_decl;
5844 cp_unevaluated_operand = s->unevaluated_operand;
5845 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5848 /* Wrapper for pop_from_top_level_1. */
5851 pop_from_top_level (void)
5853 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5854 pop_from_top_level_1 ();
5855 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5859 /* Pop off extraneous binding levels left over due to syntax errors.
5861 We don't pop past namespaces, as they might be valid. */
5864 pop_everything (void)
5866 if (ENABLE_SCOPE_CHECKING)
5867 verbatim ("XXX entering pop_everything ()\n");
5868 while (!toplevel_bindings_p ())
5870 if (current_binding_level->kind == sk_class)
5871 pop_nested_class ();
5875 if (ENABLE_SCOPE_CHECKING)
5876 verbatim ("XXX leaving pop_everything ()\n");
5879 /* Emit debugging information for using declarations and directives.
5880 If input tree is overloaded fn then emit debug info for all
5884 cp_emit_debug_info_for_using (tree t, tree context)
5886 /* Don't try to emit any debug information if we have errors. */
5890 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5891 of a builtin function. */
5892 if (TREE_CODE (t) == FUNCTION_DECL
5893 && DECL_EXTERNAL (t)
5894 && DECL_BUILT_IN (t))
5897 /* Do not supply context to imported_module_or_decl, if
5898 it is a global namespace. */
5899 if (context == global_namespace)
5900 context = NULL_TREE;
5903 t = BASELINK_FUNCTIONS (t);
5905 /* FIXME: Handle TEMPLATE_DECLs. */
5906 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5907 if (TREE_CODE (t) != TEMPLATE_DECL)
5909 if (building_stmt_list_p ())
5910 add_stmt (build_stmt (input_location, USING_STMT, t));
5912 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5916 #include "gt-cp-name-lookup.h"