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 cp_binding_level *innermost_nonclass_level (void);
47 static cxx_binding *binding_for_name (cp_binding_level *, 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 tree lookup_extern_c_fun_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, cp_binding_level *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, cp_binding_level* 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, cp_binding_level *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 tree previous = lookup_extern_c_fun_in_all_ns (x);
773 && !DECL_ARTIFICIAL (previous)
774 && !DECL_IN_SYSTEM_HEADER (previous)
775 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
777 /* In case either x or previous is declared to throw an exception,
778 make sure both exception specifications are equal. */
779 if (decls_match (x, previous))
781 tree x_exception_spec = NULL_TREE;
782 tree previous_exception_spec = NULL_TREE;
785 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
786 previous_exception_spec =
787 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
788 if (!comp_except_specs (previous_exception_spec,
792 pedwarn (input_location, 0,
793 "declaration of %q#D with C language linkage",
795 pedwarn (input_location, 0,
796 "conflicts with previous declaration %q+#D",
798 pedwarn (input_location, 0,
799 "due to different exception specifications");
800 return error_mark_node;
802 if (DECL_ASSEMBLER_NAME_SET_P (previous))
803 SET_DECL_ASSEMBLER_NAME (x,
804 DECL_ASSEMBLER_NAME (previous));
808 pedwarn (input_location, 0,
809 "declaration of %q#D with C language linkage", x);
810 pedwarn (input_location, 0,
811 "conflicts with previous declaration %q+#D",
817 check_template_shadow (x);
819 /* If this is a function conjured up by the back end, massage it
820 so it looks friendly. */
821 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
823 retrofit_lang_decl (x);
824 SET_DECL_LANGUAGE (x, lang_c);
828 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
830 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
831 if (!namespace_bindings_p ())
832 /* We do not need to create a binding for this name;
833 push_overloaded_decl will have already done so if
835 need_new_binding = 0;
837 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
839 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
841 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
844 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
845 check_default_args (t);
847 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
850 /* If declaring a type as a typedef, copy the type (unless we're
851 at line 0), and install this TYPE_DECL as the new type's typedef
852 name. See the extensive comment of set_underlying_type (). */
853 if (TREE_CODE (x) == TYPE_DECL)
855 tree type = TREE_TYPE (x);
857 if (DECL_IS_BUILTIN (x)
858 || (TREE_TYPE (x) != error_mark_node
859 && TYPE_NAME (type) != x
860 /* We don't want to copy the type when all we're
861 doing is making a TYPE_DECL for the purposes of
863 && (!TYPE_NAME (type)
864 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
865 set_underlying_type (x);
867 if (type != error_mark_node
869 && TYPE_IDENTIFIER (type))
870 set_identifier_type_value (DECL_NAME (x), x);
873 /* Multiple external decls of the same identifier ought to match.
875 We get warnings about inline functions where they are defined.
876 We get warnings about other functions from push_overloaded_decl.
878 Avoid duplicate warnings where they are used. */
879 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
883 decl = IDENTIFIER_NAMESPACE_VALUE (name);
884 if (decl && TREE_CODE (decl) == OVERLOAD)
885 decl = OVL_FUNCTION (decl);
887 if (decl && decl != error_mark_node
888 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
889 /* If different sort of thing, we already gave an error. */
890 && TREE_CODE (decl) == TREE_CODE (x)
891 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
893 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
894 permerror (input_location, "previous external decl of %q+#D", decl);
898 if (TREE_CODE (x) == FUNCTION_DECL
900 && !flag_friend_injection)
902 /* This is a new declaration of a friend function, so hide
903 it from ordinary function lookup. */
904 DECL_ANTICIPATED (x) = 1;
905 DECL_HIDDEN_FRIEND_P (x) = 1;
908 /* This name is new in its binding level.
909 Install the new declaration and return it. */
910 if (namespace_bindings_p ())
912 /* Install a global value. */
914 /* If the first global decl has external linkage,
915 warn if we later see static one. */
916 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
917 TREE_PUBLIC (name) = 1;
919 /* Bind the name for the entity. */
920 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
922 && (TREE_CODE (x) == TYPE_DECL
923 || TREE_CODE (x) == VAR_DECL
924 || TREE_CODE (x) == NAMESPACE_DECL
925 || TREE_CODE (x) == CONST_DECL
926 || TREE_CODE (x) == TEMPLATE_DECL))
927 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
929 /* If new decl is `static' and an `extern' was seen previously,
931 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
932 warn_extern_redeclared_static (x, t);
936 /* Here to install a non-global value. */
937 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
938 tree oldlocal = NULL_TREE;
939 cp_binding_level *oldscope = NULL;
940 cxx_binding *oldbinding = outer_binding (name, NULL, true);
943 oldlocal = oldbinding->value;
944 oldscope = oldbinding->scope;
947 if (need_new_binding)
949 push_local_binding (name, x, 0);
950 /* Because push_local_binding will hook X on to the
951 current_binding_level's name list, we don't want to
952 do that again below. */
953 need_new_binding = 0;
956 /* If this is a TYPE_DECL, push it into the type value slot. */
957 if (TREE_CODE (x) == TYPE_DECL)
958 set_identifier_type_value (name, x);
960 /* Clear out any TYPE_DECL shadowed by a namespace so that
961 we won't think this is a type. The C struct hack doesn't
962 go through namespaces. */
963 if (TREE_CODE (x) == NAMESPACE_DECL)
964 set_identifier_type_value (name, NULL_TREE);
971 && TREE_CODE (oldlocal) == VAR_DECL
972 && DECL_DEAD_FOR_LOCAL (oldlocal))
973 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
975 if (oldlocal == NULL_TREE)
976 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
979 /* If this is an extern function declaration, see if we
980 have a global definition or declaration for the function. */
981 if (oldlocal == NULL_TREE
983 && oldglobal != NULL_TREE
984 && TREE_CODE (x) == FUNCTION_DECL
985 && TREE_CODE (oldglobal) == FUNCTION_DECL)
987 /* We have one. Their types must agree. */
988 if (decls_match (x, oldglobal))
992 warning (0, "extern declaration of %q#D doesn%'t match", x);
993 warning (0, "global declaration %q+#D", oldglobal);
996 /* If we have a local external declaration,
997 and no file-scope declaration has yet been seen,
998 then if we later have a file-scope decl it must not be static. */
999 if (oldlocal == NULL_TREE
1000 && oldglobal == NULL_TREE
1001 && DECL_EXTERNAL (x)
1003 TREE_PUBLIC (name) = 1;
1005 /* Don't complain about the parms we push and then pop
1006 while tentatively parsing a function declarator. */
1007 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1010 /* Warn if shadowing an argument at the top level of the body. */
1011 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1012 /* Inline decls shadow nothing. */
1013 && !DECL_FROM_INLINE (x)
1014 && (TREE_CODE (oldlocal) == PARM_DECL
1015 || TREE_CODE (oldlocal) == VAR_DECL
1016 /* If the old decl is a type decl, only warn if the
1017 old decl is an explicit typedef or if both the old
1018 and new decls are type decls. */
1019 || (TREE_CODE (oldlocal) == TYPE_DECL
1020 && (!DECL_ARTIFICIAL (oldlocal)
1021 || TREE_CODE (x) == TYPE_DECL)))
1022 /* Don't check for internally generated vars unless
1023 it's an implicit typedef (see create_implicit_typedef
1025 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1027 bool nowarn = false;
1029 /* Don't complain if it's from an enclosing function. */
1030 if (DECL_CONTEXT (oldlocal) == current_function_decl
1031 && TREE_CODE (x) != PARM_DECL
1032 && TREE_CODE (oldlocal) == PARM_DECL)
1034 /* Go to where the parms should be and see if we find
1036 cp_binding_level *b = current_binding_level->level_chain;
1038 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1039 /* Skip the ctor/dtor cleanup level. */
1043 if (b->kind == sk_function_parms)
1045 error ("declaration of %q#D shadows a parameter", x);
1050 /* The local structure or class can't use parameters of
1051 the containing function anyway. */
1052 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1054 cp_binding_level *scope = current_binding_level;
1055 tree context = DECL_CONTEXT (oldlocal);
1056 for (; scope; scope = scope->level_chain)
1058 if (scope->kind == sk_function_parms
1059 && scope->this_entity == context)
1061 if (scope->kind == sk_class
1062 && !LAMBDA_TYPE_P (scope->this_entity))
1069 /* Error if redeclaring a local declared in a
1070 for-init-statement or in the condition of an if or
1071 switch statement when the new declaration is in the
1072 outermost block of the controlled statement.
1073 Redeclaring a variable from a for or while condition is
1074 detected elsewhere. */
1075 else if (TREE_CODE (oldlocal) == VAR_DECL
1076 && oldscope == current_binding_level->level_chain
1077 && (oldscope->kind == sk_cond
1078 || oldscope->kind == sk_for))
1080 error ("redeclaration of %q#D", x);
1081 error ("%q+#D previously declared here", oldlocal);
1084 if (warn_shadow && !nowarn)
1086 if (TREE_CODE (oldlocal) == PARM_DECL)
1087 warning_at (input_location, OPT_Wshadow,
1088 "declaration of %q#D shadows a parameter", x);
1089 else if (is_capture_proxy (oldlocal))
1090 warning_at (input_location, OPT_Wshadow,
1091 "declaration of %qD shadows a lambda capture",
1094 warning_at (input_location, OPT_Wshadow,
1095 "declaration of %qD shadows a previous local",
1097 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1098 "shadowed declaration is here");
1102 /* Maybe warn if shadowing something else. */
1103 else if (warn_shadow && !DECL_EXTERNAL (x)
1104 /* No shadow warnings for internally generated vars unless
1105 it's an implicit typedef (see create_implicit_typedef
1107 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1108 /* No shadow warnings for vars made for inlining. */
1109 && ! DECL_FROM_INLINE (x))
1113 if (current_class_ptr)
1114 member = lookup_member (current_class_type,
1117 /*want_type=*/false);
1121 if (member && !TREE_STATIC (member))
1123 /* Location of previous decl is not useful in this case. */
1124 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1127 else if (oldglobal != NULL_TREE
1128 && (TREE_CODE (oldglobal) == VAR_DECL
1129 /* If the old decl is a type decl, only warn if the
1130 old decl is an explicit typedef or if both the
1131 old and new decls are type decls. */
1132 || (TREE_CODE (oldglobal) == TYPE_DECL
1133 && (!DECL_ARTIFICIAL (oldglobal)
1134 || TREE_CODE (x) == TYPE_DECL))))
1135 /* XXX shadow warnings in outer-more namespaces */
1137 warning_at (input_location, OPT_Wshadow,
1138 "declaration of %qD shadows a global declaration", x);
1139 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1140 "shadowed declaration is here");
1145 if (TREE_CODE (x) == VAR_DECL)
1146 maybe_register_incomplete_var (x);
1149 if (need_new_binding)
1150 add_decl_to_level (x,
1151 DECL_NAMESPACE_SCOPE_P (x)
1152 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1153 : current_binding_level);
1158 /* Wrapper for pushdecl_maybe_friend_1. */
1161 pushdecl_maybe_friend (tree x, bool is_friend)
1164 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1165 ret = pushdecl_maybe_friend_1 (x, is_friend);
1166 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1170 /* Record a decl-node X as belonging to the current lexical scope. */
1175 return pushdecl_maybe_friend (x, false);
1178 /* Enter DECL into the symbol table, if that's appropriate. Returns
1179 DECL, or a modified version thereof. */
1182 maybe_push_decl (tree decl)
1184 tree type = TREE_TYPE (decl);
1186 /* Add this decl to the current binding level, but not if it comes
1187 from another scope, e.g. a static member variable. TEM may equal
1188 DECL or it may be a previous decl of the same name. */
1189 if (decl == error_mark_node
1190 || (TREE_CODE (decl) != PARM_DECL
1191 && DECL_CONTEXT (decl) != NULL_TREE
1192 /* Definitions of namespace members outside their namespace are
1194 && !DECL_NAMESPACE_SCOPE_P (decl))
1195 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1196 || type == unknown_type_node
1197 /* The declaration of a template specialization does not affect
1198 the functions available for overload resolution, so we do not
1200 || (TREE_CODE (decl) == FUNCTION_DECL
1201 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1204 return pushdecl (decl);
1207 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1208 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1209 doesn't really belong to this binding level, that it got here
1210 through a using-declaration. */
1213 push_local_binding (tree id, tree decl, int flags)
1215 cp_binding_level *b;
1217 /* Skip over any local classes. This makes sense if we call
1218 push_local_binding with a friend decl of a local class. */
1219 b = innermost_nonclass_level ();
1221 if (lookup_name_innermost_nonclass_level (id))
1223 /* Supplement the existing binding. */
1224 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1225 /* It didn't work. Something else must be bound at this
1226 level. Do not add DECL to the list of things to pop
1231 /* Create a new binding. */
1232 push_binding (id, decl, b);
1234 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1235 /* We must put the OVERLOAD into a TREE_LIST since the
1236 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1237 decls that got here through a using-declaration. */
1238 decl = build_tree_list (NULL_TREE, decl);
1240 /* And put DECL on the list of things declared by the current
1242 add_decl_to_level (decl, b);
1245 /* Check to see whether or not DECL is a variable that would have been
1246 in scope under the ARM, but is not in scope under the ANSI/ISO
1247 standard. If so, issue an error message. If name lookup would
1248 work in both cases, but return a different result, this function
1249 returns the result of ANSI/ISO lookup. Otherwise, it returns
1253 check_for_out_of_scope_variable (tree decl)
1257 /* We only care about out of scope variables. */
1258 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1261 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1262 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1263 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1264 && DECL_DEAD_FOR_LOCAL (shadowed))
1265 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1266 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1268 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1271 if (!DECL_ERROR_REPORTED (decl))
1273 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1274 warning (0, " matches this %q+D under ISO standard rules",
1276 warning (0, " matches this %q+D under old rules", decl);
1277 DECL_ERROR_REPORTED (decl) = 1;
1282 /* If we have already complained about this declaration, there's no
1283 need to do it again. */
1284 if (DECL_ERROR_REPORTED (decl))
1287 DECL_ERROR_REPORTED (decl) = 1;
1289 if (TREE_TYPE (decl) == error_mark_node)
1292 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1294 error ("name lookup of %qD changed for ISO %<for%> scoping",
1296 error (" cannot use obsolete binding at %q+D because "
1297 "it has a destructor", decl);
1298 return error_mark_node;
1302 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1304 if (flag_permissive)
1305 permerror (input_location, " using obsolete binding at %q+D", decl);
1311 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1320 /* true means unconditionally make a BLOCK for the next level pushed. */
1322 static bool keep_next_level_flag;
1324 static int binding_depth = 0;
1331 for (i = 0; i < depth * 2; i++)
1335 /* Return a string describing the kind of SCOPE we have. */
1337 cp_binding_level_descriptor (cp_binding_level *scope)
1339 /* The order of this table must match the "scope_kind"
1341 static const char* scope_kind_names[] = {
1347 "function-parameter-scope",
1350 "template-parameter-scope",
1351 "template-explicit-spec-scope"
1353 const scope_kind kind = scope->explicit_spec_p
1354 ? sk_template_spec : scope->kind;
1356 return scope_kind_names[kind];
1359 /* Output a debugging information about SCOPE when performing
1362 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
1364 const char *desc = cp_binding_level_descriptor (scope);
1365 if (scope->this_entity)
1366 verbatim ("%s %s(%E) %p %d\n", action, desc,
1367 scope->this_entity, (void *) scope, line);
1369 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1372 /* Return the estimated initial size of the hashtable of a NAMESPACE
1375 static inline size_t
1376 namespace_scope_ht_size (tree ns)
1378 tree name = DECL_NAME (ns);
1380 return name == std_identifier
1381 ? NAMESPACE_STD_HT_SIZE
1382 : (name == global_scope_name
1383 ? GLOBAL_SCOPE_HT_SIZE
1384 : NAMESPACE_ORDINARY_HT_SIZE);
1387 /* A chain of binding_level structures awaiting reuse. */
1389 static GTY((deletable)) cp_binding_level *free_binding_level;
1391 /* Insert SCOPE as the innermost binding level. */
1394 push_binding_level (cp_binding_level *scope)
1396 /* Add it to the front of currently active scopes stack. */
1397 scope->level_chain = current_binding_level;
1398 current_binding_level = scope;
1399 keep_next_level_flag = false;
1401 if (ENABLE_SCOPE_CHECKING)
1403 scope->binding_depth = binding_depth;
1404 indent (binding_depth);
1405 cp_binding_level_debug (scope, input_line, "push");
1410 /* Create a new KIND scope and make it the top of the active scopes stack.
1411 ENTITY is the scope of the associated C++ entity (namespace, class,
1412 function, C++0x enumeration); it is NULL otherwise. */
1415 begin_scope (scope_kind kind, tree entity)
1417 cp_binding_level *scope;
1419 /* Reuse or create a struct for this binding level. */
1420 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1422 scope = free_binding_level;
1423 memset (scope, 0, sizeof (cp_binding_level));
1424 free_binding_level = scope->level_chain;
1427 scope = ggc_alloc_cleared_cp_binding_level ();
1429 scope->this_entity = entity;
1430 scope->more_cleanups_ok = true;
1437 case sk_template_spec:
1438 scope->explicit_spec_p = true;
1439 kind = sk_template_parms;
1441 case sk_template_parms:
1448 case sk_scoped_enum:
1449 case sk_function_parms:
1451 scope->keep = keep_next_level_flag;
1455 NAMESPACE_LEVEL (entity) = scope;
1456 scope->static_decls =
1457 VEC_alloc (tree, gc,
1458 DECL_NAME (entity) == std_identifier
1459 || DECL_NAME (entity) == global_scope_name
1464 /* Should not happen. */
1470 push_binding_level (scope);
1475 /* We're about to leave current scope. Pop the top of the stack of
1476 currently active scopes. Return the enclosing scope, now active. */
1481 cp_binding_level *scope = current_binding_level;
1483 if (scope->kind == sk_namespace && class_binding_level)
1484 current_binding_level = class_binding_level;
1486 /* We cannot leave a scope, if there are none left. */
1487 if (NAMESPACE_LEVEL (global_namespace))
1488 gcc_assert (!global_scope_p (scope));
1490 if (ENABLE_SCOPE_CHECKING)
1492 indent (--binding_depth);
1493 cp_binding_level_debug (scope, input_line, "leave");
1496 /* Move one nesting level up. */
1497 current_binding_level = scope->level_chain;
1499 /* Namespace-scopes are left most probably temporarily, not
1500 completely; they can be reopened later, e.g. in namespace-extension
1501 or any name binding activity that requires us to resume a
1502 namespace. For classes, we cache some binding levels. For other
1503 scopes, we just make the structure available for reuse. */
1504 if (scope->kind != sk_namespace
1505 && scope->kind != sk_class)
1507 scope->level_chain = free_binding_level;
1508 gcc_assert (!ENABLE_SCOPE_CHECKING
1509 || scope->binding_depth == binding_depth);
1510 free_binding_level = scope;
1513 /* Find the innermost enclosing class scope, and reset
1514 CLASS_BINDING_LEVEL appropriately. */
1515 if (scope->kind == sk_class)
1517 class_binding_level = NULL;
1518 for (scope = current_binding_level; scope; scope = scope->level_chain)
1519 if (scope->kind == sk_class)
1521 class_binding_level = scope;
1526 return current_binding_level;
1530 resume_scope (cp_binding_level* b)
1532 /* Resuming binding levels is meant only for namespaces,
1533 and those cannot nest into classes. */
1534 gcc_assert (!class_binding_level);
1535 /* Also, resuming a non-directly nested namespace is a no-no. */
1536 gcc_assert (b->level_chain == current_binding_level);
1537 current_binding_level = b;
1538 if (ENABLE_SCOPE_CHECKING)
1540 b->binding_depth = binding_depth;
1541 indent (binding_depth);
1542 cp_binding_level_debug (b, input_line, "resume");
1547 /* Return the innermost binding level that is not for a class scope. */
1549 static cp_binding_level *
1550 innermost_nonclass_level (void)
1552 cp_binding_level *b;
1554 b = current_binding_level;
1555 while (b->kind == sk_class)
1561 /* We're defining an object of type TYPE. If it needs a cleanup, but
1562 we're not allowed to add any more objects with cleanups to the current
1563 scope, create a new binding level. */
1566 maybe_push_cleanup_level (tree type)
1568 if (type != error_mark_node
1569 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1570 && current_binding_level->more_cleanups_ok == 0)
1572 begin_scope (sk_cleanup, NULL);
1573 current_binding_level->statement_list = push_stmt_list ();
1577 /* Return true if we are in the global binding level. */
1580 global_bindings_p (void)
1582 return global_scope_p (current_binding_level);
1585 /* True if we are currently in a toplevel binding level. This
1586 means either the global binding level or a namespace in a toplevel
1587 binding level. Since there are no non-toplevel namespace levels,
1588 this really means any namespace or template parameter level. We
1589 also include a class whose context is toplevel. */
1592 toplevel_bindings_p (void)
1594 cp_binding_level *b = innermost_nonclass_level ();
1596 return b->kind == sk_namespace || b->kind == sk_template_parms;
1599 /* True if this is a namespace scope, or if we are defining a class
1600 which is itself at namespace scope, or whose enclosing class is
1601 such a class, etc. */
1604 namespace_bindings_p (void)
1606 cp_binding_level *b = innermost_nonclass_level ();
1608 return b->kind == sk_namespace;
1611 /* True if the innermost non-class scope is a block scope. */
1614 local_bindings_p (void)
1616 cp_binding_level *b = innermost_nonclass_level ();
1617 return b->kind < sk_function_parms || b->kind == sk_omp;
1620 /* True if the current level needs to have a BLOCK made. */
1625 return (current_binding_level->blocks != NULL_TREE
1626 || current_binding_level->keep
1627 || current_binding_level->kind == sk_cleanup
1628 || current_binding_level->names != NULL_TREE
1629 || current_binding_level->using_directives);
1632 /* Returns the kind of the innermost scope. */
1635 innermost_scope_kind (void)
1637 return current_binding_level->kind;
1640 /* Returns true if this scope was created to store template parameters. */
1643 template_parm_scope_p (void)
1645 return innermost_scope_kind () == sk_template_parms;
1648 /* If KEEP is true, make a BLOCK node for the next binding level,
1649 unconditionally. Otherwise, use the normal logic to decide whether
1650 or not to create a BLOCK. */
1653 keep_next_level (bool keep)
1655 keep_next_level_flag = keep;
1658 /* Return the list of declarations of the current level.
1659 Note that this list is in reverse order unless/until
1660 you nreverse it; and when you do nreverse it, you must
1661 store the result back using `storedecls' or you will lose. */
1666 return current_binding_level->names;
1669 /* Return how many function prototypes we are currently nested inside. */
1672 function_parm_depth (void)
1675 cp_binding_level *b;
1677 for (b = current_binding_level;
1678 b->kind == sk_function_parms;
1685 /* For debugging. */
1686 static int no_print_functions = 0;
1687 static int no_print_builtins = 0;
1690 print_binding_level (cp_binding_level* lvl)
1694 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1695 if (lvl->more_cleanups_ok)
1696 fprintf (stderr, " more-cleanups-ok");
1697 if (lvl->have_cleanups)
1698 fprintf (stderr, " have-cleanups");
1699 fprintf (stderr, "\n");
1702 fprintf (stderr, " names:\t");
1703 /* We can probably fit 3 names to a line? */
1704 for (t = lvl->names; t; t = TREE_CHAIN (t))
1706 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1708 if (no_print_builtins
1709 && (TREE_CODE (t) == TYPE_DECL)
1710 && DECL_IS_BUILTIN (t))
1713 /* Function decls tend to have longer names. */
1714 if (TREE_CODE (t) == FUNCTION_DECL)
1721 fprintf (stderr, "\n\t");
1724 print_node_brief (stderr, "", t, 0);
1725 if (t == error_mark_node)
1729 fprintf (stderr, "\n");
1731 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1734 cp_class_binding *b;
1735 fprintf (stderr, " class-shadowed:");
1736 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1737 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1738 fprintf (stderr, "\n");
1740 if (lvl->type_shadowed)
1742 fprintf (stderr, " type-shadowed:");
1743 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1745 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1747 fprintf (stderr, "\n");
1752 print_other_binding_stack (cp_binding_level *stack)
1754 cp_binding_level *level;
1755 for (level = stack; !global_scope_p (level); level = level->level_chain)
1757 fprintf (stderr, "binding level %p\n", (void *) level);
1758 print_binding_level (level);
1763 print_binding_stack (void)
1765 cp_binding_level *b;
1766 fprintf (stderr, "current_binding_level=%p\n"
1767 "class_binding_level=%p\n"
1768 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1769 (void *) current_binding_level, (void *) class_binding_level,
1770 (void *) NAMESPACE_LEVEL (global_namespace));
1771 if (class_binding_level)
1773 for (b = class_binding_level; b; b = b->level_chain)
1774 if (b == current_binding_level)
1777 b = class_binding_level;
1779 b = current_binding_level;
1782 b = current_binding_level;
1783 print_other_binding_stack (b);
1784 fprintf (stderr, "global:\n");
1785 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1788 /* Return the type associated with ID. */
1791 identifier_type_value_1 (tree id)
1793 /* There is no type with that name, anywhere. */
1794 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1796 /* This is not the type marker, but the real thing. */
1797 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1798 return REAL_IDENTIFIER_TYPE_VALUE (id);
1799 /* Have to search for it. It must be on the global level, now.
1800 Ask lookup_name not to return non-types. */
1801 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1803 return TREE_TYPE (id);
1807 /* Wrapper for identifier_type_value_1. */
1810 identifier_type_value (tree id)
1813 timevar_start (TV_NAME_LOOKUP);
1814 ret = identifier_type_value_1 (id);
1815 timevar_stop (TV_NAME_LOOKUP);
1820 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1821 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1824 identifier_global_value (tree t)
1826 return IDENTIFIER_GLOBAL_VALUE (t);
1829 /* Push a definition of struct, union or enum tag named ID. into
1830 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1831 the tag ID is not already defined. */
1834 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
1838 if (b->kind != sk_namespace)
1840 /* Shadow the marker, not the real thing, so that the marker
1841 gets restored later. */
1842 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1844 = tree_cons (id, old_type_value, b->type_shadowed);
1845 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1846 TREE_TYPE (b->type_shadowed) = type;
1850 cxx_binding *binding =
1851 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1854 supplement_binding (binding, decl);
1856 binding->value = decl;
1858 /* Store marker instead of real type. */
1859 type = global_type_node;
1861 SET_IDENTIFIER_TYPE_VALUE (id, type);
1864 /* As set_identifier_type_value_with_scope, but using
1865 current_binding_level. */
1868 set_identifier_type_value (tree id, tree decl)
1870 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1873 /* Return the name for the constructor (or destructor) for the
1874 specified class TYPE. When given a template, this routine doesn't
1875 lose the specialization. */
1878 constructor_name_full (tree type)
1880 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1883 /* Return the name for the constructor (or destructor) for the
1884 specified class. When given a template, return the plain
1885 unspecialized name. */
1888 constructor_name (tree type)
1891 name = constructor_name_full (type);
1892 if (IDENTIFIER_TEMPLATE (name))
1893 name = IDENTIFIER_TEMPLATE (name);
1897 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1898 which must be a class type. */
1901 constructor_name_p (tree name, tree type)
1905 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1910 if (TREE_CODE (name) != IDENTIFIER_NODE)
1913 ctor_name = constructor_name_full (type);
1914 if (name == ctor_name)
1916 if (IDENTIFIER_TEMPLATE (ctor_name)
1917 && name == IDENTIFIER_TEMPLATE (ctor_name))
1922 /* Counter used to create anonymous type names. */
1924 static GTY(()) int anon_cnt;
1926 /* Return an IDENTIFIER which can be used as a name for
1927 anonymous structs and unions. */
1930 make_anon_name (void)
1934 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1935 return get_identifier (buf);
1938 /* This code is practically identical to that for creating
1939 anonymous names, but is just used for lambdas instead. This is necessary
1940 because anonymous names are recognized and cannot be passed to template
1942 /* FIXME is this still necessary? */
1944 static GTY(()) int lambda_cnt = 0;
1947 make_lambda_name (void)
1951 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1952 return get_identifier (buf);
1955 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1957 static inline cxx_binding *
1958 find_binding (cp_binding_level *scope, cxx_binding *binding)
1960 for (; binding != NULL; binding = binding->previous)
1961 if (binding->scope == scope)
1964 return (cxx_binding *)0;
1967 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1969 static inline cxx_binding *
1970 cp_binding_level_find_binding_for_name (cp_binding_level *scope, tree name)
1972 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1975 /* Fold-in case where NAME is used only once. */
1976 if (scope == b->scope && b->previous == NULL)
1978 return find_binding (scope, b);
1983 /* Always returns a binding for name in scope. If no binding is
1984 found, make a new one. */
1986 static cxx_binding *
1987 binding_for_name (cp_binding_level *scope, tree name)
1989 cxx_binding *result;
1991 result = cp_binding_level_find_binding_for_name (scope, name);
1994 /* Not found, make a new one. */
1995 result = cxx_binding_make (NULL, NULL);
1996 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1997 result->scope = scope;
1998 result->is_local = false;
1999 result->value_is_inherited = false;
2000 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2004 /* Walk through the bindings associated to the name of FUNCTION,
2005 and return the first declaration of a function with a
2006 "C" linkage specification, a.k.a 'extern "C"'.
2007 This function looks for the binding, regardless of which scope it
2008 has been defined in. It basically looks in all the known scopes.
2009 Note that this function does not lookup for bindings of builtin functions
2010 or for functions declared in system headers. */
2012 lookup_extern_c_fun_in_all_ns (tree function)
2017 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2019 name = DECL_NAME (function);
2020 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2022 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2024 iter = iter->previous)
2027 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2029 tree decl = OVL_CURRENT (ovl);
2031 && TREE_CODE (decl) == FUNCTION_DECL
2032 && DECL_EXTERN_C_P (decl)
2033 && !DECL_ARTIFICIAL (decl))
2042 /* Returns a list of C-linkage decls with the name NAME. */
2045 c_linkage_bindings (tree name)
2047 tree decls = NULL_TREE;
2050 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2052 iter = iter->previous)
2055 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2057 tree decl = OVL_CURRENT (ovl);
2059 && DECL_EXTERN_C_P (decl)
2060 && !DECL_ARTIFICIAL (decl))
2062 if (decls == NULL_TREE)
2065 decls = tree_cons (NULL_TREE, decl, decls);
2072 /* Insert another USING_DECL into the current binding level, returning
2073 this declaration. If this is a redeclaration, do nothing, and
2074 return NULL_TREE if this not in namespace scope (in namespace
2075 scope, a using decl might extend any previous bindings). */
2078 push_using_decl_1 (tree scope, tree name)
2082 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2083 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2084 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2085 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2088 return namespace_bindings_p () ? decl : NULL_TREE;
2089 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2090 USING_DECL_SCOPE (decl) = scope;
2091 DECL_CHAIN (decl) = current_binding_level->usings;
2092 current_binding_level->usings = decl;
2096 /* Wrapper for push_using_decl_1. */
2099 push_using_decl (tree scope, tree name)
2102 timevar_start (TV_NAME_LOOKUP);
2103 ret = push_using_decl_1 (scope, name);
2104 timevar_stop (TV_NAME_LOOKUP);
2108 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2109 caller to set DECL_CONTEXT properly.
2111 Note that this must only be used when X will be the new innermost
2112 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2113 without checking to see if the current IDENTIFIER_BINDING comes from a
2114 closer binding level than LEVEL. */
2117 pushdecl_with_scope_1 (tree x, cp_binding_level *level, bool is_friend)
2119 cp_binding_level *b;
2120 tree function_decl = current_function_decl;
2122 current_function_decl = NULL_TREE;
2123 if (level->kind == sk_class)
2125 b = class_binding_level;
2126 class_binding_level = level;
2127 pushdecl_class_level (x);
2128 class_binding_level = b;
2132 b = current_binding_level;
2133 current_binding_level = level;
2134 x = pushdecl_maybe_friend (x, is_friend);
2135 current_binding_level = b;
2137 current_function_decl = function_decl;
2141 /* Wrapper for pushdecl_with_scope_1. */
2144 pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
2147 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2148 ret = pushdecl_with_scope_1 (x, level, is_friend);
2149 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2154 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2155 other definitions already in place. We get around this by making
2156 the value of the identifier point to a list of all the things that
2157 want to be referenced by that name. It is then up to the users of
2158 that name to decide what to do with that list.
2160 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2161 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2163 FLAGS is a bitwise-or of the following values:
2164 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2166 PUSH_USING: DECL is being pushed as the result of a using
2169 IS_FRIEND is true if this is a friend declaration.
2171 The value returned may be a previous declaration if we guessed wrong
2172 about what language DECL should belong to (C or C++). Otherwise,
2173 it's always DECL (and never something that's not a _DECL). */
2176 push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2178 tree name = DECL_NAME (decl);
2181 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2184 old = namespace_binding (name, DECL_CONTEXT (decl));
2186 old = lookup_name_innermost_nonclass_level (name);
2190 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2192 tree t = TREE_TYPE (old);
2193 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2194 && (! DECL_IN_SYSTEM_HEADER (decl)
2195 || ! DECL_IN_SYSTEM_HEADER (old)))
2196 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2199 else if (is_overloaded_fn (old))
2203 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2205 tree fn = OVL_CURRENT (tmp);
2208 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2209 && !(flags & PUSH_USING)
2210 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2211 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2212 && ! decls_match (fn, decl))
2213 error ("%q#D conflicts with previous using declaration %q#D",
2216 dup = duplicate_decls (decl, fn, is_friend);
2217 /* If DECL was a redeclaration of FN -- even an invalid
2218 one -- pass that information along to our caller. */
2219 if (dup == fn || dup == error_mark_node)
2223 /* We don't overload implicit built-ins. duplicate_decls()
2224 may fail to merge the decls if the new decl is e.g. a
2225 template function. */
2226 if (TREE_CODE (old) == FUNCTION_DECL
2227 && DECL_ANTICIPATED (old)
2228 && !DECL_HIDDEN_FRIEND_P (old))
2231 else if (old == error_mark_node)
2232 /* Ignore the undefined symbol marker. */
2236 error ("previous non-function declaration %q+#D", old);
2237 error ("conflicts with function declaration %q#D", decl);
2242 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2243 /* If it's a using declaration, we always need to build an OVERLOAD,
2244 because it's the only way to remember that the declaration comes
2245 from 'using', and have the lookup behave correctly. */
2246 || (flags & PUSH_USING))
2248 if (old && TREE_CODE (old) != OVERLOAD)
2249 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2251 new_binding = ovl_cons (decl, old);
2252 if (flags & PUSH_USING)
2253 OVL_USED (new_binding) = 1;
2256 /* NAME is not ambiguous. */
2260 set_namespace_binding (name, current_namespace, new_binding);
2263 /* We only create an OVERLOAD if there was a previous binding at
2264 this level, or if decl is a template. In the former case, we
2265 need to remove the old binding and replace it with the new
2266 binding. We must also run through the NAMES on the binding
2267 level where the name was bound to update the chain. */
2269 if (TREE_CODE (new_binding) == OVERLOAD && old)
2273 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2275 d = &TREE_CHAIN (*d))
2277 || (TREE_CODE (*d) == TREE_LIST
2278 && TREE_VALUE (*d) == old))
2280 if (TREE_CODE (*d) == TREE_LIST)
2281 /* Just replace the old binding with the new. */
2282 TREE_VALUE (*d) = new_binding;
2284 /* Build a TREE_LIST to wrap the OVERLOAD. */
2285 *d = tree_cons (NULL_TREE, new_binding,
2288 /* And update the cxx_binding node. */
2289 IDENTIFIER_BINDING (name)->value = new_binding;
2293 /* We should always find a previous binding in this case. */
2297 /* Install the new binding. */
2298 push_local_binding (name, new_binding, flags);
2304 /* Wrapper for push_overloaded_decl_1. */
2307 push_overloaded_decl (tree decl, int flags, bool is_friend)
2310 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2311 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2312 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2316 /* Check a non-member using-declaration. Return the name and scope
2317 being used, and the USING_DECL, or NULL_TREE on failure. */
2320 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2322 /* [namespace.udecl]
2323 A using-declaration for a class member shall be a
2324 member-declaration. */
2327 error ("%qT is not a namespace", scope);
2330 else if (scope == error_mark_node)
2333 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2336 A using-declaration shall not name a template-id. */
2337 error ("a using-declaration cannot specify a template-id. "
2338 "Try %<using %D%>", name);
2342 if (TREE_CODE (decl) == NAMESPACE_DECL)
2344 error ("namespace %qD not allowed in using-declaration", decl);
2348 if (TREE_CODE (decl) == SCOPE_REF)
2350 /* It's a nested name with template parameter dependent scope.
2351 This can only be using-declaration for class member. */
2352 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2356 if (is_overloaded_fn (decl))
2357 decl = get_first_fn (decl);
2359 gcc_assert (DECL_P (decl));
2361 /* Make a USING_DECL. */
2362 return push_using_decl (scope, name);
2365 /* Process local and global using-declarations. */
2368 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2369 tree *newval, tree *newtype)
2371 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2373 *newval = *newtype = NULL_TREE;
2374 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2378 if (!decls.value && !decls.type)
2380 error ("%qD not declared", name);
2384 /* Shift the old and new bindings around so we're comparing class and
2385 enumeration names to each other. */
2386 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2392 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2394 decls.type = decls.value;
2395 decls.value = NULL_TREE;
2398 /* It is impossible to overload a built-in function; any explicit
2399 declaration eliminates the built-in declaration. So, if OLDVAL
2400 is a built-in, then we can just pretend it isn't there. */
2402 && TREE_CODE (oldval) == FUNCTION_DECL
2403 && DECL_ANTICIPATED (oldval)
2404 && !DECL_HIDDEN_FRIEND_P (oldval))
2409 /* Check for using functions. */
2410 if (is_overloaded_fn (decls.value))
2414 if (oldval && !is_overloaded_fn (oldval))
2416 error ("%qD is already declared in this scope", name);
2421 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2423 tree new_fn = OVL_CURRENT (tmp);
2425 /* [namespace.udecl]
2427 If a function declaration in namespace scope or block
2428 scope has the same name and the same parameter types as a
2429 function introduced by a using declaration the program is
2431 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2433 tree old_fn = OVL_CURRENT (tmp1);
2435 if (new_fn == old_fn)
2436 /* The function already exists in the current namespace. */
2438 else if (OVL_USED (tmp1))
2439 continue; /* this is a using decl */
2440 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2441 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2443 gcc_assert (!DECL_ANTICIPATED (old_fn)
2444 || DECL_HIDDEN_FRIEND_P (old_fn));
2446 /* There was already a non-using declaration in
2447 this scope with the same parameter types. If both
2448 are the same extern "C" functions, that's ok. */
2449 if (decls_match (new_fn, old_fn))
2453 error ("%qD is already declared in this scope", name);
2459 /* If we broke out of the loop, there's no reason to add
2460 this function to the using declarations for this
2465 /* If we are adding to an existing OVERLOAD, then we no
2466 longer know the type of the set of functions. */
2467 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2468 TREE_TYPE (*newval) = unknown_type_node;
2469 /* Add this new function to the set. */
2470 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2471 /* If there is only one function, then we use its type. (A
2472 using-declaration naming a single function can be used in
2473 contexts where overload resolution cannot be
2475 if (TREE_CODE (*newval) != OVERLOAD)
2477 *newval = ovl_cons (*newval, NULL_TREE);
2478 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2480 OVL_USED (*newval) = 1;
2485 *newval = decls.value;
2486 if (oldval && !decls_match (*newval, oldval))
2487 error ("%qD is already declared in this scope", name);
2493 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2495 error ("reference to %qD is ambiguous", name);
2496 print_candidates (decls.type);
2500 *newtype = decls.type;
2501 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2502 error ("%qD is already declared in this scope", name);
2505 /* If *newval is empty, shift any class or enumeration name down. */
2509 *newtype = NULL_TREE;
2513 /* Process a using-declaration at function scope. */
2516 do_local_using_decl (tree decl, tree scope, tree name)
2518 tree oldval, oldtype, newval, newtype;
2519 tree orig_decl = decl;
2521 decl = validate_nonmember_using_decl (decl, scope, name);
2522 if (decl == NULL_TREE)
2525 if (building_stmt_list_p ()
2526 && at_function_scope_p ())
2527 add_decl_expr (decl);
2529 oldval = lookup_name_innermost_nonclass_level (name);
2530 oldtype = lookup_type_current_level (name);
2532 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2536 if (is_overloaded_fn (newval))
2540 /* We only need to push declarations for those functions
2541 that were not already bound in the current level.
2542 The old value might be NULL_TREE, it might be a single
2543 function, or an OVERLOAD. */
2544 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2545 term = OVL_FUNCTION (oldval);
2548 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2550 push_overloaded_decl (OVL_CURRENT (fn),
2551 PUSH_LOCAL | PUSH_USING,
2555 push_local_binding (name, newval, PUSH_USING);
2559 push_local_binding (name, newtype, PUSH_USING);
2560 set_identifier_type_value (name, newtype);
2563 /* Emit debug info. */
2564 if (!processing_template_decl)
2565 cp_emit_debug_info_for_using (orig_decl, current_scope());
2568 /* Returns true if ROOT (a namespace, class, or function) encloses
2569 CHILD. CHILD may be either a class type or a namespace. */
2572 is_ancestor (tree root, tree child)
2574 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2575 || TREE_CODE (root) == FUNCTION_DECL
2576 || CLASS_TYPE_P (root)));
2577 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2578 || CLASS_TYPE_P (child)));
2580 /* The global namespace encloses everything. */
2581 if (root == global_namespace)
2586 /* If we've run out of scopes, stop. */
2589 /* If we've reached the ROOT, it encloses CHILD. */
2592 /* Go out one level. */
2594 child = TYPE_NAME (child);
2595 child = DECL_CONTEXT (child);
2599 /* Enter the class or namespace scope indicated by T suitable for name
2600 lookup. T can be arbitrary scope, not necessary nested inside the
2601 current scope. Returns a non-null scope to pop iff pop_scope
2602 should be called later to exit this scope. */
2607 if (TREE_CODE (t) == NAMESPACE_DECL)
2608 push_decl_namespace (t);
2609 else if (CLASS_TYPE_P (t))
2611 if (!at_class_scope_p ()
2612 || !same_type_p (current_class_type, t))
2613 push_nested_class (t);
2615 /* T is the same as the current scope. There is therefore no
2616 need to re-enter the scope. Since we are not actually
2617 pushing a new scope, our caller should not call
2625 /* Leave scope pushed by push_scope. */
2632 if (TREE_CODE (t) == NAMESPACE_DECL)
2633 pop_decl_namespace ();
2634 else if CLASS_TYPE_P (t)
2635 pop_nested_class ();
2638 /* Subroutine of push_inner_scope. */
2641 push_inner_scope_r (tree outer, tree inner)
2646 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2649 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2651 push_inner_scope_r (outer, prev);
2652 if (TREE_CODE (inner) == NAMESPACE_DECL)
2654 cp_binding_level *save_template_parm = 0;
2655 /* Temporary take out template parameter scopes. They are saved
2656 in reversed order in save_template_parm. */
2657 while (current_binding_level->kind == sk_template_parms)
2659 cp_binding_level *b = current_binding_level;
2660 current_binding_level = b->level_chain;
2661 b->level_chain = save_template_parm;
2662 save_template_parm = b;
2665 resume_scope (NAMESPACE_LEVEL (inner));
2666 current_namespace = inner;
2668 /* Restore template parameter scopes. */
2669 while (save_template_parm)
2671 cp_binding_level *b = save_template_parm;
2672 save_template_parm = b->level_chain;
2673 b->level_chain = current_binding_level;
2674 current_binding_level = b;
2681 /* Enter the scope INNER from current scope. INNER must be a scope
2682 nested inside current scope. This works with both name lookup and
2683 pushing name into scope. In case a template parameter scope is present,
2684 namespace is pushed under the template parameter scope according to
2685 name lookup rule in 14.6.1/6.
2687 Return the former current scope suitable for pop_inner_scope. */
2690 push_inner_scope (tree inner)
2692 tree outer = current_scope ();
2694 outer = current_namespace;
2696 push_inner_scope_r (outer, inner);
2700 /* Exit the current scope INNER back to scope OUTER. */
2703 pop_inner_scope (tree outer, tree inner)
2706 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2709 while (outer != inner)
2711 if (TREE_CODE (inner) == NAMESPACE_DECL)
2713 cp_binding_level *save_template_parm = 0;
2714 /* Temporary take out template parameter scopes. They are saved
2715 in reversed order in save_template_parm. */
2716 while (current_binding_level->kind == sk_template_parms)
2718 cp_binding_level *b = current_binding_level;
2719 current_binding_level = b->level_chain;
2720 b->level_chain = save_template_parm;
2721 save_template_parm = b;
2726 /* Restore template parameter scopes. */
2727 while (save_template_parm)
2729 cp_binding_level *b = save_template_parm;
2730 save_template_parm = b->level_chain;
2731 b->level_chain = current_binding_level;
2732 current_binding_level = b;
2738 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2742 /* Do a pushlevel for class declarations. */
2745 pushlevel_class (void)
2747 class_binding_level = begin_scope (sk_class, current_class_type);
2750 /* ...and a poplevel for class declarations. */
2753 poplevel_class (void)
2755 cp_binding_level *level = class_binding_level;
2756 cp_class_binding *cb;
2760 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2761 gcc_assert (level != 0);
2763 /* If we're leaving a toplevel class, cache its binding level. */
2764 if (current_class_depth == 1)
2765 previous_class_level = level;
2766 for (shadowed = level->type_shadowed;
2768 shadowed = TREE_CHAIN (shadowed))
2769 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2771 /* Remove the bindings for all of the class-level declarations. */
2772 if (level->class_shadowed)
2774 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2776 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2777 cxx_binding_free (cb->base);
2779 ggc_free (level->class_shadowed);
2780 level->class_shadowed = NULL;
2783 /* Now, pop out of the binding level which we created up in the
2784 `pushlevel_class' routine. */
2785 gcc_assert (current_binding_level == level);
2787 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2790 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2791 appropriate. DECL is the value to which a name has just been
2792 bound. CLASS_TYPE is the class in which the lookup occurred. */
2795 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2798 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2802 if (TREE_CODE (decl) == OVERLOAD)
2803 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2806 gcc_assert (DECL_P (decl));
2807 context = context_for_name_lookup (decl);
2810 if (is_properly_derived_from (class_type, context))
2811 INHERITED_VALUE_BINDING_P (binding) = 1;
2813 INHERITED_VALUE_BINDING_P (binding) = 0;
2815 else if (binding->value == decl)
2816 /* We only encounter a TREE_LIST when there is an ambiguity in the
2817 base classes. Such an ambiguity can be overridden by a
2818 definition in this class. */
2819 INHERITED_VALUE_BINDING_P (binding) = 1;
2821 INHERITED_VALUE_BINDING_P (binding) = 0;
2824 /* Make the declaration of X appear in CLASS scope. */
2827 pushdecl_class_level (tree x)
2830 bool is_valid = true;
2833 /* Do nothing if we're adding to an outer lambda closure type,
2834 outer_binding will add it later if it's needed. */
2835 if (current_class_type != class_binding_level->this_entity)
2838 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2839 /* Get the name of X. */
2840 if (TREE_CODE (x) == OVERLOAD)
2841 name = DECL_NAME (get_first_fn (x));
2843 name = DECL_NAME (x);
2847 is_valid = push_class_level_binding (name, x);
2848 if (TREE_CODE (x) == TYPE_DECL)
2849 set_identifier_type_value (name, x);
2851 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2853 /* If X is an anonymous aggregate, all of its members are
2854 treated as if they were members of the class containing the
2855 aggregate, for naming purposes. */
2858 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2860 location_t save_location = input_location;
2861 input_location = DECL_SOURCE_LOCATION (f);
2862 if (!pushdecl_class_level (f))
2864 input_location = save_location;
2867 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2871 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2872 scope. If the value returned is non-NULL, and the PREVIOUS field
2873 is not set, callers must set the PREVIOUS field explicitly. */
2875 static cxx_binding *
2876 get_class_binding (tree name, cp_binding_level *scope)
2881 cxx_binding *binding;
2883 class_type = scope->this_entity;
2885 /* Get the type binding. */
2886 type_binding = lookup_member (class_type, name,
2887 /*protect=*/2, /*want_type=*/true);
2888 /* Get the value binding. */
2889 value_binding = lookup_member (class_type, name,
2890 /*protect=*/2, /*want_type=*/false);
2893 && (TREE_CODE (value_binding) == TYPE_DECL
2894 || DECL_CLASS_TEMPLATE_P (value_binding)
2895 || (TREE_CODE (value_binding) == TREE_LIST
2896 && TREE_TYPE (value_binding) == error_mark_node
2897 && (TREE_CODE (TREE_VALUE (value_binding))
2899 /* We found a type binding, even when looking for a non-type
2900 binding. This means that we already processed this binding
2903 else if (value_binding)
2905 if (TREE_CODE (value_binding) == TREE_LIST
2906 && TREE_TYPE (value_binding) == error_mark_node)
2907 /* NAME is ambiguous. */
2909 else if (BASELINK_P (value_binding))
2910 /* NAME is some overloaded functions. */
2911 value_binding = BASELINK_FUNCTIONS (value_binding);
2914 /* If we found either a type binding or a value binding, create a
2915 new binding object. */
2916 if (type_binding || value_binding)
2918 binding = new_class_binding (name,
2922 /* This is a class-scope binding, not a block-scope binding. */
2923 LOCAL_BINDING_P (binding) = 0;
2924 set_inherited_value_binding_p (binding, value_binding, class_type);
2932 /* Make the declaration(s) of X appear in CLASS scope under the name
2933 NAME. Returns true if the binding is valid. */
2936 push_class_level_binding_1 (tree name, tree x)
2938 cxx_binding *binding;
2942 /* The class_binding_level will be NULL if x is a template
2943 parameter name in a member template. */
2944 if (!class_binding_level)
2947 if (name == error_mark_node)
2950 /* Check for invalid member names. */
2951 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2952 /* Check that we're pushing into the right binding level. */
2953 gcc_assert (current_class_type == class_binding_level->this_entity);
2955 /* We could have been passed a tree list if this is an ambiguous
2956 declaration. If so, pull the declaration out because
2957 check_template_shadow will not handle a TREE_LIST. */
2958 if (TREE_CODE (decl) == TREE_LIST
2959 && TREE_TYPE (decl) == error_mark_node)
2960 decl = TREE_VALUE (decl);
2962 if (!check_template_shadow (decl))
2967 If T is the name of a class, then each of the following shall
2968 have a name different from T:
2970 -- every static data member of class T;
2972 -- every member of class T that is itself a type;
2974 -- every enumerator of every member of class T that is an
2977 -- every member of every anonymous union that is a member of
2980 (Non-static data members were also forbidden to have the same
2981 name as T until TC1.) */
2982 if ((TREE_CODE (x) == VAR_DECL
2983 || TREE_CODE (x) == CONST_DECL
2984 || (TREE_CODE (x) == TYPE_DECL
2985 && !DECL_SELF_REFERENCE_P (x))
2986 /* A data member of an anonymous union. */
2987 || (TREE_CODE (x) == FIELD_DECL
2988 && DECL_CONTEXT (x) != current_class_type))
2989 && DECL_NAME (x) == constructor_name (current_class_type))
2991 tree scope = context_for_name_lookup (x);
2992 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2994 error ("%qD has the same name as the class in which it is "
3001 /* Get the current binding for NAME in this class, if any. */
3002 binding = IDENTIFIER_BINDING (name);
3003 if (!binding || binding->scope != class_binding_level)
3005 binding = get_class_binding (name, class_binding_level);
3006 /* If a new binding was created, put it at the front of the
3007 IDENTIFIER_BINDING list. */
3010 binding->previous = IDENTIFIER_BINDING (name);
3011 IDENTIFIER_BINDING (name) = binding;
3015 /* If there is already a binding, then we may need to update the
3017 if (binding && binding->value)
3019 tree bval = binding->value;
3020 tree old_decl = NULL_TREE;
3022 if (INHERITED_VALUE_BINDING_P (binding))
3024 /* If the old binding was from a base class, and was for a
3025 tag name, slide it over to make room for the new binding.
3026 The old binding is still visible if explicitly qualified
3027 with a class-key. */
3028 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
3029 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
3031 old_decl = binding->type;
3032 binding->type = bval;
3033 binding->value = NULL_TREE;
3034 INHERITED_VALUE_BINDING_P (binding) = 0;
3039 /* Any inherited type declaration is hidden by the type
3040 declaration in the derived class. */
3041 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
3042 binding->type = NULL_TREE;
3045 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
3047 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
3049 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
3051 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
3054 if (old_decl && binding->scope == class_binding_level)
3057 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3058 here. This function is only used to register bindings
3059 from with the class definition itself. */
3060 INHERITED_VALUE_BINDING_P (binding) = 0;
3065 /* Note that we declared this value so that we can issue an error if
3066 this is an invalid redeclaration of a name already used for some
3068 note_name_declared_in_class (name, decl);
3070 /* If we didn't replace an existing binding, put the binding on the
3071 stack of bindings for the identifier, and update the shadowed
3073 if (binding && binding->scope == class_binding_level)
3074 /* Supplement the existing binding. */
3075 ok = supplement_binding (binding, decl);
3078 /* Create a new binding. */
3079 push_binding (name, decl, class_binding_level);
3086 /* Wrapper for push_class_level_binding_1. */
3089 push_class_level_binding (tree name, tree x)
3092 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3093 ret = push_class_level_binding_1 (name, x);
3094 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3098 /* Process "using SCOPE::NAME" in a class scope. Return the
3099 USING_DECL created. */
3102 do_class_using_decl (tree scope, tree name)
3104 /* The USING_DECL returned by this function. */
3106 /* The declaration (or declarations) name by this using
3107 declaration. NULL if we are in a template and cannot figure out
3108 what has been named. */
3110 /* True if SCOPE is a dependent type. */
3111 bool scope_dependent_p;
3112 /* True if SCOPE::NAME is dependent. */
3113 bool name_dependent_p;
3114 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3115 bool bases_dependent_p;
3120 if (name == error_mark_node)
3123 if (!scope || !TYPE_P (scope))
3125 error ("using-declaration for non-member at class scope");
3129 /* Make sure the name is not invalid */
3130 if (TREE_CODE (name) == BIT_NOT_EXPR)
3132 error ("%<%T::%D%> names destructor", scope, name);
3135 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3137 error ("%<%T::%D%> names constructor", scope, name);
3140 if (constructor_name_p (name, current_class_type))
3142 error ("%<%T::%D%> names constructor in %qT",
3143 scope, name, current_class_type);
3147 scope_dependent_p = dependent_type_p (scope);
3148 name_dependent_p = (scope_dependent_p
3149 || (IDENTIFIER_TYPENAME_P (name)
3150 && dependent_type_p (TREE_TYPE (name))));
3152 bases_dependent_p = false;
3153 if (processing_template_decl)
3154 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3155 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3157 if (dependent_type_p (TREE_TYPE (base_binfo)))
3159 bases_dependent_p = true;
3165 /* From [namespace.udecl]:
3167 A using-declaration used as a member-declaration shall refer to a
3168 member of a base class of the class being defined.
3170 In general, we cannot check this constraint in a template because
3171 we do not know the entire set of base classes of the current
3172 class type. However, if all of the base classes are
3173 non-dependent, then we can avoid delaying the check until
3175 if (!scope_dependent_p)
3178 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3179 if (b_kind < bk_proper_base)
3181 if (!bases_dependent_p)
3183 error_not_base_type (scope, current_class_type);
3187 else if (!name_dependent_p)
3189 decl = lookup_member (binfo, name, 0, false);
3192 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3196 /* The binfo from which the functions came does not matter. */
3197 if (BASELINK_P (decl))
3198 decl = BASELINK_FUNCTIONS (decl);
3202 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3203 USING_DECL_DECLS (value) = decl;
3204 USING_DECL_SCOPE (value) = scope;
3205 DECL_DEPENDENT_P (value) = !decl;
3211 /* Return the binding value for name in scope. */
3215 namespace_binding_1 (tree name, tree scope)
3217 cxx_binding *binding;
3219 if (SCOPE_FILE_SCOPE_P (scope))
3220 scope = global_namespace;
3222 /* Unnecessary for the global namespace because it can't be an alias. */
3223 scope = ORIGINAL_NAMESPACE (scope);
3225 binding = cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3227 return binding ? binding->value : NULL_TREE;
3231 namespace_binding (tree name, tree scope)
3234 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3235 ret = namespace_binding_1 (name, scope);
3236 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3240 /* Set the binding value for name in scope. */
3243 set_namespace_binding_1 (tree name, tree scope, tree val)
3247 if (scope == NULL_TREE)
3248 scope = global_namespace;
3249 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3250 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3253 supplement_binding (b, val);
3256 /* Wrapper for set_namespace_binding_1. */
3259 set_namespace_binding (tree name, tree scope, tree val)
3261 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3262 set_namespace_binding_1 (name, scope, val);
3263 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3266 /* Set the context of a declaration to scope. Complain if we are not
3270 set_decl_namespace (tree decl, tree scope, bool friendp)
3274 /* Get rid of namespace aliases. */
3275 scope = ORIGINAL_NAMESPACE (scope);
3277 /* It is ok for friends to be qualified in parallel space. */
3278 if (!friendp && !is_ancestor (current_namespace, scope))
3279 error ("declaration of %qD not in a namespace surrounding %qD",
3281 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3283 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3284 if (scope == current_namespace)
3286 if (at_namespace_scope_p ())
3287 error ("explicit qualification in declaration of %qD",
3292 /* See whether this has been declared in the namespace. */
3293 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3294 if (old == error_mark_node)
3295 /* No old declaration at all. */
3297 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3298 if (TREE_CODE (old) == TREE_LIST)
3300 error ("reference to %qD is ambiguous", decl);
3301 print_candidates (old);
3304 if (!is_overloaded_fn (decl))
3306 /* We might have found OLD in an inline namespace inside SCOPE. */
3307 if (TREE_CODE (decl) == TREE_CODE (old))
3308 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3309 /* Don't compare non-function decls with decls_match here, since
3310 it can't check for the correct constness at this
3311 point. pushdecl will find those errors later. */
3314 /* Since decl is a function, old should contain a function decl. */
3315 if (!is_overloaded_fn (old))
3317 /* A template can be explicitly specialized in any namespace. */
3318 if (processing_explicit_instantiation)
3320 if (processing_template_decl || processing_specialization)
3321 /* We have not yet called push_template_decl to turn a
3322 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3323 match. But, we'll check later, when we construct the
3326 /* Instantiations or specializations of templates may be declared as
3327 friends in any namespace. */
3328 if (friendp && DECL_USE_TEMPLATE (decl))
3330 if (is_overloaded_fn (old))
3332 tree found = NULL_TREE;
3334 for (; elt; elt = OVL_NEXT (elt))
3336 tree ofn = OVL_CURRENT (elt);
3337 /* Adjust DECL_CONTEXT first so decls_match will return true
3338 if DECL will match a declaration in an inline namespace. */
3339 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3340 if (decls_match (decl, ofn))
3342 if (found && !decls_match (found, ofn))
3344 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3345 error ("reference to %qD is ambiguous", decl);
3346 print_candidates (old);
3354 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3356 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3362 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3363 if (decls_match (decl, old))
3367 /* It didn't work, go back to the explicit scope. */
3368 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3370 error ("%qD should have been declared inside %qD", decl, scope);
3373 /* Return the namespace where the current declaration is declared. */
3376 current_decl_namespace (void)
3379 /* If we have been pushed into a different namespace, use it. */
3380 if (!VEC_empty (tree, decl_namespace_list))
3381 return VEC_last (tree, decl_namespace_list);
3383 if (current_class_type)
3384 result = decl_namespace_context (current_class_type);
3385 else if (current_function_decl)
3386 result = decl_namespace_context (current_function_decl);
3388 result = current_namespace;
3392 /* Process any ATTRIBUTES on a namespace definition. Currently only
3393 attribute visibility is meaningful, which is a property of the syntactic
3394 block rather than the namespace as a whole, so we don't touch the
3395 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3398 handle_namespace_attrs (tree ns, tree attributes)
3401 bool saw_vis = false;
3403 for (d = attributes; d; d = TREE_CHAIN (d))
3405 tree name = TREE_PURPOSE (d);
3406 tree args = TREE_VALUE (d);
3408 if (is_attribute_p ("visibility", name))
3410 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3411 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3413 warning (OPT_Wattributes,
3414 "%qD attribute requires a single NTBS argument",
3419 if (!TREE_PUBLIC (ns))
3420 warning (OPT_Wattributes,
3421 "%qD attribute is meaningless since members of the "
3422 "anonymous namespace get local symbols", name);
3424 push_visibility (TREE_STRING_POINTER (x), 1);
3429 warning (OPT_Wattributes, "%qD attribute directive ignored",
3438 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3439 select a name that is unique to this compilation unit. */
3442 push_namespace (tree name)
3446 int implicit_use = 0;
3449 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3451 /* We should not get here if the global_namespace is not yet constructed
3452 nor if NAME designates the global namespace: The global scope is
3453 constructed elsewhere. */
3454 gcc_assert (global_namespace != NULL && name != global_scope_name);
3458 name = get_anonymous_namespace_name();
3459 d = IDENTIFIER_NAMESPACE_VALUE (name);
3461 /* Reopening anonymous namespace. */
3467 /* Check whether this is an extended namespace definition. */
3468 d = IDENTIFIER_NAMESPACE_VALUE (name);
3469 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3472 if (DECL_NAMESPACE_ALIAS (d))
3474 error ("namespace alias %qD not allowed here, assuming %qD",
3475 d, DECL_NAMESPACE_ALIAS (d));
3476 d = DECL_NAMESPACE_ALIAS (d);
3483 /* Make a new namespace, binding the name to it. */
3484 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3485 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3486 /* The name of this namespace is not visible to other translation
3487 units if it is an anonymous namespace or member thereof. */
3488 if (anon || decl_anon_ns_mem_p (current_namespace))
3489 TREE_PUBLIC (d) = 0;
3491 TREE_PUBLIC (d) = 1;
3495 /* Clear DECL_NAME for the benefit of debugging back ends. */
3496 SET_DECL_ASSEMBLER_NAME (d, name);
3497 DECL_NAME (d) = NULL_TREE;
3499 begin_scope (sk_namespace, d);
3502 resume_scope (NAMESPACE_LEVEL (d));
3505 do_using_directive (d);
3506 /* Enter the name space. */
3507 current_namespace = d;
3509 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3512 /* Pop from the scope of the current namespace. */
3515 pop_namespace (void)
3517 gcc_assert (current_namespace != global_namespace);
3518 current_namespace = CP_DECL_CONTEXT (current_namespace);
3519 /* The binding level is not popped, as it might be re-opened later. */
3523 /* Push into the scope of the namespace NS, even if it is deeply
3524 nested within another namespace. */
3527 push_nested_namespace (tree ns)
3529 if (ns == global_namespace)
3530 push_to_top_level ();
3533 push_nested_namespace (CP_DECL_CONTEXT (ns));
3534 push_namespace (DECL_NAME (ns));
3538 /* Pop back from the scope of the namespace NS, which was previously
3539 entered with push_nested_namespace. */
3542 pop_nested_namespace (tree ns)
3544 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3545 gcc_assert (current_namespace == ns);
3546 while (ns != global_namespace)
3549 ns = CP_DECL_CONTEXT (ns);
3552 pop_from_top_level ();
3553 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3556 /* Temporarily set the namespace for the current declaration. */
3559 push_decl_namespace (tree decl)
3561 if (TREE_CODE (decl) != NAMESPACE_DECL)
3562 decl = decl_namespace_context (decl);
3563 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3566 /* [namespace.memdef]/2 */
3569 pop_decl_namespace (void)
3571 VEC_pop (tree, decl_namespace_list);
3574 /* Return the namespace that is the common ancestor
3575 of two given namespaces. */
3578 namespace_ancestor_1 (tree ns1, tree ns2)
3581 if (is_ancestor (ns1, ns2))
3584 nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
3588 /* Wrapper for namespace_ancestor_1. */
3591 namespace_ancestor (tree ns1, tree ns2)
3594 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3595 nsr = namespace_ancestor_1 (ns1, ns2);
3596 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3600 /* Process a namespace-alias declaration. */
3603 do_namespace_alias (tree alias, tree name_space)
3605 if (name_space == error_mark_node)
3608 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3610 name_space = ORIGINAL_NAMESPACE (name_space);
3612 /* Build the alias. */
3613 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3614 DECL_NAMESPACE_ALIAS (alias) = name_space;
3615 DECL_EXTERNAL (alias) = 1;
3616 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3619 /* Emit debug info for namespace alias. */
3620 if (!building_stmt_list_p ())
3621 (*debug_hooks->global_decl) (alias);
3624 /* Like pushdecl, only it places X in the current namespace,
3628 pushdecl_namespace_level (tree x, bool is_friend)
3630 cp_binding_level *b = current_binding_level;
3633 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3634 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3636 /* Now, the type_shadowed stack may screw us. Munge it so it does
3638 if (TREE_CODE (t) == TYPE_DECL)
3640 tree name = DECL_NAME (t);
3642 tree *ptr = (tree *)0;
3643 for (; !global_scope_p (b); b = b->level_chain)
3645 tree shadowed = b->type_shadowed;
3646 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3647 if (TREE_PURPOSE (shadowed) == name)
3649 ptr = &TREE_VALUE (shadowed);
3650 /* Can't break out of the loop here because sometimes
3651 a binding level will have duplicate bindings for
3652 PT names. It's gross, but I haven't time to fix it. */
3655 newval = TREE_TYPE (t);
3656 if (ptr == (tree *)0)
3658 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3659 up here if this is changed to an assertion. --KR */
3660 SET_IDENTIFIER_TYPE_VALUE (name, t);
3667 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3671 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3672 directive is not directly from the source. Also find the common
3673 ancestor and let our users know about the new namespace */
3676 add_using_namespace_1 (tree user, tree used, bool indirect)
3679 /* Using oneself is a no-op. */
3682 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3683 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3684 /* Check if we already have this. */
3685 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3689 /* Promote to direct usage. */
3690 TREE_INDIRECT_USING (t) = 0;
3694 /* Add used to the user's using list. */
3695 DECL_NAMESPACE_USING (user)
3696 = tree_cons (used, namespace_ancestor (user, used),
3697 DECL_NAMESPACE_USING (user));
3699 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3701 /* Add user to the used's users list. */
3702 DECL_NAMESPACE_USERS (used)
3703 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3705 /* Recursively add all namespaces used. */
3706 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3707 /* indirect usage */
3708 add_using_namespace_1 (user, TREE_PURPOSE (t), 1);
3710 /* Tell everyone using us about the new used namespaces. */
3711 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3712 add_using_namespace_1 (TREE_PURPOSE (t), used, 1);
3715 /* Wrapper for add_using_namespace_1. */
3718 add_using_namespace (tree user, tree used, bool indirect)
3720 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3721 add_using_namespace_1 (user, used, indirect);
3722 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3725 /* Process a using-declaration not appearing in class or local scope. */
3728 do_toplevel_using_decl (tree decl, tree scope, tree name)
3730 tree oldval, oldtype, newval, newtype;
3731 tree orig_decl = decl;
3732 cxx_binding *binding;
3734 decl = validate_nonmember_using_decl (decl, scope, name);
3735 if (decl == NULL_TREE)
3738 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3740 oldval = binding->value;
3741 oldtype = binding->type;
3743 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3745 /* Emit debug info. */
3746 if (!processing_template_decl)
3747 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3749 /* Copy declarations found. */
3751 binding->value = newval;
3753 binding->type = newtype;
3756 /* Process a using-directive. */
3759 do_using_directive (tree name_space)
3761 tree context = NULL_TREE;
3763 if (name_space == error_mark_node)
3766 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3768 if (building_stmt_list_p ())
3769 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3770 name_space = ORIGINAL_NAMESPACE (name_space);
3772 if (!toplevel_bindings_p ())
3774 push_using_directive (name_space);
3779 add_using_namespace (current_namespace, name_space, 0);
3780 if (current_namespace != global_namespace)
3781 context = current_namespace;
3783 /* Emit debugging info. */
3784 if (!processing_template_decl)
3785 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3790 /* Deal with a using-directive seen by the parser. Currently we only
3791 handle attributes here, since they cannot appear inside a template. */
3794 parse_using_directive (tree name_space, tree attribs)
3798 do_using_directive (name_space);
3800 for (a = attribs; a; a = TREE_CHAIN (a))
3802 tree name = TREE_PURPOSE (a);
3803 if (is_attribute_p ("strong", name))
3805 if (!toplevel_bindings_p ())
3806 error ("strong using only meaningful at namespace scope");
3807 else if (name_space != error_mark_node)
3809 if (!is_ancestor (current_namespace, name_space))
3810 error ("current namespace %qD does not enclose strongly used namespace %qD",
3811 current_namespace, name_space);
3812 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3813 = tree_cons (current_namespace, 0,
3814 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3818 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3822 /* Like pushdecl, only it places X in the global scope if appropriate.
3823 Calls cp_finish_decl to register the variable, initializing it with
3824 *INIT, if INIT is non-NULL. */
3827 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3829 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3830 push_to_top_level ();
3831 x = pushdecl_namespace_level (x, is_friend);
3833 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3834 pop_from_top_level ();
3835 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3839 /* Like pushdecl, only it places X in the global scope if appropriate. */
3842 pushdecl_top_level (tree x)
3844 return pushdecl_top_level_1 (x, NULL, false);
3847 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3850 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3852 return pushdecl_top_level_1 (x, NULL, is_friend);
3855 /* Like pushdecl, only it places X in the global scope if
3856 appropriate. Calls cp_finish_decl to register the variable,
3857 initializing it with INIT. */
3860 pushdecl_top_level_and_finish (tree x, tree init)
3862 return pushdecl_top_level_1 (x, &init, false);
3865 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3866 duplicates. The first list becomes the tail of the result.
3868 The algorithm is O(n^2). We could get this down to O(n log n) by
3869 doing a sort on the addresses of the functions, if that becomes
3873 merge_functions (tree s1, tree s2)
3875 for (; s2; s2 = OVL_NEXT (s2))
3877 tree fn2 = OVL_CURRENT (s2);
3880 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3882 tree fn1 = OVL_CURRENT (fns1);
3884 /* If the function from S2 is already in S1, there is no
3885 need to add it again. For `extern "C"' functions, we
3886 might have two FUNCTION_DECLs for the same function, in
3887 different namespaces, but let's leave them in in case
3888 they have different default arguments. */
3893 /* If we exhausted all of the functions in S1, FN2 is new. */
3895 s1 = build_overload (fn2, s1);
3900 /* Returns TRUE iff OLD and NEW are the same entity.
3902 3 [basic]/3: An entity is a value, object, reference, function,
3903 enumerator, type, class member, template, template specialization,
3904 namespace, parameter pack, or this.
3906 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3907 in two different namespaces, and the declarations do not declare the
3908 same entity and do not declare functions, the use of the name is
3912 same_entity_p (tree one, tree two)
3918 if (TREE_CODE (one) == TYPE_DECL
3919 && TREE_CODE (two) == TYPE_DECL
3920 && same_type_p (TREE_TYPE (one), TREE_TYPE (two)))
3925 /* This should return an error not all definitions define functions.
3926 It is not an error if we find two functions with exactly the
3927 same signature, only if these are selected in overload resolution.
3928 old is the current set of bindings, new_binding the freshly-found binding.
3929 XXX Do we want to give *all* candidates in case of ambiguity?
3930 XXX In what way should I treat extern declarations?
3931 XXX I don't want to repeat the entire duplicate_decls here */
3934 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3937 gcc_assert (old != NULL);
3939 /* Copy the type. */
3940 type = new_binding->type;
3941 if (LOOKUP_NAMESPACES_ONLY (flags)
3942 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3945 /* Copy the value. */
3946 val = new_binding->value;
3949 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3952 switch (TREE_CODE (val))
3955 /* If we expect types or namespaces, and not templates,
3956 or this is not a template class. */
3957 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3958 && !DECL_CLASS_TEMPLATE_P (val)))
3962 if (LOOKUP_NAMESPACES_ONLY (flags)
3963 || (type && (flags & LOOKUP_PREFER_TYPES)))
3966 case NAMESPACE_DECL:
3967 if (LOOKUP_TYPES_ONLY (flags))
3971 /* Ignore built-in functions that are still anticipated. */
3972 if (LOOKUP_QUALIFIERS_ONLY (flags))
3976 if (LOOKUP_QUALIFIERS_ONLY (flags))
3981 /* If val is hidden, shift down any class or enumeration name. */
3990 else if (val && !same_entity_p (val, old->value))
3992 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3993 old->value = merge_functions (old->value, val);
3996 old->value = tree_cons (NULL_TREE, old->value,
3997 build_tree_list (NULL_TREE, val));
3998 TREE_TYPE (old->value) = error_mark_node;
4004 else if (type && old->type != type)
4006 old->type = tree_cons (NULL_TREE, old->type,
4007 build_tree_list (NULL_TREE, type));
4008 TREE_TYPE (old->type) = error_mark_node;
4012 /* Return the declarations that are members of the namespace NS. */
4015 cp_namespace_decls (tree ns)
4017 return NAMESPACE_LEVEL (ns)->names;
4020 /* Combine prefer_type and namespaces_only into flags. */
4023 lookup_flags (int prefer_type, int namespaces_only)
4025 if (namespaces_only)
4026 return LOOKUP_PREFER_NAMESPACES;
4027 if (prefer_type > 1)
4028 return LOOKUP_PREFER_TYPES;
4029 if (prefer_type > 0)
4030 return LOOKUP_PREFER_BOTH;
4034 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4035 ignore it or not. Subroutine of lookup_name_real and
4036 lookup_type_scope. */
4039 qualify_lookup (tree val, int flags)
4041 if (val == NULL_TREE)
4043 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
4045 if ((flags & LOOKUP_PREFER_TYPES)
4046 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
4048 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
4050 /* Look through lambda things that we shouldn't be able to see. */
4051 if (is_lambda_ignored_entity (val))
4056 /* Given a lookup that returned VAL, decide if we want to ignore it or
4057 not based on DECL_ANTICIPATED. */
4060 hidden_name_p (tree val)
4063 && DECL_LANG_SPECIFIC (val)
4064 && DECL_ANTICIPATED (val))
4069 /* Remove any hidden friend functions from a possibly overloaded set
4073 remove_hidden_names (tree fns)
4078 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
4080 else if (TREE_CODE (fns) == OVERLOAD)
4084 for (o = fns; o; o = OVL_NEXT (o))
4085 if (hidden_name_p (OVL_CURRENT (o)))
4091 for (o = fns; o; o = OVL_NEXT (o))
4092 if (!hidden_name_p (OVL_CURRENT (o)))
4093 n = build_overload (OVL_CURRENT (o), n);
4101 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4102 lookup failed. Search through all available namespaces and print out
4103 possible candidates. */
4106 suggest_alternatives_for (location_t location, tree name)
4108 VEC(tree,heap) *candidates = NULL;
4109 VEC(tree,heap) *namespaces_to_search = NULL;
4110 int max_to_search = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
4115 VEC_safe_push (tree, heap, namespaces_to_search, global_namespace);
4117 while (!VEC_empty (tree, namespaces_to_search)
4118 && n_searched < max_to_search)
4120 tree scope = VEC_pop (tree, namespaces_to_search);
4121 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4122 cp_binding_level *level = NAMESPACE_LEVEL (scope);
4124 /* Look in this namespace. */
4125 qualified_lookup_using_namespace (name, scope, &binding, 0);
4130 VEC_safe_push (tree, heap, candidates, binding.value);
4132 /* Add child namespaces. */
4133 for (t = level->namespaces; t; t = DECL_CHAIN (t))
4134 VEC_safe_push (tree, heap, namespaces_to_search, t);
4137 /* If we stopped before we could examine all namespaces, inform the
4138 user. Do this even if we don't have any candidates, since there
4139 might be more candidates further down that we weren't able to
4141 if (n_searched >= max_to_search
4142 && !VEC_empty (tree, namespaces_to_search))
4144 "maximum limit of %d namespaces searched for %qE",
4145 max_to_search, name);
4147 VEC_free (tree, heap, namespaces_to_search);
4149 /* Nothing useful to report. */
4150 if (VEC_empty (tree, candidates))
4153 inform_n (location, VEC_length (tree, candidates),
4154 "suggested alternative:",
4155 "suggested alternatives:");
4157 FOR_EACH_VEC_ELT (tree, candidates, ix, t)
4158 inform (location_of (t), " %qE", t);
4160 VEC_free (tree, heap, candidates);
4163 /* Unscoped lookup of a global: iterate over current namespaces,
4164 considering using-directives. */
4167 unqualified_namespace_lookup_1 (tree name, int flags)
4169 tree initial = current_decl_namespace ();
4170 tree scope = initial;
4172 cp_binding_level *level;
4173 tree val = NULL_TREE;
4175 for (; !val; scope = CP_DECL_CONTEXT (scope))
4177 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4179 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4182 ambiguous_decl (&binding, b, flags);
4184 /* Add all _DECLs seen through local using-directives. */
4185 for (level = current_binding_level;
4186 level->kind != sk_namespace;
4187 level = level->level_chain)
4188 if (!lookup_using_namespace (name, &binding, level->using_directives,
4190 /* Give up because of error. */
4191 return error_mark_node;
4193 /* Add all _DECLs seen through global using-directives. */
4194 /* XXX local and global using lists should work equally. */
4198 if (!lookup_using_namespace (name, &binding,
4199 DECL_NAMESPACE_USING (siter),
4201 /* Give up because of error. */
4202 return error_mark_node;
4203 if (siter == scope) break;
4204 siter = CP_DECL_CONTEXT (siter);
4207 val = binding.value;
4208 if (scope == global_namespace)
4214 /* Wrapper for unqualified_namespace_lookup_1. */
4217 unqualified_namespace_lookup (tree name, int flags)
4220 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4221 ret = unqualified_namespace_lookup_1 (name, flags);
4222 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4226 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4227 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4230 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4231 declaration found. If no suitable declaration can be found,
4232 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4233 neither a class-type nor a namespace a diagnostic is issued. */
4236 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
4241 if (TREE_CODE (scope) == NAMESPACE_DECL)
4243 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4245 flags |= LOOKUP_COMPLAIN;
4247 flags |= LOOKUP_PREFER_TYPES;
4248 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
4251 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
4252 t = lookup_enumerator (scope, name);
4253 else if (is_class_type (scope, complain))
4254 t = lookup_member (scope, name, 2, is_type_p);
4257 return error_mark_node;
4261 /* Subroutine of unqualified_namespace_lookup:
4262 Add the bindings of NAME in used namespaces to VAL.
4263 We are currently looking for names in namespace SCOPE, so we
4264 look through USINGS for using-directives of namespaces
4265 which have SCOPE as a common ancestor with the current scope.
4266 Returns false on errors. */
4269 lookup_using_namespace (tree name, struct scope_binding *val,
4270 tree usings, tree scope, int flags)
4273 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4274 /* Iterate over all used namespaces in current, searching for using
4275 directives of scope. */
4276 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4277 if (TREE_VALUE (iter) == scope)
4279 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
4281 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used), name);
4282 /* Resolve ambiguities. */
4284 ambiguous_decl (val, val1, flags);
4286 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4287 return val->value != error_mark_node;
4290 /* Returns true iff VEC contains TARGET. */
4293 tree_vec_contains (VEC(tree,gc)* vec, tree target)
4297 FOR_EACH_VEC_ELT (tree,vec,i,elt)
4304 Accepts the NAME to lookup and its qualifying SCOPE.
4305 Returns the name/type pair found into the cxx_binding *RESULT,
4306 or false on error. */
4309 qualified_lookup_using_namespace (tree name, tree scope,
4310 struct scope_binding *result, int flags)
4312 /* Maintain a list of namespaces visited... */
4313 VEC(tree,gc) *seen = NULL;
4314 VEC(tree,gc) *seen_inline = NULL;
4315 /* ... and a list of namespace yet to see. */
4316 VEC(tree,gc) *todo = NULL;
4317 VEC(tree,gc) *todo_maybe = NULL;
4318 VEC(tree,gc) *todo_inline = NULL;
4320 timevar_start (TV_NAME_LOOKUP);
4321 /* Look through namespace aliases. */
4322 scope = ORIGINAL_NAMESPACE (scope);
4324 /* Algorithm: Starting with SCOPE, walk through the set of used
4325 namespaces. For each used namespace, look through its inline
4326 namespace set for any bindings and usings. If no bindings are
4327 found, add any usings seen to the set of used namespaces. */
4328 VEC_safe_push (tree, gc, todo, scope);
4330 while (VEC_length (tree, todo))
4333 scope = VEC_pop (tree, todo);
4334 if (tree_vec_contains (seen, scope))
4336 VEC_safe_push (tree, gc, seen, scope);
4337 VEC_safe_push (tree, gc, todo_inline, scope);
4340 while (VEC_length (tree, todo_inline))
4342 cxx_binding *binding;
4344 scope = VEC_pop (tree, todo_inline);
4345 if (tree_vec_contains (seen_inline, scope))
4347 VEC_safe_push (tree, gc, seen_inline, scope);
4350 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4354 ambiguous_decl (result, binding, flags);
4357 for (usings = DECL_NAMESPACE_USING (scope); usings;
4358 usings = TREE_CHAIN (usings))
4359 if (!TREE_INDIRECT_USING (usings))
4361 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4362 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4364 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4369 VEC_truncate (tree, todo_maybe, 0);
4371 while (VEC_length (tree, todo_maybe))
4372 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4374 VEC_free (tree,gc,todo);
4375 VEC_free (tree,gc,todo_maybe);
4376 VEC_free (tree,gc,todo_inline);
4377 VEC_free (tree,gc,seen);
4378 VEC_free (tree,gc,seen_inline);
4379 timevar_stop (TV_NAME_LOOKUP);
4380 return result->value != error_mark_node;
4383 /* Subroutine of outer_binding.
4385 Returns TRUE if BINDING is a binding to a template parameter of
4386 SCOPE. In that case SCOPE is the scope of a primary template
4387 parameter -- in the sense of G++, i.e, a template that has its own
4390 Returns FALSE otherwise. */
4393 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4394 cp_binding_level *scope)
4398 if (!binding || !scope)
4401 binding_value = binding->value ? binding->value : binding->type;
4404 && scope->this_entity
4405 && get_template_info (scope->this_entity)
4406 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4407 (get_template_info (scope->this_entity)))
4408 && parameter_of_template_p (binding_value,
4409 TI_TEMPLATE (get_template_info \
4410 (scope->this_entity))));
4413 /* Return the innermost non-namespace binding for NAME from a scope
4414 containing BINDING, or, if BINDING is NULL, the current scope.
4415 Please note that for a given template, the template parameters are
4416 considered to be in the scope containing the current scope.
4417 If CLASS_P is false, then class bindings are ignored. */
4420 outer_binding (tree name,
4421 cxx_binding *binding,
4425 cp_binding_level *scope;
4426 cp_binding_level *outer_scope;
4430 scope = binding->scope->level_chain;
4431 outer = binding->previous;
4435 scope = current_binding_level;
4436 outer = IDENTIFIER_BINDING (name);
4438 outer_scope = outer ? outer->scope : NULL;
4440 /* Because we create class bindings lazily, we might be missing a
4441 class binding for NAME. If there are any class binding levels
4442 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4443 declared, we must lookup NAME in those class scopes. */
4445 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4447 if (scope->kind == sk_class)
4449 cxx_binding *class_binding;
4451 class_binding = get_class_binding (name, scope);
4454 /* Thread this new class-scope binding onto the
4455 IDENTIFIER_BINDING list so that future lookups
4457 class_binding->previous = outer;
4459 binding->previous = class_binding;
4461 IDENTIFIER_BINDING (name) = class_binding;
4462 return class_binding;
4465 /* If we are in a member template, the template parms of the member
4466 template are considered to be inside the scope of the containing
4467 class, but within G++ the class bindings are all pushed between the
4468 template parms and the function body. So if the outer binding is
4469 a template parm for the current scope, return it now rather than
4470 look for a class binding. */
4471 if (outer_scope && outer_scope->kind == sk_template_parms
4472 && binding_to_template_parms_of_scope_p (outer, scope))
4475 scope = scope->level_chain;
4481 /* Return the innermost block-scope or class-scope value binding for
4482 NAME, or NULL_TREE if there is no such binding. */
4485 innermost_non_namespace_value (tree name)
4487 cxx_binding *binding;
4488 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4489 return binding ? binding->value : NULL_TREE;
4492 /* Look up NAME in the current binding level and its superiors in the
4493 namespace of variables, functions and typedefs. Return a ..._DECL
4494 node of some kind representing its definition if there is only one
4495 such declaration, or return a TREE_LIST with all the overloaded
4496 definitions if there are many, or return 0 if it is undefined.
4497 Hidden name, either friend declaration or built-in function, are
4500 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4501 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4502 Otherwise we prefer non-TYPE_DECLs.
4504 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4505 BLOCK_P is false, bindings in block scopes are ignored. */
4508 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
4509 int namespaces_only, int flags)
4512 tree val = NULL_TREE;
4514 /* Conversion operators are handled specially because ordinary
4515 unqualified name lookup will not find template conversion
4517 if (IDENTIFIER_TYPENAME_P (name))
4519 cp_binding_level *level;
4521 for (level = current_binding_level;
4522 level && level->kind != sk_namespace;
4523 level = level->level_chain)
4528 /* A conversion operator can only be declared in a class
4530 if (level->kind != sk_class)
4533 /* Lookup the conversion operator in the class. */
4534 class_type = level->this_entity;
4535 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4543 flags |= lookup_flags (prefer_type, namespaces_only);
4545 /* First, look in non-namespace scopes. */
4547 if (current_class_type == NULL_TREE)
4550 if (block_p || !nonclass)
4551 for (iter = outer_binding (name, NULL, !nonclass);
4553 iter = outer_binding (name, iter, !nonclass))
4557 /* Skip entities we don't want. */
4558 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4561 /* If this is the kind of thing we're looking for, we're done. */
4562 if (qualify_lookup (iter->value, flags))
4563 binding = iter->value;
4564 else if ((flags & LOOKUP_PREFER_TYPES)
4565 && qualify_lookup (iter->type, flags))
4566 binding = iter->type;
4568 binding = NULL_TREE;
4572 if (hidden_name_p (binding))
4574 /* A non namespace-scope binding can only be hidden in the
4575 presence of a local class, due to friend declarations.
4577 In particular, consider:
4585 B* b; // error: B is hidden
4586 C* c; // OK, finds ::C
4589 B *b; // error: B is hidden
4590 C *c; // OK, finds ::C
4595 The standard says that "B" is a local class in "f"
4596 (but not nested within "A") -- but that name lookup
4597 for "B" does not find this declaration until it is
4598 declared directly with "f".
4604 If a friend declaration appears in a local class and
4605 the name specified is an unqualified name, a prior
4606 declaration is looked up without considering scopes
4607 that are outside the innermost enclosing non-class
4608 scope. For a friend function declaration, if there is
4609 no prior declaration, the program is ill-formed. For a
4610 friend class declaration, if there is no prior
4611 declaration, the class that is specified belongs to the
4612 innermost enclosing non-class scope, but if it is
4613 subsequently referenced, its name is not found by name
4614 lookup until a matching declaration is provided in the
4615 innermost enclosing nonclass scope.
4617 So just keep looking for a non-hidden binding.
4619 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4627 /* Now lookup in namespace scopes. */
4629 val = unqualified_namespace_lookup (name, flags);
4631 /* If we have a single function from a using decl, pull it out. */
4632 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4633 val = OVL_FUNCTION (val);
4638 /* Wrapper for lookup_name_real_1. */
4641 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4642 int namespaces_only, int flags)
4645 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4646 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
4647 namespaces_only, flags);
4648 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4653 lookup_name_nonclass (tree name)
4655 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4659 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4662 lookup_arg_dependent (name,
4663 lookup_name_real (name, 0, 1, block_p, 0,
4669 lookup_name (tree name)
4671 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4675 lookup_name_prefer_type (tree name, int prefer_type)
4677 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4678 0, LOOKUP_COMPLAIN);
4681 /* Look up NAME for type used in elaborated name specifier in
4682 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4683 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4684 name, more scopes are checked if cleanup or template parameter
4685 scope is encountered.
4687 Unlike lookup_name_real, we make sure that NAME is actually
4688 declared in the desired scope, not from inheritance, nor using
4689 directive. For using declaration, there is DR138 still waiting
4690 to be resolved. Hidden name coming from an earlier friend
4691 declaration is also returned.
4693 A TYPE_DECL best matching the NAME is returned. Catching error
4694 and issuing diagnostics are caller's responsibility. */
4697 lookup_type_scope_1 (tree name, tag_scope scope)
4699 cxx_binding *iter = NULL;
4700 tree val = NULL_TREE;
4702 /* Look in non-namespace scope first. */
4703 if (current_binding_level->kind != sk_namespace)
4704 iter = outer_binding (name, NULL, /*class_p=*/ true);
4705 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4707 /* Check if this is the kind of thing we're looking for.
4708 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4709 base class. For ITER->VALUE, we can simply use
4710 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4713 We check ITER->TYPE before ITER->VALUE in order to handle
4714 typedef struct C {} C;
4717 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4718 && (scope != ts_current
4719 || LOCAL_BINDING_P (iter)
4720 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4722 else if ((scope != ts_current
4723 || !INHERITED_VALUE_BINDING_P (iter))
4724 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4731 /* Look in namespace scope. */
4734 iter = cp_binding_level_find_binding_for_name
4735 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4739 /* If this is the kind of thing we're looking for, we're done. */
4740 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4742 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4748 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4749 and template parameter scopes. */
4752 cp_binding_level *b = current_binding_level;
4755 if (iter->scope == b)
4758 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4759 || b->kind == sk_function_parms)
4761 else if (b->kind == sk_class
4762 && scope == ts_within_enclosing_non_class)
4772 /* Wrapper for lookup_type_scope_1. */
4775 lookup_type_scope (tree name, tag_scope scope)
4778 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4779 ret = lookup_type_scope_1 (name, scope);
4780 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4785 /* Similar to `lookup_name' but look only in the innermost non-class
4789 lookup_name_innermost_nonclass_level_1 (tree name)
4791 cp_binding_level *b;
4794 b = innermost_nonclass_level ();
4796 if (b->kind == sk_namespace)
4798 t = IDENTIFIER_NAMESPACE_VALUE (name);
4800 /* extern "C" function() */
4801 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4804 else if (IDENTIFIER_BINDING (name)
4805 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4807 cxx_binding *binding;
4808 binding = IDENTIFIER_BINDING (name);
4811 if (binding->scope == b
4812 && !(TREE_CODE (binding->value) == VAR_DECL
4813 && DECL_DEAD_FOR_LOCAL (binding->value)))
4814 return binding->value;
4816 if (b->kind == sk_cleanup)
4826 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4829 lookup_name_innermost_nonclass_level (tree name)
4832 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4833 ret = lookup_name_innermost_nonclass_level_1 (name);
4834 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4839 /* Returns true iff DECL is a block-scope extern declaration of a function
4843 is_local_extern (tree decl)
4845 cxx_binding *binding;
4847 /* For functions, this is easy. */
4848 if (TREE_CODE (decl) == FUNCTION_DECL)
4849 return DECL_LOCAL_FUNCTION_P (decl);
4851 if (TREE_CODE (decl) != VAR_DECL)
4853 if (!current_function_decl)
4856 /* For variables, this is not easy. We need to look at the binding stack
4857 for the identifier to see whether the decl we have is a local. */
4858 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4859 binding && binding->scope->kind != sk_namespace;
4860 binding = binding->previous)
4861 if (binding->value == decl)
4862 return LOCAL_BINDING_P (binding);
4867 /* Like lookup_name_innermost_nonclass_level, but for types. */
4870 lookup_type_current_level (tree name)
4874 timevar_start (TV_NAME_LOOKUP);
4875 gcc_assert (current_binding_level->kind != sk_namespace);
4877 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4878 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4880 cp_binding_level *b = current_binding_level;
4883 if (purpose_member (name, b->type_shadowed))
4885 t = REAL_IDENTIFIER_TYPE_VALUE (name);
4888 if (b->kind == sk_cleanup)
4895 timevar_stop (TV_NAME_LOOKUP);
4899 /* [basic.lookup.koenig] */
4900 /* A nonzero return value in the functions below indicates an error. */
4906 VEC(tree,gc) *namespaces;
4907 VEC(tree,gc) *classes;
4909 struct pointer_set_t *fn_set;
4912 static bool arg_assoc (struct arg_lookup*, tree);
4913 static bool arg_assoc_args (struct arg_lookup*, tree);
4914 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4915 static bool arg_assoc_type (struct arg_lookup*, tree);
4916 static bool add_function (struct arg_lookup *, tree);
4917 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4918 static bool arg_assoc_class_only (struct arg_lookup *, tree);
4919 static bool arg_assoc_bases (struct arg_lookup *, tree);
4920 static bool arg_assoc_class (struct arg_lookup *, tree);
4921 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4923 /* Add a function to the lookup structure.
4924 Returns true on error. */
4927 add_function (struct arg_lookup *k, tree fn)
4929 if (!is_overloaded_fn (fn))
4930 /* All names except those of (possibly overloaded) functions and
4931 function templates are ignored. */;
4932 else if (k->fn_set && pointer_set_insert (k->fn_set, fn))
4933 /* It's already in the list. */;
4934 else if (!k->functions)
4936 else if (fn == k->functions)
4940 k->functions = build_overload (fn, k->functions);
4941 if (TREE_CODE (k->functions) == OVERLOAD)
4942 OVL_ARG_DEPENDENT (k->functions) = true;
4948 /* Returns true iff CURRENT has declared itself to be an associated
4949 namespace of SCOPE via a strong using-directive (or transitive chain
4950 thereof). Both are namespaces. */
4953 is_associated_namespace (tree current, tree scope)
4955 VEC(tree,gc) *seen = make_tree_vector ();
4956 VEC(tree,gc) *todo = make_tree_vector ();
4962 if (scope == current)
4967 VEC_safe_push (tree, gc, seen, scope);
4968 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4969 if (!vec_member (TREE_PURPOSE (t), seen))
4970 VEC_safe_push (tree, gc, todo, TREE_PURPOSE (t));
4971 if (!VEC_empty (tree, todo))
4973 scope = VEC_last (tree, todo);
4974 VEC_pop (tree, todo);
4983 release_tree_vector (seen);
4984 release_tree_vector (todo);
4989 /* Add functions of a namespace to the lookup structure.
4990 Returns true on error. */
4993 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4997 if (vec_member (scope, k->namespaces))
4999 VEC_safe_push (tree, gc, k->namespaces, scope);
5001 /* Check out our super-users. */
5002 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
5003 value = TREE_CHAIN (value))
5004 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
5007 /* Also look down into inline namespaces. */
5008 for (value = DECL_NAMESPACE_USING (scope); value;
5009 value = TREE_CHAIN (value))
5010 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
5011 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
5014 value = namespace_binding (k->name, scope);
5018 for (; value; value = OVL_NEXT (value))
5020 /* We don't want to find arbitrary hidden functions via argument
5021 dependent lookup. We only want to find friends of associated
5022 classes, which we'll do via arg_assoc_class. */
5023 if (hidden_name_p (OVL_CURRENT (value)))
5026 if (add_function (k, OVL_CURRENT (value)))
5033 /* Adds everything associated with a template argument to the lookup
5034 structure. Returns true on error. */
5037 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
5039 /* [basic.lookup.koenig]
5041 If T is a template-id, its associated namespaces and classes are
5042 ... the namespaces and classes associated with the types of the
5043 template arguments provided for template type parameters
5044 (excluding template template parameters); the namespaces in which
5045 any template template arguments are defined; and the classes in
5046 which any member templates used as template template arguments
5047 are defined. [Note: non-type template arguments do not
5048 contribute to the set of associated namespaces. ] */
5050 /* Consider first template template arguments. */
5051 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5052 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
5054 else if (TREE_CODE (arg) == TEMPLATE_DECL)
5056 tree ctx = CP_DECL_CONTEXT (arg);
5058 /* It's not a member template. */
5059 if (TREE_CODE (ctx) == NAMESPACE_DECL)
5060 return arg_assoc_namespace (k, ctx);
5061 /* Otherwise, it must be member template. */
5063 return arg_assoc_class_only (k, ctx);
5065 /* It's an argument pack; handle it recursively. */
5066 else if (ARGUMENT_PACK_P (arg))
5068 tree args = ARGUMENT_PACK_ARGS (arg);
5069 int i, len = TREE_VEC_LENGTH (args);
5070 for (i = 0; i < len; ++i)
5071 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
5076 /* It's not a template template argument, but it is a type template
5078 else if (TYPE_P (arg))
5079 return arg_assoc_type (k, arg);
5080 /* It's a non-type template argument. */
5085 /* Adds the class and its friends to the lookup structure.
5086 Returns true on error. */
5089 arg_assoc_class_only (struct arg_lookup *k, tree type)
5091 tree list, friends, context;
5093 /* Backend-built structures, such as __builtin_va_list, aren't
5094 affected by all this. */
5095 if (!CLASS_TYPE_P (type))
5098 context = decl_namespace_context (type);
5099 if (arg_assoc_namespace (k, context))
5102 complete_type (type);
5104 /* Process friends. */
5105 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
5106 list = TREE_CHAIN (list))
5107 if (k->name == FRIEND_NAME (list))
5108 for (friends = FRIEND_DECLS (list); friends;
5109 friends = TREE_CHAIN (friends))
5111 tree fn = TREE_VALUE (friends);
5113 /* Only interested in global functions with potentially hidden
5114 (i.e. unqualified) declarations. */
5115 if (CP_DECL_CONTEXT (fn) != context)
5117 /* Template specializations are never found by name lookup.
5118 (Templates themselves can be found, but not template
5119 specializations.) */
5120 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
5122 if (add_function (k, fn))
5129 /* Adds the class and its bases to the lookup structure.
5130 Returns true on error. */
5133 arg_assoc_bases (struct arg_lookup *k, tree type)
5135 if (arg_assoc_class_only (k, type))
5138 if (TYPE_BINFO (type))
5140 /* Process baseclasses. */
5141 tree binfo, base_binfo;
5144 for (binfo = TYPE_BINFO (type), i = 0;
5145 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5146 if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
5153 /* Adds everything associated with a class argument type to the lookup
5154 structure. Returns true on error.
5156 If T is a class type (including unions), its associated classes are: the
5157 class itself; the class of which it is a member, if any; and its direct
5158 and indirect base classes. Its associated namespaces are the namespaces
5159 of which its associated classes are members. Furthermore, if T is a
5160 class template specialization, its associated namespaces and classes
5161 also include: the namespaces and classes associated with the types of
5162 the template arguments provided for template type parameters (excluding
5163 template template parameters); the namespaces of which any template
5164 template arguments are members; and the classes of which any member
5165 templates used as template template arguments are members. [ Note:
5166 non-type template arguments do not contribute to the set of associated
5167 namespaces. --end note] */
5170 arg_assoc_class (struct arg_lookup *k, tree type)
5175 /* Backend build structures, such as __builtin_va_list, aren't
5176 affected by all this. */
5177 if (!CLASS_TYPE_P (type))
5180 if (vec_member (type, k->classes))
5182 VEC_safe_push (tree, gc, k->classes, type);
5184 if (TYPE_CLASS_SCOPE_P (type)
5185 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5188 if (arg_assoc_bases (k, type))
5191 /* Process template arguments. */
5192 if (CLASSTYPE_TEMPLATE_INFO (type)
5193 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
5195 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
5196 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
5197 if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
5204 /* Adds everything associated with a given type.
5205 Returns 1 on error. */
5208 arg_assoc_type (struct arg_lookup *k, tree type)
5210 /* As we do not get the type of non-type dependent expressions
5211 right, we can end up with such things without a type. */
5215 if (TYPE_PTRMEM_P (type))
5217 /* Pointer to member: associate class type and value type. */
5218 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
5220 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
5222 else switch (TREE_CODE (type))
5232 case FIXED_POINT_TYPE:
5237 if (TYPE_PTRMEMFUNC_P (type))
5238 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
5240 return arg_assoc_class (k, type);
5242 case REFERENCE_TYPE:
5244 return arg_assoc_type (k, TREE_TYPE (type));
5246 if (TYPE_CLASS_SCOPE_P (type)
5247 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5249 return arg_assoc_namespace (k, decl_namespace_context (type));
5251 /* The basetype is referenced in the first arg type, so just
5254 /* Associate the parameter types. */
5255 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
5257 /* Associate the return type. */
5258 return arg_assoc_type (k, TREE_TYPE (type));
5259 case TEMPLATE_TYPE_PARM:
5260 case BOUND_TEMPLATE_TEMPLATE_PARM:
5265 gcc_assert (type == unknown_type_node
5266 || type == init_list_type_node);
5268 case TYPE_PACK_EXPANSION:
5269 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
5277 /* Adds everything associated with arguments. Returns true on error. */
5280 arg_assoc_args (struct arg_lookup *k, tree args)
5282 for (; args; args = TREE_CHAIN (args))
5283 if (arg_assoc (k, TREE_VALUE (args)))
5288 /* Adds everything associated with an argument vector. Returns true
5292 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
5297 FOR_EACH_VEC_ELT (tree, args, ix, arg)
5298 if (arg_assoc (k, arg))
5303 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5306 arg_assoc (struct arg_lookup *k, tree n)
5308 if (n == error_mark_node)
5312 return arg_assoc_type (k, n);
5314 if (! type_unknown_p (n))
5315 return arg_assoc_type (k, TREE_TYPE (n));
5317 if (TREE_CODE (n) == ADDR_EXPR)
5318 n = TREE_OPERAND (n, 0);
5319 if (TREE_CODE (n) == COMPONENT_REF)
5320 n = TREE_OPERAND (n, 1);
5321 if (TREE_CODE (n) == OFFSET_REF)
5322 n = TREE_OPERAND (n, 1);
5323 while (TREE_CODE (n) == TREE_LIST)
5325 if (TREE_CODE (n) == BASELINK)
5326 n = BASELINK_FUNCTIONS (n);
5328 if (TREE_CODE (n) == FUNCTION_DECL)
5329 return arg_assoc_type (k, TREE_TYPE (n));
5330 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
5332 /* The working paper doesn't currently say how to handle template-id
5333 arguments. The sensible thing would seem to be to handle the list
5334 of template candidates like a normal overload set, and handle the
5335 template arguments like we do for class template
5337 tree templ = TREE_OPERAND (n, 0);
5338 tree args = TREE_OPERAND (n, 1);
5341 /* First the templates. */
5342 if (arg_assoc (k, templ))
5345 /* Now the arguments. */
5347 for (ix = TREE_VEC_LENGTH (args); ix--;)
5348 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
5351 else if (TREE_CODE (n) == OVERLOAD)
5353 for (; n; n = OVL_NEXT (n))
5354 if (arg_assoc_type (k, TREE_TYPE (OVL_CURRENT (n))))
5361 /* Performs Koenig lookup depending on arguments, where fns
5362 are the functions found in normal lookup. */
5365 lookup_arg_dependent_1 (tree name, tree fns, VEC(tree,gc) *args,
5368 struct arg_lookup k;
5370 /* Remove any hidden friend functions from the list of functions
5371 found so far. They will be added back by arg_assoc_class as
5373 fns = remove_hidden_names (fns);
5378 k.classes = make_tree_vector ();
5380 /* We previously performed an optimization here by setting
5381 NAMESPACES to the current namespace when it was safe. However, DR
5382 164 says that namespaces that were already searched in the first
5383 stage of template processing are searched again (potentially
5384 picking up later definitions) in the second stage. */
5385 k.namespaces = make_tree_vector ();
5387 /* We used to allow duplicates and let joust discard them, but
5388 since the above change for DR 164 we end up with duplicates of
5389 all the functions found by unqualified lookup. So keep track
5390 of which ones we've seen. */
5394 /* We shouldn't be here if lookup found something other than
5395 namespace-scope functions. */
5396 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns)));
5397 k.fn_set = pointer_set_create ();
5398 for (ovl = fns; ovl; ovl = OVL_NEXT (ovl))
5399 pointer_set_insert (k.fn_set, OVL_CURRENT (ovl));
5405 arg_assoc_namespace (&k, std_node);
5406 arg_assoc_args_vec (&k, args);
5411 && TREE_CODE (fns) != VAR_DECL
5412 && !is_overloaded_fn (fns))
5414 error ("argument dependent lookup finds %q+D", fns);
5415 error (" in call to %qD", name);
5416 fns = error_mark_node;
5419 release_tree_vector (k.classes);
5420 release_tree_vector (k.namespaces);
5422 pointer_set_destroy (k.fn_set);
5427 /* Wrapper for lookup_arg_dependent_1. */
5430 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
5434 timevar_start (TV_NAME_LOOKUP);
5435 ret = lookup_arg_dependent_1 (name, fns, args, include_std);
5436 timevar_stop (TV_NAME_LOOKUP);
5441 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5442 changed (i.e. there was already a directive), or the fresh
5443 TREE_LIST otherwise. */
5446 push_using_directive_1 (tree used)
5448 tree ud = current_binding_level->using_directives;
5449 tree iter, ancestor;
5451 /* Check if we already have this. */
5452 if (purpose_member (used, ud) != NULL_TREE)
5455 ancestor = namespace_ancestor (current_decl_namespace (), used);
5456 ud = current_binding_level->using_directives;
5457 ud = tree_cons (used, ancestor, ud);
5458 current_binding_level->using_directives = ud;
5460 /* Recursively add all namespaces used. */
5461 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5462 push_using_directive (TREE_PURPOSE (iter));
5467 /* Wrapper for push_using_directive_1. */
5470 push_using_directive (tree used)
5473 timevar_start (TV_NAME_LOOKUP);
5474 ret = push_using_directive_1 (used);
5475 timevar_stop (TV_NAME_LOOKUP);
5479 /* The type TYPE is being declared. If it is a class template, or a
5480 specialization of a class template, do any processing required and
5481 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5482 being declared a friend. B is the binding level at which this TYPE
5485 Returns the TYPE_DECL for TYPE, which may have been altered by this
5489 maybe_process_template_type_declaration (tree type, int is_friend,
5490 cp_binding_level *b)
5492 tree decl = TYPE_NAME (type);
5494 if (processing_template_parmlist)
5495 /* You can't declare a new template type in a template parameter
5496 list. But, you can declare a non-template type:
5498 template <class A*> struct S;
5500 is a forward-declaration of `A'. */
5502 else if (b->kind == sk_namespace
5503 && current_binding_level->kind != sk_namespace)
5504 /* If this new type is being injected into a containing scope,
5505 then it's not a template type. */
5509 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5510 || TREE_CODE (type) == ENUMERAL_TYPE);
5512 if (processing_template_decl)
5514 /* This may change after the call to
5515 push_template_decl_real, but we want the original value. */
5516 tree name = DECL_NAME (decl);
5518 decl = push_template_decl_real (decl, is_friend);
5519 if (decl == error_mark_node)
5520 return error_mark_node;
5522 /* If the current binding level is the binding level for the
5523 template parameters (see the comment in
5524 begin_template_parm_list) and the enclosing level is a class
5525 scope, and we're not looking at a friend, push the
5526 declaration of the member class into the class scope. In the
5527 friend case, push_template_decl will already have put the
5528 friend into global scope, if appropriate. */
5529 if (TREE_CODE (type) != ENUMERAL_TYPE
5530 && !is_friend && b->kind == sk_template_parms
5531 && b->level_chain->kind == sk_class)
5533 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5535 if (!COMPLETE_TYPE_P (current_class_type))
5537 maybe_add_class_template_decl_list (current_class_type,
5538 type, /*friend_p=*/0);
5539 /* Put this UTD in the table of UTDs for the class. */
5540 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5541 CLASSTYPE_NESTED_UTDS (current_class_type) =
5542 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5544 binding_table_insert
5545 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5554 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5555 that the NAME is a class template, the tag is processed but not pushed.
5557 The pushed scope depend on the SCOPE parameter:
5558 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5560 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5561 non-template-parameter scope. This case is needed for forward
5563 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5564 TS_GLOBAL case except that names within template-parameter scopes
5565 are not pushed at all.
5567 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5570 pushtag_1 (tree name, tree type, tag_scope scope)
5572 cp_binding_level *b;
5575 b = current_binding_level;
5576 while (/* Cleanup scopes are not scopes from the point of view of
5578 b->kind == sk_cleanup
5579 /* Neither are function parameter scopes. */
5580 || b->kind == sk_function_parms
5581 /* Neither are the scopes used to hold template parameters
5582 for an explicit specialization. For an ordinary template
5583 declaration, these scopes are not scopes from the point of
5584 view of the language. */
5585 || (b->kind == sk_template_parms
5586 && (b->explicit_spec_p || scope == ts_global))
5587 || (b->kind == sk_class
5588 && (scope != ts_current
5589 /* We may be defining a new type in the initializer
5590 of a static member variable. We allow this when
5591 not pedantic, and it is particularly useful for
5592 type punning via an anonymous union. */
5593 || COMPLETE_TYPE_P (b->this_entity))))
5596 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5598 /* Do C++ gratuitous typedefing. */
5599 if (identifier_type_value_1 (name) != type)
5603 tree context = TYPE_CONTEXT (type);
5607 tree cs = current_scope ();
5609 if (scope == ts_current
5610 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5612 else if (cs != NULL_TREE && TYPE_P (cs))
5613 /* When declaring a friend class of a local class, we want
5614 to inject the newly named class into the scope
5615 containing the local class, not the namespace
5617 context = decl_function_context (get_type_decl (cs));
5620 context = current_namespace;
5622 if (b->kind == sk_class
5623 || (b->kind == sk_template_parms
5624 && b->level_chain->kind == sk_class))
5627 if (current_lang_name == lang_name_java)
5628 TYPE_FOR_JAVA (type) = 1;
5630 tdef = create_implicit_typedef (name, type);
5631 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5632 if (scope == ts_within_enclosing_non_class)
5634 /* This is a friend. Make this TYPE_DECL node hidden from
5635 ordinary name lookup. Its corresponding TEMPLATE_DECL
5636 will be marked in push_template_decl_real. */
5637 retrofit_lang_decl (tdef);
5638 DECL_ANTICIPATED (tdef) = 1;
5639 DECL_FRIEND_P (tdef) = 1;
5642 decl = maybe_process_template_type_declaration
5643 (type, scope == ts_within_enclosing_non_class, b);
5644 if (decl == error_mark_node)
5647 if (b->kind == sk_class)
5649 if (!TYPE_BEING_DEFINED (current_class_type))
5650 return error_mark_node;
5652 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5653 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5654 class. But if it's a member template class, we want
5655 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5657 finish_member_declaration (decl);
5659 pushdecl_class_level (decl);
5661 else if (b->kind != sk_template_parms)
5663 decl = pushdecl_with_scope_1 (decl, b, /*is_friend=*/false);
5664 if (decl == error_mark_node)
5669 set_identifier_type_value_with_scope (name, tdef, b);
5671 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5673 /* If this is a local class, keep track of it. We need this
5674 information for name-mangling, and so that it is possible to
5675 find all function definitions in a translation unit in a
5676 convenient way. (It's otherwise tricky to find a member
5677 function definition it's only pointed to from within a local
5679 if (TYPE_CONTEXT (type)
5680 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5681 VEC_safe_push (tree, gc, local_classes, type);
5683 if (b->kind == sk_class
5684 && !COMPLETE_TYPE_P (current_class_type))
5686 maybe_add_class_template_decl_list (current_class_type,
5687 type, /*friend_p=*/0);
5689 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5690 CLASSTYPE_NESTED_UTDS (current_class_type)
5691 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5693 binding_table_insert
5694 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5697 decl = TYPE_NAME (type);
5698 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5700 /* Set type visibility now if this is a forward declaration. */
5701 TREE_PUBLIC (decl) = 1;
5702 determine_visibility (decl);
5707 /* Wrapper for pushtag_1. */
5710 pushtag (tree name, tree type, tag_scope scope)
5713 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5714 ret = pushtag_1 (name, type, scope);
5715 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5719 /* Subroutines for reverting temporarily to top-level for instantiation
5720 of templates and such. We actually need to clear out the class- and
5721 local-value slots of all identifiers, so that only the global values
5722 are at all visible. Simply setting current_binding_level to the global
5723 scope isn't enough, because more binding levels may be pushed. */
5724 struct saved_scope *scope_chain;
5726 /* If ID has not already been marked, add an appropriate binding to
5730 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5732 cxx_saved_binding *saved;
5734 if (!id || !IDENTIFIER_BINDING (id))
5737 if (IDENTIFIER_MARKED (id))
5740 IDENTIFIER_MARKED (id) = 1;
5742 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5743 saved->identifier = id;
5744 saved->binding = IDENTIFIER_BINDING (id);
5745 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5746 IDENTIFIER_BINDING (id) = NULL;
5750 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5754 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5755 for (t = names; t; t = TREE_CHAIN (t))
5759 if (TREE_CODE (t) == TREE_LIST)
5760 id = TREE_PURPOSE (t);
5764 store_binding (id, old_bindings);
5766 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5769 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5770 objects, rather than a TREE_LIST. */
5773 store_class_bindings (VEC(cp_class_binding,gc) *names,
5774 VEC(cxx_saved_binding,gc) **old_bindings)
5777 cp_class_binding *cb;
5779 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5780 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5781 store_binding (cb->identifier, old_bindings);
5782 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5786 push_to_top_level (void)
5788 struct saved_scope *s;
5789 cp_binding_level *b;
5790 cxx_saved_binding *sb;
5794 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5795 s = ggc_alloc_cleared_saved_scope ();
5797 b = scope_chain ? current_binding_level : 0;
5799 /* If we're in the middle of some function, save our state. */
5803 push_function_context ();
5808 if (scope_chain && previous_class_level)
5809 store_class_bindings (previous_class_level->class_shadowed,
5812 /* Have to include the global scope, because class-scope decls
5813 aren't listed anywhere useful. */
5814 for (; b; b = b->level_chain)
5818 /* Template IDs are inserted into the global level. If they were
5819 inserted into namespace level, finish_file wouldn't find them
5820 when doing pending instantiations. Therefore, don't stop at
5821 namespace level, but continue until :: . */
5822 if (global_scope_p (b))
5825 store_bindings (b->names, &s->old_bindings);
5826 /* We also need to check class_shadowed to save class-level type
5827 bindings, since pushclass doesn't fill in b->names. */
5828 if (b->kind == sk_class)
5829 store_class_bindings (b->class_shadowed, &s->old_bindings);
5831 /* Unwind type-value slots back to top level. */
5832 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5833 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5836 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, sb)
5837 IDENTIFIER_MARKED (sb->identifier) = 0;
5839 s->prev = scope_chain;
5841 s->need_pop_function_context = need_pop;
5842 s->function_decl = current_function_decl;
5843 s->unevaluated_operand = cp_unevaluated_operand;
5844 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5847 current_function_decl = NULL_TREE;
5848 current_lang_base = VEC_alloc (tree, gc, 10);
5849 current_lang_name = lang_name_cplusplus;
5850 current_namespace = global_namespace;
5851 push_class_stack ();
5852 cp_unevaluated_operand = 0;
5853 c_inhibit_evaluation_warnings = 0;
5854 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5858 pop_from_top_level_1 (void)
5860 struct saved_scope *s = scope_chain;
5861 cxx_saved_binding *saved;
5864 /* Clear out class-level bindings cache. */
5865 if (previous_class_level)
5866 invalidate_class_lookup_cache ();
5869 current_lang_base = 0;
5871 scope_chain = s->prev;
5872 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, saved)
5874 tree id = saved->identifier;
5876 IDENTIFIER_BINDING (id) = saved->binding;
5877 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5880 /* If we were in the middle of compiling a function, restore our
5882 if (s->need_pop_function_context)
5883 pop_function_context ();
5884 current_function_decl = s->function_decl;
5885 cp_unevaluated_operand = s->unevaluated_operand;
5886 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5889 /* Wrapper for pop_from_top_level_1. */
5892 pop_from_top_level (void)
5894 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5895 pop_from_top_level_1 ();
5896 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5900 /* Pop off extraneous binding levels left over due to syntax errors.
5902 We don't pop past namespaces, as they might be valid. */
5905 pop_everything (void)
5907 if (ENABLE_SCOPE_CHECKING)
5908 verbatim ("XXX entering pop_everything ()\n");
5909 while (!toplevel_bindings_p ())
5911 if (current_binding_level->kind == sk_class)
5912 pop_nested_class ();
5916 if (ENABLE_SCOPE_CHECKING)
5917 verbatim ("XXX leaving pop_everything ()\n");
5920 /* Emit debugging information for using declarations and directives.
5921 If input tree is overloaded fn then emit debug info for all
5925 cp_emit_debug_info_for_using (tree t, tree context)
5927 /* Don't try to emit any debug information if we have errors. */
5931 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5932 of a builtin function. */
5933 if (TREE_CODE (t) == FUNCTION_DECL
5934 && DECL_EXTERNAL (t)
5935 && DECL_BUILT_IN (t))
5938 /* Do not supply context to imported_module_or_decl, if
5939 it is a global namespace. */
5940 if (context == global_namespace)
5941 context = NULL_TREE;
5944 t = BASELINK_FUNCTIONS (t);
5946 /* FIXME: Handle TEMPLATE_DECLs. */
5947 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5948 if (TREE_CODE (t) != TEMPLATE_DECL)
5950 if (building_stmt_list_p ())
5951 add_stmt (build_stmt (input_location, USING_STMT, t));
5953 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5957 #include "gt-cp-name-lookup.h"