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"
37 /* The bindings for a particular name in a particular scope. */
39 struct scope_binding {
43 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
45 static cxx_scope *innermost_nonclass_level (void);
46 static cxx_binding *binding_for_name (cxx_scope *, tree);
47 static tree push_overloaded_decl (tree, int, bool);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
54 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
56 /* The :: namespace. */
58 tree global_namespace;
60 /* The name of the anonymous namespace, throughout this translation
62 static GTY(()) tree anonymous_namespace_name;
64 /* Initialize anonymous_namespace_name if necessary, and return it. */
67 get_anonymous_namespace_name (void)
69 if (!anonymous_namespace_name)
71 /* The anonymous namespace has to have a unique name
72 if typeinfo objects are being compared by name. */
73 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
74 anonymous_namespace_name = get_file_function_name ("N");
76 /* The demangler expects anonymous namespaces to be called
77 something starting with '_GLOBAL__N_'. */
78 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
80 return anonymous_namespace_name;
83 /* Compute the chain index of a binding_entry given the HASH value of its
84 name and the total COUNT of chains. COUNT is assumed to be a power
87 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
89 /* A free list of "binding_entry"s awaiting for re-use. */
91 static GTY((deletable)) binding_entry free_binding_entry = NULL;
93 /* Create a binding_entry object for (NAME, TYPE). */
95 static inline binding_entry
96 binding_entry_make (tree name, tree type)
100 if (free_binding_entry)
102 entry = free_binding_entry;
103 free_binding_entry = entry->chain;
106 entry = ggc_alloc_binding_entry_s ();
115 /* Put ENTRY back on the free list. */
118 binding_entry_free (binding_entry entry)
122 entry->chain = free_binding_entry;
123 free_binding_entry = entry;
127 /* The datatype used to implement the mapping from names to types at
129 struct GTY(()) binding_table_s {
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = ggc_alloc_binding_table_s ();
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = ggc_alloc_cxx_binding ();
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
324 cb->identifier = name;
325 cb->base = binding = cxx_binding_make (value, type);
326 binding->scope = scope;
330 /* Make DECL the innermost binding for ID. The LEVEL is the binding
331 level at which this declaration is being bound. */
334 push_binding (tree id, tree decl, cxx_scope* level)
336 cxx_binding *binding;
338 if (level != class_binding_level)
340 binding = cxx_binding_make (decl, NULL_TREE);
341 binding->scope = level;
344 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
346 /* Now, fill in the binding information. */
347 binding->previous = IDENTIFIER_BINDING (id);
348 INHERITED_VALUE_BINDING_P (binding) = 0;
349 LOCAL_BINDING_P (binding) = (level != class_binding_level);
351 /* And put it on the front of the list of bindings for ID. */
352 IDENTIFIER_BINDING (id) = binding;
355 /* Remove the binding for DECL which should be the innermost binding
359 pop_binding (tree id, tree decl)
361 cxx_binding *binding;
364 /* It's easiest to write the loops that call this function without
365 checking whether or not the entities involved have names. We
366 get here for such an entity. */
369 /* Get the innermost binding for ID. */
370 binding = IDENTIFIER_BINDING (id);
372 /* The name should be bound. */
373 gcc_assert (binding != NULL);
375 /* The DECL will be either the ordinary binding or the type
376 binding for this identifier. Remove that binding. */
377 if (binding->value == decl)
378 binding->value = NULL_TREE;
381 gcc_assert (binding->type == decl);
382 binding->type = NULL_TREE;
385 if (!binding->value && !binding->type)
387 /* We're completely done with the innermost binding for this
388 identifier. Unhook it from the list of bindings. */
389 IDENTIFIER_BINDING (id) = binding->previous;
391 /* Add it to the free list. */
392 cxx_binding_free (binding);
396 /* BINDING records an existing declaration for a name in the current scope.
397 But, DECL is another declaration for that same identifier in the
398 same scope. This is the `struct stat' hack whereby a non-typedef
399 class name or enum-name can be bound at the same level as some other
403 A class name (9.1) or enumeration name (7.2) can be hidden by the
404 name of an object, function, or enumerator declared in the same scope.
405 If a class or enumeration name and an object, function, or enumerator
406 are declared in the same scope (in any order) with the same name, the
407 class or enumeration name is hidden wherever the object, function, or
408 enumerator name is visible.
410 It's the responsibility of the caller to check that
411 inserting this name is valid here. Returns nonzero if the new binding
415 supplement_binding_1 (cxx_binding *binding, tree decl)
417 tree bval = binding->value;
420 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
421 /* The new name is the type name. */
422 binding->type = decl;
423 else if (/* BVAL is null when push_class_level_binding moves an
424 inherited type-binding out of the way to make room for a
425 new value binding. */
427 /* BVAL is error_mark_node when DECL's name has been used
428 in a non-class scope prior declaration. In that case,
429 we should have already issued a diagnostic; for graceful
430 error recovery purpose, pretend this was the intended
431 declaration for that name. */
432 || bval == error_mark_node
433 /* If BVAL is anticipated but has not yet been declared,
434 pretend it is not there at all. */
435 || (TREE_CODE (bval) == FUNCTION_DECL
436 && DECL_ANTICIPATED (bval)
437 && !DECL_HIDDEN_FRIEND_P (bval)))
438 binding->value = decl;
439 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
440 && (TREE_CODE (decl) != TYPE_DECL
441 || same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))))
443 /* The old binding was a type name. It was placed in
444 VALUE field because it was thought, at the point it was
445 declared, to be the only entity with such a name. Move the
446 type name into the type slot; it is now hidden by the new
448 binding->type = bval;
449 binding->value = decl;
450 binding->value_is_inherited = false;
452 else if (TREE_CODE (bval) == TYPE_DECL
453 && TREE_CODE (decl) == TYPE_DECL
454 && DECL_NAME (decl) == DECL_NAME (bval)
455 && binding->scope->kind != sk_class
456 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
457 /* If either type involves template parameters, we must
458 wait until instantiation. */
459 || uses_template_parms (TREE_TYPE (decl))
460 || uses_template_parms (TREE_TYPE (bval))))
461 /* We have two typedef-names, both naming the same type to have
462 the same name. In general, this is OK because of:
466 In a given scope, a typedef specifier can be used to redefine
467 the name of any type declared in that scope to refer to the
468 type to which it already refers.
470 However, in class scopes, this rule does not apply due to the
471 stricter language in [class.mem] prohibiting redeclarations of
474 /* There can be two block-scope declarations of the same variable,
475 so long as they are `extern' declarations. However, there cannot
476 be two declarations of the same static data member:
480 A member shall not be declared twice in the
481 member-specification. */
482 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
483 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
484 && !DECL_CLASS_SCOPE_P (decl))
486 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
489 else if (TREE_CODE (decl) == NAMESPACE_DECL
490 && TREE_CODE (bval) == NAMESPACE_DECL
491 && DECL_NAMESPACE_ALIAS (decl)
492 && DECL_NAMESPACE_ALIAS (bval)
493 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
496 In a declarative region, a namespace-alias-definition can be
497 used to redefine a namespace-alias declared in that declarative
498 region to refer only to the namespace to which it already
503 error ("declaration of %q#D", decl);
504 error ("conflicts with previous declaration %q+#D", bval);
511 /* Wrapper for supplement_binding_1. */
514 supplement_binding (cxx_binding *binding, tree decl)
517 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
518 ret = supplement_binding_1 (binding, decl);
519 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
523 /* Add DECL to the list of things declared in B. */
526 add_decl_to_level (tree decl, cxx_scope *b)
528 /* We used to record virtual tables as if they were ordinary
529 variables, but no longer do so. */
530 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
532 if (TREE_CODE (decl) == NAMESPACE_DECL
533 && !DECL_NAMESPACE_ALIAS (decl))
535 DECL_CHAIN (decl) = b->namespaces;
536 b->namespaces = decl;
540 /* We build up the list in reverse order, and reverse it later if
542 TREE_CHAIN (decl) = b->names;
546 /* If appropriate, add decl to separate list of statics. We
547 include extern variables because they might turn out to be
548 static later. It's OK for this list to contain a few false
550 if (b->kind == sk_namespace)
551 if ((TREE_CODE (decl) == VAR_DECL
552 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
553 || (TREE_CODE (decl) == FUNCTION_DECL
554 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
555 VEC_safe_push (tree, gc, b->static_decls, decl);
559 /* Record a decl-node X as belonging to the current lexical scope.
560 Check for errors (such as an incompatible declaration for the same
561 name already seen in the same scope). IS_FRIEND is true if X is
562 declared as a friend.
564 Returns either X or an old decl for the same name.
565 If an old decl is returned, it may have been smashed
566 to agree with what X says. */
569 pushdecl_maybe_friend_1 (tree x, bool is_friend)
573 int need_new_binding;
575 if (x == error_mark_node)
576 return error_mark_node;
578 need_new_binding = 1;
580 if (DECL_TEMPLATE_PARM_P (x))
581 /* Template parameters have no context; they are not X::T even
582 when declared within a class or namespace. */
586 if (current_function_decl && x != current_function_decl
587 /* A local declaration for a function doesn't constitute
589 && TREE_CODE (x) != FUNCTION_DECL
590 /* A local declaration for an `extern' variable is in the
591 scope of the current namespace, not the current
593 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
594 /* When parsing the parameter list of a function declarator,
595 don't set DECL_CONTEXT to an enclosing function. When we
596 push the PARM_DECLs in order to process the function body,
597 current_binding_level->this_entity will be set. */
598 && !(TREE_CODE (x) == PARM_DECL
599 && current_binding_level->kind == sk_function_parms
600 && current_binding_level->this_entity == NULL)
601 && !DECL_CONTEXT (x))
602 DECL_CONTEXT (x) = current_function_decl;
604 /* If this is the declaration for a namespace-scope function,
605 but the declaration itself is in a local scope, mark the
607 if (TREE_CODE (x) == FUNCTION_DECL
608 && DECL_NAMESPACE_SCOPE_P (x)
609 && current_function_decl
610 && x != current_function_decl)
611 DECL_LOCAL_FUNCTION_P (x) = 1;
614 name = DECL_NAME (x);
617 int different_binding_level = 0;
619 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
620 name = TREE_OPERAND (name, 0);
622 /* In case this decl was explicitly namespace-qualified, look it
623 up in its namespace context. */
624 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
625 t = namespace_binding (name, DECL_CONTEXT (x));
627 t = lookup_name_innermost_nonclass_level (name);
629 /* [basic.link] If there is a visible declaration of an entity
630 with linkage having the same name and type, ignoring entities
631 declared outside the innermost enclosing namespace scope, the
632 block scope declaration declares that same entity and
633 receives the linkage of the previous declaration. */
634 if (! t && current_function_decl && x != current_function_decl
635 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
636 && DECL_EXTERNAL (x))
638 /* Look in block scope. */
639 t = innermost_non_namespace_value (name);
640 /* Or in the innermost namespace. */
642 t = namespace_binding (name, DECL_CONTEXT (x));
643 /* Does it have linkage? Note that if this isn't a DECL, it's an
644 OVERLOAD, which is OK. */
645 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
648 different_binding_level = 1;
651 /* If we are declaring a function, and the result of name-lookup
652 was an OVERLOAD, look for an overloaded instance that is
653 actually the same as the function we are declaring. (If
654 there is one, we have to merge our declaration with the
655 previous declaration.) */
656 if (t && TREE_CODE (t) == OVERLOAD)
660 if (TREE_CODE (x) == FUNCTION_DECL)
661 for (match = t; match; match = OVL_NEXT (match))
663 if (decls_match (OVL_CURRENT (match), x))
667 /* Just choose one. */
671 t = OVL_CURRENT (match);
676 if (t && t != error_mark_node)
678 if (different_binding_level)
680 if (decls_match (x, t))
681 /* The standard only says that the local extern
682 inherits linkage from the previous decl; in
683 particular, default args are not shared. Add
684 the decl into a hash table to make sure only
685 the previous decl in this case is seen by the
688 struct cxx_int_tree_map *h;
691 TREE_PUBLIC (x) = TREE_PUBLIC (t);
693 if (cp_function_chain->extern_decl_map == NULL)
694 cp_function_chain->extern_decl_map
695 = htab_create_ggc (20, cxx_int_tree_map_hash,
696 cxx_int_tree_map_eq, NULL);
698 h = ggc_alloc_cxx_int_tree_map ();
699 h->uid = DECL_UID (x);
701 loc = htab_find_slot_with_hash
702 (cp_function_chain->extern_decl_map, h,
704 *(struct cxx_int_tree_map **) loc = h;
707 else if (TREE_CODE (t) == PARM_DECL)
709 /* Check for duplicate params. */
710 tree d = duplicate_decls (x, t, is_friend);
714 else if ((DECL_EXTERN_C_FUNCTION_P (x)
715 || DECL_FUNCTION_TEMPLATE_P (x))
716 && is_overloaded_fn (t))
717 /* Don't do anything just yet. */;
718 else if (t == wchar_decl_node)
720 if (! DECL_IN_SYSTEM_HEADER (x))
721 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
724 /* Throw away the redeclaration. */
729 tree olddecl = duplicate_decls (x, t, is_friend);
731 /* If the redeclaration failed, we can stop at this
733 if (olddecl == error_mark_node)
734 return error_mark_node;
738 if (TREE_CODE (t) == TYPE_DECL)
739 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
743 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
745 /* A redeclaration of main, but not a duplicate of the
750 This function shall not be overloaded. */
751 error ("invalid redeclaration of %q+D", t);
753 /* We don't try to push this declaration since that
760 /* If x has C linkage-specification, (extern "C"),
761 lookup its binding, in case it's already bound to an object.
762 The lookup is done in all namespaces.
763 If we find an existing binding, make sure it has the same
764 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
765 if ((TREE_CODE (x) == FUNCTION_DECL)
766 && DECL_EXTERN_C_P (x)
767 /* We should ignore declarations happening in system headers. */
768 && !DECL_ARTIFICIAL (x)
769 && !DECL_IN_SYSTEM_HEADER (x))
771 cxx_binding *function_binding =
772 lookup_extern_c_fun_binding_in_all_ns (x);
773 tree previous = (function_binding
774 ? function_binding->value
777 && !DECL_ARTIFICIAL (previous)
778 && !DECL_IN_SYSTEM_HEADER (previous)
779 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
781 tree previous = function_binding->value;
783 /* In case either x or previous is declared to throw an exception,
784 make sure both exception specifications are equal. */
785 if (decls_match (x, previous))
787 tree x_exception_spec = NULL_TREE;
788 tree previous_exception_spec = NULL_TREE;
791 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
792 previous_exception_spec =
793 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
794 if (!comp_except_specs (previous_exception_spec,
798 pedwarn (input_location, 0,
799 "declaration of %q#D with C language linkage",
801 pedwarn (input_location, 0,
802 "conflicts with previous declaration %q+#D",
804 pedwarn (input_location, 0,
805 "due to different exception specifications");
806 return error_mark_node;
811 pedwarn (input_location, 0,
812 "declaration of %q#D with C language linkage", x);
813 pedwarn (input_location, 0,
814 "conflicts with previous declaration %q+#D",
820 check_template_shadow (x);
822 /* If this is a function conjured up by the back end, massage it
823 so it looks friendly. */
824 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
826 retrofit_lang_decl (x);
827 SET_DECL_LANGUAGE (x, lang_c);
831 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
833 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
834 if (!namespace_bindings_p ())
835 /* We do not need to create a binding for this name;
836 push_overloaded_decl will have already done so if
838 need_new_binding = 0;
840 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
842 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
844 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
847 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
848 check_default_args (t);
850 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
853 /* If declaring a type as a typedef, copy the type (unless we're
854 at line 0), and install this TYPE_DECL as the new type's typedef
855 name. See the extensive comment of set_underlying_type (). */
856 if (TREE_CODE (x) == TYPE_DECL)
858 tree type = TREE_TYPE (x);
860 if (DECL_IS_BUILTIN (x)
861 || (TREE_TYPE (x) != error_mark_node
862 && TYPE_NAME (type) != x
863 /* We don't want to copy the type when all we're
864 doing is making a TYPE_DECL for the purposes of
866 && (!TYPE_NAME (type)
867 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
868 set_underlying_type (x);
870 if (type != error_mark_node
872 && TYPE_IDENTIFIER (type))
873 set_identifier_type_value (DECL_NAME (x), x);
876 /* Multiple external decls of the same identifier ought to match.
878 We get warnings about inline functions where they are defined.
879 We get warnings about other functions from push_overloaded_decl.
881 Avoid duplicate warnings where they are used. */
882 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
886 decl = IDENTIFIER_NAMESPACE_VALUE (name);
887 if (decl && TREE_CODE (decl) == OVERLOAD)
888 decl = OVL_FUNCTION (decl);
890 if (decl && decl != error_mark_node
891 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
892 /* If different sort of thing, we already gave an error. */
893 && TREE_CODE (decl) == TREE_CODE (x)
894 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
896 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
897 permerror (input_location, "previous external decl of %q+#D", decl);
901 if (TREE_CODE (x) == FUNCTION_DECL
903 && !flag_friend_injection)
905 /* This is a new declaration of a friend function, so hide
906 it from ordinary function lookup. */
907 DECL_ANTICIPATED (x) = 1;
908 DECL_HIDDEN_FRIEND_P (x) = 1;
911 /* This name is new in its binding level.
912 Install the new declaration and return it. */
913 if (namespace_bindings_p ())
915 /* Install a global value. */
917 /* If the first global decl has external linkage,
918 warn if we later see static one. */
919 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
920 TREE_PUBLIC (name) = 1;
922 /* Bind the name for the entity. */
923 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
925 && (TREE_CODE (x) == TYPE_DECL
926 || TREE_CODE (x) == VAR_DECL
927 || TREE_CODE (x) == NAMESPACE_DECL
928 || TREE_CODE (x) == CONST_DECL
929 || TREE_CODE (x) == TEMPLATE_DECL))
930 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
932 /* If new decl is `static' and an `extern' was seen previously,
934 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
935 warn_extern_redeclared_static (x, t);
939 /* Here to install a non-global value. */
940 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
941 tree oldlocal = NULL_TREE;
942 cxx_scope *oldscope = NULL;
943 cxx_binding *oldbinding = outer_binding (name, NULL, true);
946 oldlocal = oldbinding->value;
947 oldscope = oldbinding->scope;
950 if (need_new_binding)
952 push_local_binding (name, x, 0);
953 /* Because push_local_binding will hook X on to the
954 current_binding_level's name list, we don't want to
955 do that again below. */
956 need_new_binding = 0;
959 /* If this is a TYPE_DECL, push it into the type value slot. */
960 if (TREE_CODE (x) == TYPE_DECL)
961 set_identifier_type_value (name, x);
963 /* Clear out any TYPE_DECL shadowed by a namespace so that
964 we won't think this is a type. The C struct hack doesn't
965 go through namespaces. */
966 if (TREE_CODE (x) == NAMESPACE_DECL)
967 set_identifier_type_value (name, NULL_TREE);
974 && TREE_CODE (oldlocal) == VAR_DECL
975 && DECL_DEAD_FOR_LOCAL (oldlocal))
976 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
978 if (oldlocal == NULL_TREE)
979 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
982 /* If this is an extern function declaration, see if we
983 have a global definition or declaration for the function. */
984 if (oldlocal == NULL_TREE
986 && oldglobal != NULL_TREE
987 && TREE_CODE (x) == FUNCTION_DECL
988 && TREE_CODE (oldglobal) == FUNCTION_DECL)
990 /* We have one. Their types must agree. */
991 if (decls_match (x, oldglobal))
995 warning (0, "extern declaration of %q#D doesn%'t match", x);
996 warning (0, "global declaration %q+#D", oldglobal);
999 /* If we have a local external declaration,
1000 and no file-scope declaration has yet been seen,
1001 then if we later have a file-scope decl it must not be static. */
1002 if (oldlocal == NULL_TREE
1003 && oldglobal == NULL_TREE
1004 && DECL_EXTERNAL (x)
1006 TREE_PUBLIC (name) = 1;
1008 /* Don't complain about the parms we push and then pop
1009 while tentatively parsing a function declarator. */
1010 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1013 /* Warn if shadowing an argument at the top level of the body. */
1014 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1015 /* Inline decls shadow nothing. */
1016 && !DECL_FROM_INLINE (x)
1017 && (TREE_CODE (oldlocal) == PARM_DECL
1018 || TREE_CODE (oldlocal) == VAR_DECL
1019 /* If the old decl is a type decl, only warn if the
1020 old decl is an explicit typedef or if both the old
1021 and new decls are type decls. */
1022 || (TREE_CODE (oldlocal) == TYPE_DECL
1023 && (!DECL_ARTIFICIAL (oldlocal)
1024 || TREE_CODE (x) == TYPE_DECL)))
1025 /* Don't check the `this' parameter or internally generated
1026 vars unless it's an implicit typedef (see
1027 create_implicit_typedef in decl.c). */
1028 && (!DECL_ARTIFICIAL (oldlocal)
1029 || DECL_IMPLICIT_TYPEDEF_P (oldlocal))
1030 /* Don't check for internally generated vars unless
1031 it's an implicit typedef (see create_implicit_typedef
1033 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1035 bool nowarn = false;
1037 /* Don't complain if it's from an enclosing function. */
1038 if (DECL_CONTEXT (oldlocal) == current_function_decl
1039 && TREE_CODE (x) != PARM_DECL
1040 && TREE_CODE (oldlocal) == PARM_DECL)
1042 /* Go to where the parms should be and see if we find
1044 struct cp_binding_level *b = current_binding_level->level_chain;
1046 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1047 /* Skip the ctor/dtor cleanup level. */
1051 if (b->kind == sk_function_parms)
1053 error ("declaration of %q#D shadows a parameter", x);
1058 /* The local structure or class can't use parameters of
1059 the containing function anyway. */
1060 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1062 cxx_scope *scope = current_binding_level;
1063 tree context = DECL_CONTEXT (oldlocal);
1064 for (; scope; scope = scope->level_chain)
1066 if (scope->kind == sk_function_parms
1067 && scope->this_entity == context)
1069 if (scope->kind == sk_class
1070 && !LAMBDA_TYPE_P (scope->this_entity))
1077 /* Error if redeclaring a local declared in a
1078 for-init-statement or in the condition of an if or
1079 switch statement when the new declaration is in the
1080 outermost block of the controlled statement.
1081 Redeclaring a variable from a for or while condition is
1082 detected elsewhere. */
1083 else if (TREE_CODE (oldlocal) == VAR_DECL
1084 && oldscope == current_binding_level->level_chain
1085 && (oldscope->kind == sk_cond
1086 || oldscope->kind == sk_for))
1088 error ("redeclaration of %q#D", x);
1089 error ("%q+#D previously declared here", oldlocal);
1092 if (warn_shadow && !nowarn)
1094 if (TREE_CODE (oldlocal) == PARM_DECL)
1095 warning_at (input_location, OPT_Wshadow,
1096 "declaration of %q#D shadows a parameter", x);
1098 warning_at (input_location, OPT_Wshadow,
1099 "declaration of %qD shadows a previous local",
1101 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1102 "shadowed declaration is here");
1106 /* Maybe warn if shadowing something else. */
1107 else if (warn_shadow && !DECL_EXTERNAL (x)
1108 /* No shadow warnings for internally generated vars unless
1109 it's an implicit typedef (see create_implicit_typedef
1111 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1112 /* No shadow warnings for vars made for inlining. */
1113 && ! DECL_FROM_INLINE (x))
1117 if (current_class_ptr)
1118 member = lookup_member (current_class_type,
1121 /*want_type=*/false);
1125 if (member && !TREE_STATIC (member))
1127 /* Location of previous decl is not useful in this case. */
1128 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1131 else if (oldglobal != NULL_TREE
1132 && (TREE_CODE (oldglobal) == VAR_DECL
1133 /* If the old decl is a type decl, only warn if the
1134 old decl is an explicit typedef or if both the
1135 old and new decls are type decls. */
1136 || (TREE_CODE (oldglobal) == TYPE_DECL
1137 && (!DECL_ARTIFICIAL (oldglobal)
1138 || TREE_CODE (x) == TYPE_DECL))))
1139 /* XXX shadow warnings in outer-more namespaces */
1141 warning_at (input_location, OPT_Wshadow,
1142 "declaration of %qD shadows a global declaration", x);
1143 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1144 "shadowed declaration is here");
1149 if (TREE_CODE (x) == VAR_DECL)
1150 maybe_register_incomplete_var (x);
1153 if (need_new_binding)
1154 add_decl_to_level (x,
1155 DECL_NAMESPACE_SCOPE_P (x)
1156 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1157 : current_binding_level);
1162 /* Wrapper for pushdecl_maybe_friend_1. */
1165 pushdecl_maybe_friend (tree x, bool is_friend)
1168 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1169 ret = pushdecl_maybe_friend_1 (x, is_friend);
1170 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1174 /* Record a decl-node X as belonging to the current lexical scope. */
1179 return pushdecl_maybe_friend (x, false);
1182 /* Enter DECL into the symbol table, if that's appropriate. Returns
1183 DECL, or a modified version thereof. */
1186 maybe_push_decl (tree decl)
1188 tree type = TREE_TYPE (decl);
1190 /* Add this decl to the current binding level, but not if it comes
1191 from another scope, e.g. a static member variable. TEM may equal
1192 DECL or it may be a previous decl of the same name. */
1193 if (decl == error_mark_node
1194 || (TREE_CODE (decl) != PARM_DECL
1195 && DECL_CONTEXT (decl) != NULL_TREE
1196 /* Definitions of namespace members outside their namespace are
1198 && !DECL_NAMESPACE_SCOPE_P (decl))
1199 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1200 || type == unknown_type_node
1201 /* The declaration of a template specialization does not affect
1202 the functions available for overload resolution, so we do not
1204 || (TREE_CODE (decl) == FUNCTION_DECL
1205 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1208 return pushdecl (decl);
1211 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1212 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1213 doesn't really belong to this binding level, that it got here
1214 through a using-declaration. */
1217 push_local_binding (tree id, tree decl, int flags)
1219 struct cp_binding_level *b;
1221 /* Skip over any local classes. This makes sense if we call
1222 push_local_binding with a friend decl of a local class. */
1223 b = innermost_nonclass_level ();
1225 if (lookup_name_innermost_nonclass_level (id))
1227 /* Supplement the existing binding. */
1228 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1229 /* It didn't work. Something else must be bound at this
1230 level. Do not add DECL to the list of things to pop
1235 /* Create a new binding. */
1236 push_binding (id, decl, b);
1238 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1239 /* We must put the OVERLOAD into a TREE_LIST since the
1240 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1241 decls that got here through a using-declaration. */
1242 decl = build_tree_list (NULL_TREE, decl);
1244 /* And put DECL on the list of things declared by the current
1246 add_decl_to_level (decl, b);
1249 /* Check to see whether or not DECL is a variable that would have been
1250 in scope under the ARM, but is not in scope under the ANSI/ISO
1251 standard. If so, issue an error message. If name lookup would
1252 work in both cases, but return a different result, this function
1253 returns the result of ANSI/ISO lookup. Otherwise, it returns
1257 check_for_out_of_scope_variable (tree decl)
1261 /* We only care about out of scope variables. */
1262 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1265 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1266 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1267 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1268 && DECL_DEAD_FOR_LOCAL (shadowed))
1269 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1270 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1272 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1275 if (!DECL_ERROR_REPORTED (decl))
1277 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1278 warning (0, " matches this %q+D under ISO standard rules",
1280 warning (0, " matches this %q+D under old rules", decl);
1281 DECL_ERROR_REPORTED (decl) = 1;
1286 /* If we have already complained about this declaration, there's no
1287 need to do it again. */
1288 if (DECL_ERROR_REPORTED (decl))
1291 DECL_ERROR_REPORTED (decl) = 1;
1293 if (TREE_TYPE (decl) == error_mark_node)
1296 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1298 error ("name lookup of %qD changed for ISO %<for%> scoping",
1300 error (" cannot use obsolete binding at %q+D because "
1301 "it has a destructor", decl);
1302 return error_mark_node;
1306 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1308 if (flag_permissive)
1309 permerror (input_location, " using obsolete binding at %q+D", decl);
1315 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1324 /* true means unconditionally make a BLOCK for the next level pushed. */
1326 static bool keep_next_level_flag;
1328 static int binding_depth = 0;
1335 for (i = 0; i < depth * 2; i++)
1339 /* Return a string describing the kind of SCOPE we have. */
1341 cxx_scope_descriptor (cxx_scope *scope)
1343 /* The order of this table must match the "scope_kind"
1345 static const char* scope_kind_names[] = {
1351 "function-parameter-scope",
1354 "template-parameter-scope",
1355 "template-explicit-spec-scope"
1357 const scope_kind kind = scope->explicit_spec_p
1358 ? sk_template_spec : scope->kind;
1360 return scope_kind_names[kind];
1363 /* Output a debugging information about SCOPE when performing
1366 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1368 const char *desc = cxx_scope_descriptor (scope);
1369 if (scope->this_entity)
1370 verbatim ("%s %s(%E) %p %d\n", action, desc,
1371 scope->this_entity, (void *) scope, line);
1373 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1376 /* Return the estimated initial size of the hashtable of a NAMESPACE
1379 static inline size_t
1380 namespace_scope_ht_size (tree ns)
1382 tree name = DECL_NAME (ns);
1384 return name == std_identifier
1385 ? NAMESPACE_STD_HT_SIZE
1386 : (name == global_scope_name
1387 ? GLOBAL_SCOPE_HT_SIZE
1388 : NAMESPACE_ORDINARY_HT_SIZE);
1391 /* A chain of binding_level structures awaiting reuse. */
1393 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1395 /* Insert SCOPE as the innermost binding level. */
1398 push_binding_level (struct cp_binding_level *scope)
1400 /* Add it to the front of currently active scopes stack. */
1401 scope->level_chain = current_binding_level;
1402 current_binding_level = scope;
1403 keep_next_level_flag = false;
1405 if (ENABLE_SCOPE_CHECKING)
1407 scope->binding_depth = binding_depth;
1408 indent (binding_depth);
1409 cxx_scope_debug (scope, input_line, "push");
1414 /* Create a new KIND scope and make it the top of the active scopes stack.
1415 ENTITY is the scope of the associated C++ entity (namespace, class,
1416 function, C++0x enumeration); it is NULL otherwise. */
1419 begin_scope (scope_kind kind, tree entity)
1423 /* Reuse or create a struct for this binding level. */
1424 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1426 scope = free_binding_level;
1427 memset (scope, 0, sizeof (cxx_scope));
1428 free_binding_level = scope->level_chain;
1431 scope = ggc_alloc_cleared_cxx_scope ();
1433 scope->this_entity = entity;
1434 scope->more_cleanups_ok = true;
1441 case sk_template_spec:
1442 scope->explicit_spec_p = true;
1443 kind = sk_template_parms;
1445 case sk_template_parms:
1452 case sk_scoped_enum:
1453 case sk_function_parms:
1455 scope->keep = keep_next_level_flag;
1459 NAMESPACE_LEVEL (entity) = scope;
1460 scope->static_decls =
1461 VEC_alloc (tree, gc,
1462 DECL_NAME (entity) == std_identifier
1463 || DECL_NAME (entity) == global_scope_name
1468 /* Should not happen. */
1474 push_binding_level (scope);
1479 /* We're about to leave current scope. Pop the top of the stack of
1480 currently active scopes. Return the enclosing scope, now active. */
1485 cxx_scope *scope = current_binding_level;
1487 if (scope->kind == sk_namespace && class_binding_level)
1488 current_binding_level = class_binding_level;
1490 /* We cannot leave a scope, if there are none left. */
1491 if (NAMESPACE_LEVEL (global_namespace))
1492 gcc_assert (!global_scope_p (scope));
1494 if (ENABLE_SCOPE_CHECKING)
1496 indent (--binding_depth);
1497 cxx_scope_debug (scope, input_line, "leave");
1500 /* Move one nesting level up. */
1501 current_binding_level = scope->level_chain;
1503 /* Namespace-scopes are left most probably temporarily, not
1504 completely; they can be reopened later, e.g. in namespace-extension
1505 or any name binding activity that requires us to resume a
1506 namespace. For classes, we cache some binding levels. For other
1507 scopes, we just make the structure available for reuse. */
1508 if (scope->kind != sk_namespace
1509 && scope->kind != sk_class)
1511 scope->level_chain = free_binding_level;
1512 gcc_assert (!ENABLE_SCOPE_CHECKING
1513 || scope->binding_depth == binding_depth);
1514 free_binding_level = scope;
1517 /* Find the innermost enclosing class scope, and reset
1518 CLASS_BINDING_LEVEL appropriately. */
1519 if (scope->kind == sk_class)
1521 class_binding_level = NULL;
1522 for (scope = current_binding_level; scope; scope = scope->level_chain)
1523 if (scope->kind == sk_class)
1525 class_binding_level = scope;
1530 return current_binding_level;
1534 resume_scope (struct cp_binding_level* b)
1536 /* Resuming binding levels is meant only for namespaces,
1537 and those cannot nest into classes. */
1538 gcc_assert (!class_binding_level);
1539 /* Also, resuming a non-directly nested namespace is a no-no. */
1540 gcc_assert (b->level_chain == current_binding_level);
1541 current_binding_level = b;
1542 if (ENABLE_SCOPE_CHECKING)
1544 b->binding_depth = binding_depth;
1545 indent (binding_depth);
1546 cxx_scope_debug (b, input_line, "resume");
1551 /* Return the innermost binding level that is not for a class scope. */
1554 innermost_nonclass_level (void)
1558 b = current_binding_level;
1559 while (b->kind == sk_class)
1565 /* We're defining an object of type TYPE. If it needs a cleanup, but
1566 we're not allowed to add any more objects with cleanups to the current
1567 scope, create a new binding level. */
1570 maybe_push_cleanup_level (tree type)
1572 if (type != error_mark_node
1573 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1574 && current_binding_level->more_cleanups_ok == 0)
1576 begin_scope (sk_cleanup, NULL);
1577 current_binding_level->statement_list = push_stmt_list ();
1581 /* Return true if we are in the global binding level. */
1584 global_bindings_p (void)
1586 return global_scope_p (current_binding_level);
1589 /* True if we are currently in a toplevel binding level. This
1590 means either the global binding level or a namespace in a toplevel
1591 binding level. Since there are no non-toplevel namespace levels,
1592 this really means any namespace or template parameter level. We
1593 also include a class whose context is toplevel. */
1596 toplevel_bindings_p (void)
1598 struct cp_binding_level *b = innermost_nonclass_level ();
1600 return b->kind == sk_namespace || b->kind == sk_template_parms;
1603 /* True if this is a namespace scope, or if we are defining a class
1604 which is itself at namespace scope, or whose enclosing class is
1605 such a class, etc. */
1608 namespace_bindings_p (void)
1610 struct cp_binding_level *b = innermost_nonclass_level ();
1612 return b->kind == sk_namespace;
1615 /* True if the current level needs to have a BLOCK made. */
1620 return (current_binding_level->blocks != NULL_TREE
1621 || current_binding_level->keep
1622 || current_binding_level->kind == sk_cleanup
1623 || current_binding_level->names != NULL_TREE
1624 || current_binding_level->using_directives);
1627 /* Returns the kind of the innermost scope. */
1630 innermost_scope_kind (void)
1632 return current_binding_level->kind;
1635 /* Returns true if this scope was created to store template parameters. */
1638 template_parm_scope_p (void)
1640 return innermost_scope_kind () == sk_template_parms;
1643 /* If KEEP is true, make a BLOCK node for the next binding level,
1644 unconditionally. Otherwise, use the normal logic to decide whether
1645 or not to create a BLOCK. */
1648 keep_next_level (bool keep)
1650 keep_next_level_flag = keep;
1653 /* Return the list of declarations of the current level.
1654 Note that this list is in reverse order unless/until
1655 you nreverse it; and when you do nreverse it, you must
1656 store the result back using `storedecls' or you will lose. */
1661 return current_binding_level->names;
1664 /* Return how many function prototypes we are currently nested inside. */
1667 function_parm_depth (void)
1670 struct cp_binding_level *b;
1672 for (b = current_binding_level;
1673 b->kind == sk_function_parms;
1680 /* For debugging. */
1681 static int no_print_functions = 0;
1682 static int no_print_builtins = 0;
1685 print_binding_level (struct cp_binding_level* lvl)
1689 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1690 if (lvl->more_cleanups_ok)
1691 fprintf (stderr, " more-cleanups-ok");
1692 if (lvl->have_cleanups)
1693 fprintf (stderr, " have-cleanups");
1694 fprintf (stderr, "\n");
1697 fprintf (stderr, " names:\t");
1698 /* We can probably fit 3 names to a line? */
1699 for (t = lvl->names; t; t = TREE_CHAIN (t))
1701 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1703 if (no_print_builtins
1704 && (TREE_CODE (t) == TYPE_DECL)
1705 && DECL_IS_BUILTIN (t))
1708 /* Function decls tend to have longer names. */
1709 if (TREE_CODE (t) == FUNCTION_DECL)
1716 fprintf (stderr, "\n\t");
1719 print_node_brief (stderr, "", t, 0);
1720 if (t == error_mark_node)
1724 fprintf (stderr, "\n");
1726 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1729 cp_class_binding *b;
1730 fprintf (stderr, " class-shadowed:");
1731 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1732 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1733 fprintf (stderr, "\n");
1735 if (lvl->type_shadowed)
1737 fprintf (stderr, " type-shadowed:");
1738 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1740 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1742 fprintf (stderr, "\n");
1747 print_other_binding_stack (struct cp_binding_level *stack)
1749 struct cp_binding_level *level;
1750 for (level = stack; !global_scope_p (level); level = level->level_chain)
1752 fprintf (stderr, "binding level %p\n", (void *) level);
1753 print_binding_level (level);
1758 print_binding_stack (void)
1760 struct cp_binding_level *b;
1761 fprintf (stderr, "current_binding_level=%p\n"
1762 "class_binding_level=%p\n"
1763 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1764 (void *) current_binding_level, (void *) class_binding_level,
1765 (void *) NAMESPACE_LEVEL (global_namespace));
1766 if (class_binding_level)
1768 for (b = class_binding_level; b; b = b->level_chain)
1769 if (b == current_binding_level)
1772 b = class_binding_level;
1774 b = current_binding_level;
1777 b = current_binding_level;
1778 print_other_binding_stack (b);
1779 fprintf (stderr, "global:\n");
1780 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1783 /* Return the type associated with ID. */
1786 identifier_type_value_1 (tree id)
1788 /* There is no type with that name, anywhere. */
1789 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1791 /* This is not the type marker, but the real thing. */
1792 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1793 return REAL_IDENTIFIER_TYPE_VALUE (id);
1794 /* Have to search for it. It must be on the global level, now.
1795 Ask lookup_name not to return non-types. */
1796 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1798 return TREE_TYPE (id);
1802 /* Wrapper for identifier_type_value_1. */
1805 identifier_type_value (tree id)
1808 timevar_start (TV_NAME_LOOKUP);
1809 ret = identifier_type_value_1 (id);
1810 timevar_stop (TV_NAME_LOOKUP);
1815 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1816 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1819 identifier_global_value (tree t)
1821 return IDENTIFIER_GLOBAL_VALUE (t);
1824 /* Push a definition of struct, union or enum tag named ID. into
1825 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1826 the tag ID is not already defined. */
1829 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1833 if (b->kind != sk_namespace)
1835 /* Shadow the marker, not the real thing, so that the marker
1836 gets restored later. */
1837 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1839 = tree_cons (id, old_type_value, b->type_shadowed);
1840 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1841 TREE_TYPE (b->type_shadowed) = type;
1845 cxx_binding *binding =
1846 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1849 supplement_binding (binding, decl);
1851 binding->value = decl;
1853 /* Store marker instead of real type. */
1854 type = global_type_node;
1856 SET_IDENTIFIER_TYPE_VALUE (id, type);
1859 /* As set_identifier_type_value_with_scope, but using
1860 current_binding_level. */
1863 set_identifier_type_value (tree id, tree decl)
1865 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1868 /* Return the name for the constructor (or destructor) for the
1869 specified class TYPE. When given a template, this routine doesn't
1870 lose the specialization. */
1873 constructor_name_full (tree type)
1875 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1878 /* Return the name for the constructor (or destructor) for the
1879 specified class. When given a template, return the plain
1880 unspecialized name. */
1883 constructor_name (tree type)
1886 name = constructor_name_full (type);
1887 if (IDENTIFIER_TEMPLATE (name))
1888 name = IDENTIFIER_TEMPLATE (name);
1892 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1893 which must be a class type. */
1896 constructor_name_p (tree name, tree type)
1900 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1905 if (TREE_CODE (name) != IDENTIFIER_NODE)
1908 ctor_name = constructor_name_full (type);
1909 if (name == ctor_name)
1911 if (IDENTIFIER_TEMPLATE (ctor_name)
1912 && name == IDENTIFIER_TEMPLATE (ctor_name))
1917 /* Counter used to create anonymous type names. */
1919 static GTY(()) int anon_cnt;
1921 /* Return an IDENTIFIER which can be used as a name for
1922 anonymous structs and unions. */
1925 make_anon_name (void)
1929 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1930 return get_identifier (buf);
1933 /* This code is practically identical to that for creating
1934 anonymous names, but is just used for lambdas instead. This is necessary
1935 because anonymous names are recognized and cannot be passed to template
1937 /* FIXME is this still necessary? */
1939 static GTY(()) int lambda_cnt = 0;
1942 make_lambda_name (void)
1946 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1947 return get_identifier (buf);
1950 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1952 static inline cxx_binding *
1953 find_binding (cxx_scope *scope, cxx_binding *binding)
1955 for (; binding != NULL; binding = binding->previous)
1956 if (binding->scope == scope)
1959 return (cxx_binding *)0;
1962 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1964 static inline cxx_binding *
1965 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1967 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1970 /* Fold-in case where NAME is used only once. */
1971 if (scope == b->scope && b->previous == NULL)
1973 return find_binding (scope, b);
1978 /* Always returns a binding for name in scope. If no binding is
1979 found, make a new one. */
1981 static cxx_binding *
1982 binding_for_name (cxx_scope *scope, tree name)
1984 cxx_binding *result;
1986 result = cxx_scope_find_binding_for_name (scope, name);
1989 /* Not found, make a new one. */
1990 result = cxx_binding_make (NULL, NULL);
1991 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1992 result->scope = scope;
1993 result->is_local = false;
1994 result->value_is_inherited = false;
1995 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1999 /* Walk through the bindings associated to the name of FUNCTION,
2000 and return the first binding that declares a function with a
2001 "C" linkage specification, a.k.a 'extern "C"'.
2002 This function looks for the binding, regardless of which scope it
2003 has been defined in. It basically looks in all the known scopes.
2004 Note that this function does not lookup for bindings of builtin functions
2005 or for functions declared in system headers. */
2007 lookup_extern_c_fun_binding_in_all_ns (tree function)
2012 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2014 name = DECL_NAME (function);
2015 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2017 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2019 iter = iter->previous)
2022 && TREE_CODE (iter->value) == FUNCTION_DECL
2023 && DECL_EXTERN_C_P (iter->value)
2024 && !DECL_ARTIFICIAL (iter->value))
2032 /* Insert another USING_DECL into the current binding level, returning
2033 this declaration. If this is a redeclaration, do nothing, and
2034 return NULL_TREE if this not in namespace scope (in namespace
2035 scope, a using decl might extend any previous bindings). */
2038 push_using_decl_1 (tree scope, tree name)
2042 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2043 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2044 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2045 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2048 return namespace_bindings_p () ? decl : NULL_TREE;
2049 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2050 USING_DECL_SCOPE (decl) = scope;
2051 DECL_CHAIN (decl) = current_binding_level->usings;
2052 current_binding_level->usings = decl;
2056 /* Wrapper for push_using_decl_1. */
2059 push_using_decl (tree scope, tree name)
2062 timevar_start (TV_NAME_LOOKUP);
2063 ret = push_using_decl_1 (scope, name);
2064 timevar_stop (TV_NAME_LOOKUP);
2068 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2069 caller to set DECL_CONTEXT properly.
2071 Note that this must only be used when X will be the new innermost
2072 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2073 without checking to see if the current IDENTIFIER_BINDING comes from a
2074 closer binding level than LEVEL. */
2077 pushdecl_with_scope_1 (tree x, cxx_scope *level, bool is_friend)
2079 struct cp_binding_level *b;
2080 tree function_decl = current_function_decl;
2082 current_function_decl = NULL_TREE;
2083 if (level->kind == sk_class)
2085 b = class_binding_level;
2086 class_binding_level = level;
2087 pushdecl_class_level (x);
2088 class_binding_level = b;
2092 b = current_binding_level;
2093 current_binding_level = level;
2094 x = pushdecl_maybe_friend (x, is_friend);
2095 current_binding_level = b;
2097 current_function_decl = function_decl;
2101 /* Wrapper for pushdecl_with_scope_1. */
2104 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
2107 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2108 ret = pushdecl_with_scope_1 (x, level, is_friend);
2109 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2114 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2115 other definitions already in place. We get around this by making
2116 the value of the identifier point to a list of all the things that
2117 want to be referenced by that name. It is then up to the users of
2118 that name to decide what to do with that list.
2120 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2121 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2123 FLAGS is a bitwise-or of the following values:
2124 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2126 PUSH_USING: DECL is being pushed as the result of a using
2129 IS_FRIEND is true if this is a friend declaration.
2131 The value returned may be a previous declaration if we guessed wrong
2132 about what language DECL should belong to (C or C++). Otherwise,
2133 it's always DECL (and never something that's not a _DECL). */
2136 push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2138 tree name = DECL_NAME (decl);
2141 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2144 old = namespace_binding (name, DECL_CONTEXT (decl));
2146 old = lookup_name_innermost_nonclass_level (name);
2150 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2152 tree t = TREE_TYPE (old);
2153 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2154 && (! DECL_IN_SYSTEM_HEADER (decl)
2155 || ! DECL_IN_SYSTEM_HEADER (old)))
2156 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2159 else if (is_overloaded_fn (old))
2163 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2165 tree fn = OVL_CURRENT (tmp);
2168 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2169 && !(flags & PUSH_USING)
2170 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2171 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2172 && ! decls_match (fn, decl))
2173 error ("%q#D conflicts with previous using declaration %q#D",
2176 dup = duplicate_decls (decl, fn, is_friend);
2177 /* If DECL was a redeclaration of FN -- even an invalid
2178 one -- pass that information along to our caller. */
2179 if (dup == fn || dup == error_mark_node)
2183 /* We don't overload implicit built-ins. duplicate_decls()
2184 may fail to merge the decls if the new decl is e.g. a
2185 template function. */
2186 if (TREE_CODE (old) == FUNCTION_DECL
2187 && DECL_ANTICIPATED (old)
2188 && !DECL_HIDDEN_FRIEND_P (old))
2191 else if (old == error_mark_node)
2192 /* Ignore the undefined symbol marker. */
2196 error ("previous non-function declaration %q+#D", old);
2197 error ("conflicts with function declaration %q#D", decl);
2202 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2203 /* If it's a using declaration, we always need to build an OVERLOAD,
2204 because it's the only way to remember that the declaration comes
2205 from 'using', and have the lookup behave correctly. */
2206 || (flags & PUSH_USING))
2208 if (old && TREE_CODE (old) != OVERLOAD)
2209 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2211 new_binding = ovl_cons (decl, old);
2212 if (flags & PUSH_USING)
2213 OVL_USED (new_binding) = 1;
2216 /* NAME is not ambiguous. */
2220 set_namespace_binding (name, current_namespace, new_binding);
2223 /* We only create an OVERLOAD if there was a previous binding at
2224 this level, or if decl is a template. In the former case, we
2225 need to remove the old binding and replace it with the new
2226 binding. We must also run through the NAMES on the binding
2227 level where the name was bound to update the chain. */
2229 if (TREE_CODE (new_binding) == OVERLOAD && old)
2233 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2235 d = &TREE_CHAIN (*d))
2237 || (TREE_CODE (*d) == TREE_LIST
2238 && TREE_VALUE (*d) == old))
2240 if (TREE_CODE (*d) == TREE_LIST)
2241 /* Just replace the old binding with the new. */
2242 TREE_VALUE (*d) = new_binding;
2244 /* Build a TREE_LIST to wrap the OVERLOAD. */
2245 *d = tree_cons (NULL_TREE, new_binding,
2248 /* And update the cxx_binding node. */
2249 IDENTIFIER_BINDING (name)->value = new_binding;
2253 /* We should always find a previous binding in this case. */
2257 /* Install the new binding. */
2258 push_local_binding (name, new_binding, flags);
2264 /* Wrapper for push_overloaded_decl_1. */
2267 push_overloaded_decl (tree decl, int flags, bool is_friend)
2270 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2271 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2272 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2276 /* Check a non-member using-declaration. Return the name and scope
2277 being used, and the USING_DECL, or NULL_TREE on failure. */
2280 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2282 /* [namespace.udecl]
2283 A using-declaration for a class member shall be a
2284 member-declaration. */
2287 error ("%qT is not a namespace", scope);
2290 else if (scope == error_mark_node)
2293 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2296 A using-declaration shall not name a template-id. */
2297 error ("a using-declaration cannot specify a template-id. "
2298 "Try %<using %D%>", name);
2302 if (TREE_CODE (decl) == NAMESPACE_DECL)
2304 error ("namespace %qD not allowed in using-declaration", decl);
2308 if (TREE_CODE (decl) == SCOPE_REF)
2310 /* It's a nested name with template parameter dependent scope.
2311 This can only be using-declaration for class member. */
2312 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2316 if (is_overloaded_fn (decl))
2317 decl = get_first_fn (decl);
2319 gcc_assert (DECL_P (decl));
2321 /* Make a USING_DECL. */
2322 return push_using_decl (scope, name);
2325 /* Process local and global using-declarations. */
2328 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2329 tree *newval, tree *newtype)
2331 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2333 *newval = *newtype = NULL_TREE;
2334 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2338 if (!decls.value && !decls.type)
2340 error ("%qD not declared", name);
2344 /* Shift the old and new bindings around so we're comparing class and
2345 enumeration names to each other. */
2346 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2352 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2354 decls.type = decls.value;
2355 decls.value = NULL_TREE;
2358 /* It is impossible to overload a built-in function; any explicit
2359 declaration eliminates the built-in declaration. So, if OLDVAL
2360 is a built-in, then we can just pretend it isn't there. */
2362 && TREE_CODE (oldval) == FUNCTION_DECL
2363 && DECL_ANTICIPATED (oldval)
2364 && !DECL_HIDDEN_FRIEND_P (oldval))
2369 /* Check for using functions. */
2370 if (is_overloaded_fn (decls.value))
2374 if (oldval && !is_overloaded_fn (oldval))
2376 error ("%qD is already declared in this scope", name);
2381 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2383 tree new_fn = OVL_CURRENT (tmp);
2385 /* [namespace.udecl]
2387 If a function declaration in namespace scope or block
2388 scope has the same name and the same parameter types as a
2389 function introduced by a using declaration the program is
2391 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2393 tree old_fn = OVL_CURRENT (tmp1);
2395 if (new_fn == old_fn)
2396 /* The function already exists in the current namespace. */
2398 else if (OVL_USED (tmp1))
2399 continue; /* this is a using decl */
2400 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2401 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2403 gcc_assert (!DECL_ANTICIPATED (old_fn)
2404 || DECL_HIDDEN_FRIEND_P (old_fn));
2406 /* There was already a non-using declaration in
2407 this scope with the same parameter types. If both
2408 are the same extern "C" functions, that's ok. */
2409 if (decls_match (new_fn, old_fn))
2413 error ("%qD is already declared in this scope", name);
2419 /* If we broke out of the loop, there's no reason to add
2420 this function to the using declarations for this
2425 /* If we are adding to an existing OVERLOAD, then we no
2426 longer know the type of the set of functions. */
2427 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2428 TREE_TYPE (*newval) = unknown_type_node;
2429 /* Add this new function to the set. */
2430 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2431 /* If there is only one function, then we use its type. (A
2432 using-declaration naming a single function can be used in
2433 contexts where overload resolution cannot be
2435 if (TREE_CODE (*newval) != OVERLOAD)
2437 *newval = ovl_cons (*newval, NULL_TREE);
2438 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2440 OVL_USED (*newval) = 1;
2445 *newval = decls.value;
2446 if (oldval && !decls_match (*newval, oldval))
2447 error ("%qD is already declared in this scope", name);
2453 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2455 error ("reference to %qD is ambiguous", name);
2456 print_candidates (decls.type);
2460 *newtype = decls.type;
2461 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2462 error ("%qD is already declared in this scope", name);
2465 /* If *newval is empty, shift any class or enumeration name down. */
2469 *newtype = NULL_TREE;
2473 /* Process a using-declaration at function scope. */
2476 do_local_using_decl (tree decl, tree scope, tree name)
2478 tree oldval, oldtype, newval, newtype;
2479 tree orig_decl = decl;
2481 decl = validate_nonmember_using_decl (decl, scope, name);
2482 if (decl == NULL_TREE)
2485 if (building_stmt_list_p ()
2486 && at_function_scope_p ())
2487 add_decl_expr (decl);
2489 oldval = lookup_name_innermost_nonclass_level (name);
2490 oldtype = lookup_type_current_level (name);
2492 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2496 if (is_overloaded_fn (newval))
2500 /* We only need to push declarations for those functions
2501 that were not already bound in the current level.
2502 The old value might be NULL_TREE, it might be a single
2503 function, or an OVERLOAD. */
2504 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2505 term = OVL_FUNCTION (oldval);
2508 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2510 push_overloaded_decl (OVL_CURRENT (fn),
2511 PUSH_LOCAL | PUSH_USING,
2515 push_local_binding (name, newval, PUSH_USING);
2519 push_local_binding (name, newtype, PUSH_USING);
2520 set_identifier_type_value (name, newtype);
2523 /* Emit debug info. */
2524 if (!processing_template_decl)
2525 cp_emit_debug_info_for_using (orig_decl, current_scope());
2528 /* Returns true if ROOT (a namespace, class, or function) encloses
2529 CHILD. CHILD may be either a class type or a namespace. */
2532 is_ancestor (tree root, tree child)
2534 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2535 || TREE_CODE (root) == FUNCTION_DECL
2536 || CLASS_TYPE_P (root)));
2537 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2538 || CLASS_TYPE_P (child)));
2540 /* The global namespace encloses everything. */
2541 if (root == global_namespace)
2546 /* If we've run out of scopes, stop. */
2549 /* If we've reached the ROOT, it encloses CHILD. */
2552 /* Go out one level. */
2554 child = TYPE_NAME (child);
2555 child = DECL_CONTEXT (child);
2559 /* Enter the class or namespace scope indicated by T suitable for name
2560 lookup. T can be arbitrary scope, not necessary nested inside the
2561 current scope. Returns a non-null scope to pop iff pop_scope
2562 should be called later to exit this scope. */
2567 if (TREE_CODE (t) == NAMESPACE_DECL)
2568 push_decl_namespace (t);
2569 else if (CLASS_TYPE_P (t))
2571 if (!at_class_scope_p ()
2572 || !same_type_p (current_class_type, t))
2573 push_nested_class (t);
2575 /* T is the same as the current scope. There is therefore no
2576 need to re-enter the scope. Since we are not actually
2577 pushing a new scope, our caller should not call
2585 /* Leave scope pushed by push_scope. */
2592 if (TREE_CODE (t) == NAMESPACE_DECL)
2593 pop_decl_namespace ();
2594 else if CLASS_TYPE_P (t)
2595 pop_nested_class ();
2598 /* Subroutine of push_inner_scope. */
2601 push_inner_scope_r (tree outer, tree inner)
2606 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2609 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2611 push_inner_scope_r (outer, prev);
2612 if (TREE_CODE (inner) == NAMESPACE_DECL)
2614 struct cp_binding_level *save_template_parm = 0;
2615 /* Temporary take out template parameter scopes. They are saved
2616 in reversed order in save_template_parm. */
2617 while (current_binding_level->kind == sk_template_parms)
2619 struct cp_binding_level *b = current_binding_level;
2620 current_binding_level = b->level_chain;
2621 b->level_chain = save_template_parm;
2622 save_template_parm = b;
2625 resume_scope (NAMESPACE_LEVEL (inner));
2626 current_namespace = inner;
2628 /* Restore template parameter scopes. */
2629 while (save_template_parm)
2631 struct cp_binding_level *b = save_template_parm;
2632 save_template_parm = b->level_chain;
2633 b->level_chain = current_binding_level;
2634 current_binding_level = b;
2641 /* Enter the scope INNER from current scope. INNER must be a scope
2642 nested inside current scope. This works with both name lookup and
2643 pushing name into scope. In case a template parameter scope is present,
2644 namespace is pushed under the template parameter scope according to
2645 name lookup rule in 14.6.1/6.
2647 Return the former current scope suitable for pop_inner_scope. */
2650 push_inner_scope (tree inner)
2652 tree outer = current_scope ();
2654 outer = current_namespace;
2656 push_inner_scope_r (outer, inner);
2660 /* Exit the current scope INNER back to scope OUTER. */
2663 pop_inner_scope (tree outer, tree inner)
2666 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2669 while (outer != inner)
2671 if (TREE_CODE (inner) == NAMESPACE_DECL)
2673 struct cp_binding_level *save_template_parm = 0;
2674 /* Temporary take out template parameter scopes. They are saved
2675 in reversed order in save_template_parm. */
2676 while (current_binding_level->kind == sk_template_parms)
2678 struct cp_binding_level *b = current_binding_level;
2679 current_binding_level = b->level_chain;
2680 b->level_chain = save_template_parm;
2681 save_template_parm = b;
2686 /* Restore template parameter scopes. */
2687 while (save_template_parm)
2689 struct cp_binding_level *b = save_template_parm;
2690 save_template_parm = b->level_chain;
2691 b->level_chain = current_binding_level;
2692 current_binding_level = b;
2698 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2702 /* Do a pushlevel for class declarations. */
2705 pushlevel_class (void)
2707 class_binding_level = begin_scope (sk_class, current_class_type);
2710 /* ...and a poplevel for class declarations. */
2713 poplevel_class (void)
2715 struct cp_binding_level *level = class_binding_level;
2716 cp_class_binding *cb;
2720 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2721 gcc_assert (level != 0);
2723 /* If we're leaving a toplevel class, cache its binding level. */
2724 if (current_class_depth == 1)
2725 previous_class_level = level;
2726 for (shadowed = level->type_shadowed;
2728 shadowed = TREE_CHAIN (shadowed))
2729 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2731 /* Remove the bindings for all of the class-level declarations. */
2732 if (level->class_shadowed)
2734 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2736 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2737 cxx_binding_free (cb->base);
2739 ggc_free (level->class_shadowed);
2740 level->class_shadowed = NULL;
2743 /* Now, pop out of the binding level which we created up in the
2744 `pushlevel_class' routine. */
2745 gcc_assert (current_binding_level == level);
2747 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2750 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2751 appropriate. DECL is the value to which a name has just been
2752 bound. CLASS_TYPE is the class in which the lookup occurred. */
2755 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2758 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2762 if (TREE_CODE (decl) == OVERLOAD)
2763 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2766 gcc_assert (DECL_P (decl));
2767 context = context_for_name_lookup (decl);
2770 if (is_properly_derived_from (class_type, context))
2771 INHERITED_VALUE_BINDING_P (binding) = 1;
2773 INHERITED_VALUE_BINDING_P (binding) = 0;
2775 else if (binding->value == decl)
2776 /* We only encounter a TREE_LIST when there is an ambiguity in the
2777 base classes. Such an ambiguity can be overridden by a
2778 definition in this class. */
2779 INHERITED_VALUE_BINDING_P (binding) = 1;
2781 INHERITED_VALUE_BINDING_P (binding) = 0;
2784 /* Make the declaration of X appear in CLASS scope. */
2787 pushdecl_class_level (tree x)
2790 bool is_valid = true;
2793 /* Do nothing if we're adding to an outer lambda closure type,
2794 outer_binding will add it later if it's needed. */
2795 if (current_class_type != class_binding_level->this_entity)
2798 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2799 /* Get the name of X. */
2800 if (TREE_CODE (x) == OVERLOAD)
2801 name = DECL_NAME (get_first_fn (x));
2803 name = DECL_NAME (x);
2807 is_valid = push_class_level_binding (name, x);
2808 if (TREE_CODE (x) == TYPE_DECL)
2809 set_identifier_type_value (name, x);
2811 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2813 /* If X is an anonymous aggregate, all of its members are
2814 treated as if they were members of the class containing the
2815 aggregate, for naming purposes. */
2818 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2820 location_t save_location = input_location;
2821 input_location = DECL_SOURCE_LOCATION (f);
2822 if (!pushdecl_class_level (f))
2824 input_location = save_location;
2827 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2831 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2832 scope. If the value returned is non-NULL, and the PREVIOUS field
2833 is not set, callers must set the PREVIOUS field explicitly. */
2835 static cxx_binding *
2836 get_class_binding (tree name, cxx_scope *scope)
2841 cxx_binding *binding;
2843 class_type = scope->this_entity;
2845 /* Get the type binding. */
2846 type_binding = lookup_member (class_type, name,
2847 /*protect=*/2, /*want_type=*/true);
2848 /* Get the value binding. */
2849 value_binding = lookup_member (class_type, name,
2850 /*protect=*/2, /*want_type=*/false);
2853 && (TREE_CODE (value_binding) == TYPE_DECL
2854 || DECL_CLASS_TEMPLATE_P (value_binding)
2855 || (TREE_CODE (value_binding) == TREE_LIST
2856 && TREE_TYPE (value_binding) == error_mark_node
2857 && (TREE_CODE (TREE_VALUE (value_binding))
2859 /* We found a type binding, even when looking for a non-type
2860 binding. This means that we already processed this binding
2863 else if (value_binding)
2865 if (TREE_CODE (value_binding) == TREE_LIST
2866 && TREE_TYPE (value_binding) == error_mark_node)
2867 /* NAME is ambiguous. */
2869 else if (BASELINK_P (value_binding))
2870 /* NAME is some overloaded functions. */
2871 value_binding = BASELINK_FUNCTIONS (value_binding);
2874 /* If we found either a type binding or a value binding, create a
2875 new binding object. */
2876 if (type_binding || value_binding)
2878 binding = new_class_binding (name,
2882 /* This is a class-scope binding, not a block-scope binding. */
2883 LOCAL_BINDING_P (binding) = 0;
2884 set_inherited_value_binding_p (binding, value_binding, class_type);
2892 /* Make the declaration(s) of X appear in CLASS scope under the name
2893 NAME. Returns true if the binding is valid. */
2896 push_class_level_binding_1 (tree name, tree x)
2898 cxx_binding *binding;
2902 /* The class_binding_level will be NULL if x is a template
2903 parameter name in a member template. */
2904 if (!class_binding_level)
2907 if (name == error_mark_node)
2910 /* Check for invalid member names. */
2911 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2912 /* Check that we're pushing into the right binding level. */
2913 gcc_assert (current_class_type == class_binding_level->this_entity);
2915 /* We could have been passed a tree list if this is an ambiguous
2916 declaration. If so, pull the declaration out because
2917 check_template_shadow will not handle a TREE_LIST. */
2918 if (TREE_CODE (decl) == TREE_LIST
2919 && TREE_TYPE (decl) == error_mark_node)
2920 decl = TREE_VALUE (decl);
2922 if (!check_template_shadow (decl))
2927 If T is the name of a class, then each of the following shall
2928 have a name different from T:
2930 -- every static data member of class T;
2932 -- every member of class T that is itself a type;
2934 -- every enumerator of every member of class T that is an
2937 -- every member of every anonymous union that is a member of
2940 (Non-static data members were also forbidden to have the same
2941 name as T until TC1.) */
2942 if ((TREE_CODE (x) == VAR_DECL
2943 || TREE_CODE (x) == CONST_DECL
2944 || (TREE_CODE (x) == TYPE_DECL
2945 && !DECL_SELF_REFERENCE_P (x))
2946 /* A data member of an anonymous union. */
2947 || (TREE_CODE (x) == FIELD_DECL
2948 && DECL_CONTEXT (x) != current_class_type))
2949 && DECL_NAME (x) == constructor_name (current_class_type))
2951 tree scope = context_for_name_lookup (x);
2952 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2954 error ("%qD has the same name as the class in which it is "
2961 /* Get the current binding for NAME in this class, if any. */
2962 binding = IDENTIFIER_BINDING (name);
2963 if (!binding || binding->scope != class_binding_level)
2965 binding = get_class_binding (name, class_binding_level);
2966 /* If a new binding was created, put it at the front of the
2967 IDENTIFIER_BINDING list. */
2970 binding->previous = IDENTIFIER_BINDING (name);
2971 IDENTIFIER_BINDING (name) = binding;
2975 /* If there is already a binding, then we may need to update the
2977 if (binding && binding->value)
2979 tree bval = binding->value;
2980 tree old_decl = NULL_TREE;
2982 if (INHERITED_VALUE_BINDING_P (binding))
2984 /* If the old binding was from a base class, and was for a
2985 tag name, slide it over to make room for the new binding.
2986 The old binding is still visible if explicitly qualified
2987 with a class-key. */
2988 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2989 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2991 old_decl = binding->type;
2992 binding->type = bval;
2993 binding->value = NULL_TREE;
2994 INHERITED_VALUE_BINDING_P (binding) = 0;
2999 /* Any inherited type declaration is hidden by the type
3000 declaration in the derived class. */
3001 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
3002 binding->type = NULL_TREE;
3005 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
3007 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
3009 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
3011 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
3014 if (old_decl && binding->scope == class_binding_level)
3017 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3018 here. This function is only used to register bindings
3019 from with the class definition itself. */
3020 INHERITED_VALUE_BINDING_P (binding) = 0;
3025 /* Note that we declared this value so that we can issue an error if
3026 this is an invalid redeclaration of a name already used for some
3028 note_name_declared_in_class (name, decl);
3030 /* If we didn't replace an existing binding, put the binding on the
3031 stack of bindings for the identifier, and update the shadowed
3033 if (binding && binding->scope == class_binding_level)
3034 /* Supplement the existing binding. */
3035 ok = supplement_binding (binding, decl);
3038 /* Create a new binding. */
3039 push_binding (name, decl, class_binding_level);
3046 /* Wrapper for push_class_level_binding_1. */
3049 push_class_level_binding (tree name, tree x)
3052 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3053 ret = push_class_level_binding_1 (name, x);
3054 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3058 /* Process "using SCOPE::NAME" in a class scope. Return the
3059 USING_DECL created. */
3062 do_class_using_decl (tree scope, tree name)
3064 /* The USING_DECL returned by this function. */
3066 /* The declaration (or declarations) name by this using
3067 declaration. NULL if we are in a template and cannot figure out
3068 what has been named. */
3070 /* True if SCOPE is a dependent type. */
3071 bool scope_dependent_p;
3072 /* True if SCOPE::NAME is dependent. */
3073 bool name_dependent_p;
3074 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3075 bool bases_dependent_p;
3080 if (name == error_mark_node)
3083 if (!scope || !TYPE_P (scope))
3085 error ("using-declaration for non-member at class scope");
3089 /* Make sure the name is not invalid */
3090 if (TREE_CODE (name) == BIT_NOT_EXPR)
3092 error ("%<%T::%D%> names destructor", scope, name);
3095 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3097 error ("%<%T::%D%> names constructor", scope, name);
3100 if (constructor_name_p (name, current_class_type))
3102 error ("%<%T::%D%> names constructor in %qT",
3103 scope, name, current_class_type);
3107 scope_dependent_p = dependent_type_p (scope);
3108 name_dependent_p = (scope_dependent_p
3109 || (IDENTIFIER_TYPENAME_P (name)
3110 && dependent_type_p (TREE_TYPE (name))));
3112 bases_dependent_p = false;
3113 if (processing_template_decl)
3114 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3115 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3117 if (dependent_type_p (TREE_TYPE (base_binfo)))
3119 bases_dependent_p = true;
3125 /* From [namespace.udecl]:
3127 A using-declaration used as a member-declaration shall refer to a
3128 member of a base class of the class being defined.
3130 In general, we cannot check this constraint in a template because
3131 we do not know the entire set of base classes of the current
3132 class type. However, if all of the base classes are
3133 non-dependent, then we can avoid delaying the check until
3135 if (!scope_dependent_p)
3138 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3139 if (b_kind < bk_proper_base)
3141 if (!bases_dependent_p)
3143 error_not_base_type (scope, current_class_type);
3147 else if (!name_dependent_p)
3149 decl = lookup_member (binfo, name, 0, false);
3152 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3156 /* The binfo from which the functions came does not matter. */
3157 if (BASELINK_P (decl))
3158 decl = BASELINK_FUNCTIONS (decl);
3162 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3163 USING_DECL_DECLS (value) = decl;
3164 USING_DECL_SCOPE (value) = scope;
3165 DECL_DEPENDENT_P (value) = !decl;
3171 /* Return the binding value for name in scope. */
3175 namespace_binding_1 (tree name, tree scope)
3177 cxx_binding *binding;
3179 if (SCOPE_FILE_SCOPE_P (scope))
3180 scope = global_namespace;
3182 /* Unnecessary for the global namespace because it can't be an alias. */
3183 scope = ORIGINAL_NAMESPACE (scope);
3185 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3187 return binding ? binding->value : NULL_TREE;
3191 namespace_binding (tree name, tree scope)
3194 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3195 ret = namespace_binding_1 (name, scope);
3196 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3200 /* Set the binding value for name in scope. */
3203 set_namespace_binding_1 (tree name, tree scope, tree val)
3207 if (scope == NULL_TREE)
3208 scope = global_namespace;
3209 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3210 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3213 supplement_binding (b, val);
3216 /* Wrapper for set_namespace_binding_1. */
3219 set_namespace_binding (tree name, tree scope, tree val)
3221 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3222 set_namespace_binding_1 (name, scope, val);
3223 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3226 /* Set the context of a declaration to scope. Complain if we are not
3230 set_decl_namespace (tree decl, tree scope, bool friendp)
3234 /* Get rid of namespace aliases. */
3235 scope = ORIGINAL_NAMESPACE (scope);
3237 /* It is ok for friends to be qualified in parallel space. */
3238 if (!friendp && !is_ancestor (current_namespace, scope))
3239 error ("declaration of %qD not in a namespace surrounding %qD",
3241 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3243 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3244 if (scope == current_namespace)
3246 if (at_namespace_scope_p ())
3247 error ("explicit qualification in declaration of %qD",
3252 /* See whether this has been declared in the namespace. */
3253 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3254 if (old == error_mark_node)
3255 /* No old declaration at all. */
3257 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3258 if (TREE_CODE (old) == TREE_LIST)
3260 error ("reference to %qD is ambiguous", decl);
3261 print_candidates (old);
3264 if (!is_overloaded_fn (decl))
3266 /* We might have found OLD in an inline namespace inside SCOPE. */
3267 if (TREE_CODE (decl) == TREE_CODE (old))
3268 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3269 /* Don't compare non-function decls with decls_match here, since
3270 it can't check for the correct constness at this
3271 point. pushdecl will find those errors later. */
3274 /* Since decl is a function, old should contain a function decl. */
3275 if (!is_overloaded_fn (old))
3277 /* A template can be explicitly specialized in any namespace. */
3278 if (processing_explicit_instantiation)
3280 if (processing_template_decl || processing_specialization)
3281 /* We have not yet called push_template_decl to turn a
3282 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3283 match. But, we'll check later, when we construct the
3286 /* Instantiations or specializations of templates may be declared as
3287 friends in any namespace. */
3288 if (friendp && DECL_USE_TEMPLATE (decl))
3290 if (is_overloaded_fn (old))
3292 tree found = NULL_TREE;
3294 for (; elt; elt = OVL_NEXT (elt))
3296 tree ofn = OVL_CURRENT (elt);
3297 /* Adjust DECL_CONTEXT first so decls_match will return true
3298 if DECL will match a declaration in an inline namespace. */
3299 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3300 if (decls_match (decl, ofn))
3302 if (found && !decls_match (found, ofn))
3304 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3305 error ("reference to %qD is ambiguous", decl);
3306 print_candidates (old);
3314 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3316 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3322 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3323 if (decls_match (decl, old))
3327 /* It didn't work, go back to the explicit scope. */
3328 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3330 error ("%qD should have been declared inside %qD", decl, scope);
3333 /* Return the namespace where the current declaration is declared. */
3336 current_decl_namespace (void)
3339 /* If we have been pushed into a different namespace, use it. */
3340 if (!VEC_empty (tree, decl_namespace_list))
3341 return VEC_last (tree, decl_namespace_list);
3343 if (current_class_type)
3344 result = decl_namespace_context (current_class_type);
3345 else if (current_function_decl)
3346 result = decl_namespace_context (current_function_decl);
3348 result = current_namespace;
3352 /* Process any ATTRIBUTES on a namespace definition. Currently only
3353 attribute visibility is meaningful, which is a property of the syntactic
3354 block rather than the namespace as a whole, so we don't touch the
3355 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3358 handle_namespace_attrs (tree ns, tree attributes)
3361 bool saw_vis = false;
3363 for (d = attributes; d; d = TREE_CHAIN (d))
3365 tree name = TREE_PURPOSE (d);
3366 tree args = TREE_VALUE (d);
3368 if (is_attribute_p ("visibility", name))
3370 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3371 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3373 warning (OPT_Wattributes,
3374 "%qD attribute requires a single NTBS argument",
3379 if (!TREE_PUBLIC (ns))
3380 warning (OPT_Wattributes,
3381 "%qD attribute is meaningless since members of the "
3382 "anonymous namespace get local symbols", name);
3384 push_visibility (TREE_STRING_POINTER (x), 1);
3389 warning (OPT_Wattributes, "%qD attribute directive ignored",
3398 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3399 select a name that is unique to this compilation unit. */
3402 push_namespace (tree name)
3406 int implicit_use = 0;
3409 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3411 /* We should not get here if the global_namespace is not yet constructed
3412 nor if NAME designates the global namespace: The global scope is
3413 constructed elsewhere. */
3414 gcc_assert (global_namespace != NULL && name != global_scope_name);
3418 name = get_anonymous_namespace_name();
3419 d = IDENTIFIER_NAMESPACE_VALUE (name);
3421 /* Reopening anonymous namespace. */
3427 /* Check whether this is an extended namespace definition. */
3428 d = IDENTIFIER_NAMESPACE_VALUE (name);
3429 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3432 if (DECL_NAMESPACE_ALIAS (d))
3434 error ("namespace alias %qD not allowed here, assuming %qD",
3435 d, DECL_NAMESPACE_ALIAS (d));
3436 d = DECL_NAMESPACE_ALIAS (d);
3443 /* Make a new namespace, binding the name to it. */
3444 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3445 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3446 /* The name of this namespace is not visible to other translation
3447 units if it is an anonymous namespace or member thereof. */
3448 if (anon || decl_anon_ns_mem_p (current_namespace))
3449 TREE_PUBLIC (d) = 0;
3451 TREE_PUBLIC (d) = 1;
3455 /* Clear DECL_NAME for the benefit of debugging back ends. */
3456 SET_DECL_ASSEMBLER_NAME (d, name);
3457 DECL_NAME (d) = NULL_TREE;
3459 begin_scope (sk_namespace, d);
3462 resume_scope (NAMESPACE_LEVEL (d));
3465 do_using_directive (d);
3466 /* Enter the name space. */
3467 current_namespace = d;
3469 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3472 /* Pop from the scope of the current namespace. */
3475 pop_namespace (void)
3477 gcc_assert (current_namespace != global_namespace);
3478 current_namespace = CP_DECL_CONTEXT (current_namespace);
3479 /* The binding level is not popped, as it might be re-opened later. */
3483 /* Push into the scope of the namespace NS, even if it is deeply
3484 nested within another namespace. */
3487 push_nested_namespace (tree ns)
3489 if (ns == global_namespace)
3490 push_to_top_level ();
3493 push_nested_namespace (CP_DECL_CONTEXT (ns));
3494 push_namespace (DECL_NAME (ns));
3498 /* Pop back from the scope of the namespace NS, which was previously
3499 entered with push_nested_namespace. */
3502 pop_nested_namespace (tree ns)
3504 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3505 gcc_assert (current_namespace == ns);
3506 while (ns != global_namespace)
3509 ns = CP_DECL_CONTEXT (ns);
3512 pop_from_top_level ();
3513 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3516 /* Temporarily set the namespace for the current declaration. */
3519 push_decl_namespace (tree decl)
3521 if (TREE_CODE (decl) != NAMESPACE_DECL)
3522 decl = decl_namespace_context (decl);
3523 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3526 /* [namespace.memdef]/2 */
3529 pop_decl_namespace (void)
3531 VEC_pop (tree, decl_namespace_list);
3534 /* Return the namespace that is the common ancestor
3535 of two given namespaces. */
3538 namespace_ancestor_1 (tree ns1, tree ns2)
3541 if (is_ancestor (ns1, ns2))
3544 nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
3548 /* Wrapper for namespace_ancestor_1. */
3551 namespace_ancestor (tree ns1, tree ns2)
3554 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3555 nsr = namespace_ancestor_1 (ns1, ns2);
3556 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3560 /* Process a namespace-alias declaration. */
3563 do_namespace_alias (tree alias, tree name_space)
3565 if (name_space == error_mark_node)
3568 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3570 name_space = ORIGINAL_NAMESPACE (name_space);
3572 /* Build the alias. */
3573 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3574 DECL_NAMESPACE_ALIAS (alias) = name_space;
3575 DECL_EXTERNAL (alias) = 1;
3576 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3579 /* Emit debug info for namespace alias. */
3580 if (!building_stmt_list_p ())
3581 (*debug_hooks->global_decl) (alias);
3584 /* Like pushdecl, only it places X in the current namespace,
3588 pushdecl_namespace_level (tree x, bool is_friend)
3590 struct cp_binding_level *b = current_binding_level;
3593 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3594 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3596 /* Now, the type_shadowed stack may screw us. Munge it so it does
3598 if (TREE_CODE (t) == TYPE_DECL)
3600 tree name = DECL_NAME (t);
3602 tree *ptr = (tree *)0;
3603 for (; !global_scope_p (b); b = b->level_chain)
3605 tree shadowed = b->type_shadowed;
3606 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3607 if (TREE_PURPOSE (shadowed) == name)
3609 ptr = &TREE_VALUE (shadowed);
3610 /* Can't break out of the loop here because sometimes
3611 a binding level will have duplicate bindings for
3612 PT names. It's gross, but I haven't time to fix it. */
3615 newval = TREE_TYPE (t);
3616 if (ptr == (tree *)0)
3618 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3619 up here if this is changed to an assertion. --KR */
3620 SET_IDENTIFIER_TYPE_VALUE (name, t);
3627 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3631 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3632 directive is not directly from the source. Also find the common
3633 ancestor and let our users know about the new namespace */
3636 add_using_namespace_1 (tree user, tree used, bool indirect)
3639 /* Using oneself is a no-op. */
3642 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3643 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3644 /* Check if we already have this. */
3645 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3649 /* Promote to direct usage. */
3650 TREE_INDIRECT_USING (t) = 0;
3654 /* Add used to the user's using list. */
3655 DECL_NAMESPACE_USING (user)
3656 = tree_cons (used, namespace_ancestor (user, used),
3657 DECL_NAMESPACE_USING (user));
3659 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3661 /* Add user to the used's users list. */
3662 DECL_NAMESPACE_USERS (used)
3663 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3665 /* Recursively add all namespaces used. */
3666 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3667 /* indirect usage */
3668 add_using_namespace_1 (user, TREE_PURPOSE (t), 1);
3670 /* Tell everyone using us about the new used namespaces. */
3671 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3672 add_using_namespace_1 (TREE_PURPOSE (t), used, 1);
3675 /* Wrapper for add_using_namespace_1. */
3678 add_using_namespace (tree user, tree used, bool indirect)
3680 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3681 add_using_namespace_1 (user, used, indirect);
3682 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3685 /* Process a using-declaration not appearing in class or local scope. */
3688 do_toplevel_using_decl (tree decl, tree scope, tree name)
3690 tree oldval, oldtype, newval, newtype;
3691 tree orig_decl = decl;
3692 cxx_binding *binding;
3694 decl = validate_nonmember_using_decl (decl, scope, name);
3695 if (decl == NULL_TREE)
3698 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3700 oldval = binding->value;
3701 oldtype = binding->type;
3703 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3705 /* Emit debug info. */
3706 if (!processing_template_decl)
3707 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3709 /* Copy declarations found. */
3711 binding->value = newval;
3713 binding->type = newtype;
3716 /* Process a using-directive. */
3719 do_using_directive (tree name_space)
3721 tree context = NULL_TREE;
3723 if (name_space == error_mark_node)
3726 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3728 if (building_stmt_list_p ())
3729 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3730 name_space = ORIGINAL_NAMESPACE (name_space);
3732 if (!toplevel_bindings_p ())
3734 push_using_directive (name_space);
3739 add_using_namespace (current_namespace, name_space, 0);
3740 if (current_namespace != global_namespace)
3741 context = current_namespace;
3743 /* Emit debugging info. */
3744 if (!processing_template_decl)
3745 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3750 /* Deal with a using-directive seen by the parser. Currently we only
3751 handle attributes here, since they cannot appear inside a template. */
3754 parse_using_directive (tree name_space, tree attribs)
3758 do_using_directive (name_space);
3760 for (a = attribs; a; a = TREE_CHAIN (a))
3762 tree name = TREE_PURPOSE (a);
3763 if (is_attribute_p ("strong", name))
3765 if (!toplevel_bindings_p ())
3766 error ("strong using only meaningful at namespace scope");
3767 else if (name_space != error_mark_node)
3769 if (!is_ancestor (current_namespace, name_space))
3770 error ("current namespace %qD does not enclose strongly used namespace %qD",
3771 current_namespace, name_space);
3772 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3773 = tree_cons (current_namespace, 0,
3774 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3778 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3782 /* Like pushdecl, only it places X in the global scope if appropriate.
3783 Calls cp_finish_decl to register the variable, initializing it with
3784 *INIT, if INIT is non-NULL. */
3787 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3789 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3790 push_to_top_level ();
3791 x = pushdecl_namespace_level (x, is_friend);
3793 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3794 pop_from_top_level ();
3795 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3799 /* Like pushdecl, only it places X in the global scope if appropriate. */
3802 pushdecl_top_level (tree x)
3804 return pushdecl_top_level_1 (x, NULL, false);
3807 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3810 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3812 return pushdecl_top_level_1 (x, NULL, is_friend);
3815 /* Like pushdecl, only it places X in the global scope if
3816 appropriate. Calls cp_finish_decl to register the variable,
3817 initializing it with INIT. */
3820 pushdecl_top_level_and_finish (tree x, tree init)
3822 return pushdecl_top_level_1 (x, &init, false);
3825 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3826 duplicates. The first list becomes the tail of the result.
3828 The algorithm is O(n^2). We could get this down to O(n log n) by
3829 doing a sort on the addresses of the functions, if that becomes
3833 merge_functions (tree s1, tree s2)
3835 for (; s2; s2 = OVL_NEXT (s2))
3837 tree fn2 = OVL_CURRENT (s2);
3840 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3842 tree fn1 = OVL_CURRENT (fns1);
3844 /* If the function from S2 is already in S1, there is no
3845 need to add it again. For `extern "C"' functions, we
3846 might have two FUNCTION_DECLs for the same function, in
3847 different namespaces, but let's leave them in in case
3848 they have different default arguments. */
3853 /* If we exhausted all of the functions in S1, FN2 is new. */
3855 s1 = build_overload (fn2, s1);
3860 /* Returns TRUE iff OLD and NEW are the same entity.
3862 3 [basic]/3: An entity is a value, object, reference, function,
3863 enumerator, type, class member, template, template specialization,
3864 namespace, parameter pack, or this.
3866 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3867 in two different namespaces, and the declarations do not declare the
3868 same entity and do not declare functions, the use of the name is
3872 same_entity_p (tree one, tree two)
3878 if (TREE_CODE (one) == TYPE_DECL
3879 && TREE_CODE (two) == TYPE_DECL
3880 && same_type_p (TREE_TYPE (one), TREE_TYPE (two)))
3885 /* This should return an error not all definitions define functions.
3886 It is not an error if we find two functions with exactly the
3887 same signature, only if these are selected in overload resolution.
3888 old is the current set of bindings, new_binding the freshly-found binding.
3889 XXX Do we want to give *all* candidates in case of ambiguity?
3890 XXX In what way should I treat extern declarations?
3891 XXX I don't want to repeat the entire duplicate_decls here */
3894 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3897 gcc_assert (old != NULL);
3899 /* Copy the type. */
3900 type = new_binding->type;
3901 if (LOOKUP_NAMESPACES_ONLY (flags)
3902 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3905 /* Copy the value. */
3906 val = new_binding->value;
3909 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3912 switch (TREE_CODE (val))
3915 /* If we expect types or namespaces, and not templates,
3916 or this is not a template class. */
3917 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3918 && !DECL_CLASS_TEMPLATE_P (val)))
3922 if (LOOKUP_NAMESPACES_ONLY (flags)
3923 || (type && (flags & LOOKUP_PREFER_TYPES)))
3926 case NAMESPACE_DECL:
3927 if (LOOKUP_TYPES_ONLY (flags))
3931 /* Ignore built-in functions that are still anticipated. */
3932 if (LOOKUP_QUALIFIERS_ONLY (flags))
3936 if (LOOKUP_QUALIFIERS_ONLY (flags))
3941 /* If val is hidden, shift down any class or enumeration name. */
3950 else if (val && !same_entity_p (val, old->value))
3952 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3953 old->value = merge_functions (old->value, val);
3956 old->value = tree_cons (NULL_TREE, old->value,
3957 build_tree_list (NULL_TREE, val));
3958 TREE_TYPE (old->value) = error_mark_node;
3964 else if (type && old->type != type)
3966 old->type = tree_cons (NULL_TREE, old->type,
3967 build_tree_list (NULL_TREE, type));
3968 TREE_TYPE (old->type) = error_mark_node;
3972 /* Return the declarations that are members of the namespace NS. */
3975 cp_namespace_decls (tree ns)
3977 return NAMESPACE_LEVEL (ns)->names;
3980 /* Combine prefer_type and namespaces_only into flags. */
3983 lookup_flags (int prefer_type, int namespaces_only)
3985 if (namespaces_only)
3986 return LOOKUP_PREFER_NAMESPACES;
3987 if (prefer_type > 1)
3988 return LOOKUP_PREFER_TYPES;
3989 if (prefer_type > 0)
3990 return LOOKUP_PREFER_BOTH;
3994 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3995 ignore it or not. Subroutine of lookup_name_real and
3996 lookup_type_scope. */
3999 qualify_lookup (tree val, int flags)
4001 if (val == NULL_TREE)
4003 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
4005 if ((flags & LOOKUP_PREFER_TYPES)
4006 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
4008 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
4010 /* In unevaluated context, look past normal capture fields. */
4011 if (cp_unevaluated_operand && TREE_CODE (val) == FIELD_DECL
4012 && DECL_NORMAL_CAPTURE_P (val))
4014 /* None of the lookups that use qualify_lookup want the op() from the
4015 lambda; they want the one from the enclosing class. */
4016 if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
4021 /* Given a lookup that returned VAL, decide if we want to ignore it or
4022 not based on DECL_ANTICIPATED. */
4025 hidden_name_p (tree val)
4028 && DECL_LANG_SPECIFIC (val)
4029 && DECL_ANTICIPATED (val))
4034 /* Remove any hidden friend functions from a possibly overloaded set
4038 remove_hidden_names (tree fns)
4043 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
4045 else if (TREE_CODE (fns) == OVERLOAD)
4049 for (o = fns; o; o = OVL_NEXT (o))
4050 if (hidden_name_p (OVL_CURRENT (o)))
4056 for (o = fns; o; o = OVL_NEXT (o))
4057 if (!hidden_name_p (OVL_CURRENT (o)))
4058 n = build_overload (OVL_CURRENT (o), n);
4066 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4067 lookup failed. Search through all available namespaces and print out
4068 possible candidates. */
4071 suggest_alternatives_for (location_t location, tree name)
4073 VEC(tree,heap) *candidates = NULL;
4074 VEC(tree,heap) *namespaces_to_search = NULL;
4075 int max_to_search = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
4080 VEC_safe_push (tree, heap, namespaces_to_search, global_namespace);
4082 while (!VEC_empty (tree, namespaces_to_search)
4083 && n_searched < max_to_search)
4085 tree scope = VEC_pop (tree, namespaces_to_search);
4086 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4087 struct cp_binding_level *level = NAMESPACE_LEVEL (scope);
4089 /* Look in this namespace. */
4090 qualified_lookup_using_namespace (name, scope, &binding, 0);
4095 VEC_safe_push (tree, heap, candidates, binding.value);
4097 /* Add child namespaces. */
4098 for (t = level->namespaces; t; t = DECL_CHAIN (t))
4099 VEC_safe_push (tree, heap, namespaces_to_search, t);
4102 /* If we stopped before we could examine all namespaces, inform the
4103 user. Do this even if we don't have any candidates, since there
4104 might be more candidates further down that we weren't able to
4106 if (n_searched >= max_to_search
4107 && !VEC_empty (tree, namespaces_to_search))
4109 "maximum limit of %d namespaces searched for %qE",
4110 max_to_search, name);
4112 VEC_free (tree, heap, namespaces_to_search);
4114 /* Nothing useful to report. */
4115 if (VEC_empty (tree, candidates))
4118 inform_n (location, VEC_length (tree, candidates),
4119 "suggested alternative:",
4120 "suggested alternatives:");
4122 FOR_EACH_VEC_ELT (tree, candidates, ix, t)
4123 inform (location_of (t), " %qE", t);
4125 VEC_free (tree, heap, candidates);
4128 /* Unscoped lookup of a global: iterate over current namespaces,
4129 considering using-directives. */
4132 unqualified_namespace_lookup_1 (tree name, int flags)
4134 tree initial = current_decl_namespace ();
4135 tree scope = initial;
4137 struct cp_binding_level *level;
4138 tree val = NULL_TREE;
4140 for (; !val; scope = CP_DECL_CONTEXT (scope))
4142 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4144 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4147 ambiguous_decl (&binding, b, flags);
4149 /* Add all _DECLs seen through local using-directives. */
4150 for (level = current_binding_level;
4151 level->kind != sk_namespace;
4152 level = level->level_chain)
4153 if (!lookup_using_namespace (name, &binding, level->using_directives,
4155 /* Give up because of error. */
4156 return error_mark_node;
4158 /* Add all _DECLs seen through global using-directives. */
4159 /* XXX local and global using lists should work equally. */
4163 if (!lookup_using_namespace (name, &binding,
4164 DECL_NAMESPACE_USING (siter),
4166 /* Give up because of error. */
4167 return error_mark_node;
4168 if (siter == scope) break;
4169 siter = CP_DECL_CONTEXT (siter);
4172 val = binding.value;
4173 if (scope == global_namespace)
4179 /* Wrapper for unqualified_namespace_lookup_1. */
4182 unqualified_namespace_lookup (tree name, int flags)
4185 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4186 ret = unqualified_namespace_lookup_1 (name, flags);
4187 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4191 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4192 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4195 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4196 declaration found. If no suitable declaration can be found,
4197 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4198 neither a class-type nor a namespace a diagnostic is issued. */
4201 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
4206 if (TREE_CODE (scope) == NAMESPACE_DECL)
4208 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4210 flags |= LOOKUP_COMPLAIN;
4212 flags |= LOOKUP_PREFER_TYPES;
4213 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
4216 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
4217 t = lookup_enumerator (scope, name);
4218 else if (is_class_type (scope, complain))
4219 t = lookup_member (scope, name, 2, is_type_p);
4222 return error_mark_node;
4226 /* Subroutine of unqualified_namespace_lookup:
4227 Add the bindings of NAME in used namespaces to VAL.
4228 We are currently looking for names in namespace SCOPE, so we
4229 look through USINGS for using-directives of namespaces
4230 which have SCOPE as a common ancestor with the current scope.
4231 Returns false on errors. */
4234 lookup_using_namespace (tree name, struct scope_binding *val,
4235 tree usings, tree scope, int flags)
4238 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4239 /* Iterate over all used namespaces in current, searching for using
4240 directives of scope. */
4241 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4242 if (TREE_VALUE (iter) == scope)
4244 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
4246 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
4247 /* Resolve ambiguities. */
4249 ambiguous_decl (val, val1, flags);
4251 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4252 return val->value != error_mark_node;
4255 /* Returns true iff VEC contains TARGET. */
4258 tree_vec_contains (VEC(tree,gc)* vec, tree target)
4262 FOR_EACH_VEC_ELT (tree,vec,i,elt)
4269 Accepts the NAME to lookup and its qualifying SCOPE.
4270 Returns the name/type pair found into the cxx_binding *RESULT,
4271 or false on error. */
4274 qualified_lookup_using_namespace (tree name, tree scope,
4275 struct scope_binding *result, int flags)
4277 /* Maintain a list of namespaces visited... */
4278 VEC(tree,gc) *seen = NULL;
4279 VEC(tree,gc) *seen_inline = NULL;
4280 /* ... and a list of namespace yet to see. */
4281 VEC(tree,gc) *todo = NULL;
4282 VEC(tree,gc) *todo_maybe = NULL;
4283 VEC(tree,gc) *todo_inline = NULL;
4285 timevar_start (TV_NAME_LOOKUP);
4286 /* Look through namespace aliases. */
4287 scope = ORIGINAL_NAMESPACE (scope);
4289 /* Algorithm: Starting with SCOPE, walk through the set of used
4290 namespaces. For each used namespace, look through its inline
4291 namespace set for any bindings and usings. If no bindings are
4292 found, add any usings seen to the set of used namespaces. */
4293 VEC_safe_push (tree, gc, todo, scope);
4295 while (VEC_length (tree, todo))
4298 scope = VEC_pop (tree, todo);
4299 if (tree_vec_contains (seen, scope))
4301 VEC_safe_push (tree, gc, seen, scope);
4302 VEC_safe_push (tree, gc, todo_inline, scope);
4305 while (VEC_length (tree, todo_inline))
4307 cxx_binding *binding;
4309 scope = VEC_pop (tree, todo_inline);
4310 if (tree_vec_contains (seen_inline, scope))
4312 VEC_safe_push (tree, gc, seen_inline, scope);
4315 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4319 ambiguous_decl (result, binding, flags);
4322 for (usings = DECL_NAMESPACE_USING (scope); usings;
4323 usings = TREE_CHAIN (usings))
4324 if (!TREE_INDIRECT_USING (usings))
4326 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4327 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4329 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4334 VEC_truncate (tree, todo_maybe, 0);
4336 while (VEC_length (tree, todo_maybe))
4337 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4339 VEC_free (tree,gc,todo);
4340 VEC_free (tree,gc,todo_maybe);
4341 VEC_free (tree,gc,todo_inline);
4342 VEC_free (tree,gc,seen);
4343 VEC_free (tree,gc,seen_inline);
4344 timevar_stop (TV_NAME_LOOKUP);
4345 return result->value != error_mark_node;
4348 /* Subroutine of outer_binding.
4350 Returns TRUE if BINDING is a binding to a template parameter of
4351 SCOPE. In that case SCOPE is the scope of a primary template
4352 parameter -- in the sense of G++, i.e, a template that has its own
4355 Returns FALSE otherwise. */
4358 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4363 if (!binding || !scope)
4366 binding_value = binding->value ? binding->value : binding->type;
4369 && scope->this_entity
4370 && get_template_info (scope->this_entity)
4371 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4372 (get_template_info (scope->this_entity)))
4373 && parameter_of_template_p (binding_value,
4374 TI_TEMPLATE (get_template_info \
4375 (scope->this_entity))));
4378 /* Return the innermost non-namespace binding for NAME from a scope
4379 containing BINDING, or, if BINDING is NULL, the current scope.
4380 Please note that for a given template, the template parameters are
4381 considered to be in the scope containing the current scope.
4382 If CLASS_P is false, then class bindings are ignored. */
4385 outer_binding (tree name,
4386 cxx_binding *binding,
4391 cxx_scope *outer_scope;
4395 scope = binding->scope->level_chain;
4396 outer = binding->previous;
4400 scope = current_binding_level;
4401 outer = IDENTIFIER_BINDING (name);
4403 outer_scope = outer ? outer->scope : NULL;
4405 /* Because we create class bindings lazily, we might be missing a
4406 class binding for NAME. If there are any class binding levels
4407 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4408 declared, we must lookup NAME in those class scopes. */
4410 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4412 if (scope->kind == sk_class)
4414 cxx_binding *class_binding;
4416 class_binding = get_class_binding (name, scope);
4419 /* Thread this new class-scope binding onto the
4420 IDENTIFIER_BINDING list so that future lookups
4422 class_binding->previous = outer;
4424 binding->previous = class_binding;
4426 IDENTIFIER_BINDING (name) = class_binding;
4427 return class_binding;
4430 /* If we are in a member template, the template parms of the member
4431 template are considered to be inside the scope of the containing
4432 class, but within G++ the class bindings are all pushed between the
4433 template parms and the function body. So if the outer binding is
4434 a template parm for the current scope, return it now rather than
4435 look for a class binding. */
4436 if (outer_scope && outer_scope->kind == sk_template_parms
4437 && binding_to_template_parms_of_scope_p (outer, scope))
4440 scope = scope->level_chain;
4446 /* Return the innermost block-scope or class-scope value binding for
4447 NAME, or NULL_TREE if there is no such binding. */
4450 innermost_non_namespace_value (tree name)
4452 cxx_binding *binding;
4453 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4454 return binding ? binding->value : NULL_TREE;
4457 /* Look up NAME in the current binding level and its superiors in the
4458 namespace of variables, functions and typedefs. Return a ..._DECL
4459 node of some kind representing its definition if there is only one
4460 such declaration, or return a TREE_LIST with all the overloaded
4461 definitions if there are many, or return 0 if it is undefined.
4462 Hidden name, either friend declaration or built-in function, are
4465 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4466 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4467 Otherwise we prefer non-TYPE_DECLs.
4469 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4470 BLOCK_P is false, bindings in block scopes are ignored. */
4473 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
4474 int namespaces_only, int flags)
4477 tree val = NULL_TREE;
4479 /* Conversion operators are handled specially because ordinary
4480 unqualified name lookup will not find template conversion
4482 if (IDENTIFIER_TYPENAME_P (name) && current_class_type)
4484 struct cp_binding_level *level;
4486 for (level = current_binding_level;
4487 level && level->kind != sk_namespace;
4488 level = level->level_chain)
4493 /* A conversion operator can only be declared in a class
4495 if (level->kind != sk_class)
4498 /* Lookup the conversion operator in the class. */
4499 class_type = level->this_entity;
4500 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4508 flags |= lookup_flags (prefer_type, namespaces_only);
4510 /* First, look in non-namespace scopes. */
4512 if (current_class_type == NULL_TREE)
4515 if (block_p || !nonclass)
4516 for (iter = outer_binding (name, NULL, !nonclass);
4518 iter = outer_binding (name, iter, !nonclass))
4522 /* Skip entities we don't want. */
4523 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4526 /* If this is the kind of thing we're looking for, we're done. */
4527 if (qualify_lookup (iter->value, flags))
4528 binding = iter->value;
4529 else if ((flags & LOOKUP_PREFER_TYPES)
4530 && qualify_lookup (iter->type, flags))
4531 binding = iter->type;
4533 binding = NULL_TREE;
4537 if (hidden_name_p (binding))
4539 /* A non namespace-scope binding can only be hidden in the
4540 presence of a local class, due to friend declarations.
4542 In particular, consider:
4550 B* b; // error: B is hidden
4551 C* c; // OK, finds ::C
4554 B *b; // error: B is hidden
4555 C *c; // OK, finds ::C
4560 The standard says that "B" is a local class in "f"
4561 (but not nested within "A") -- but that name lookup
4562 for "B" does not find this declaration until it is
4563 declared directly with "f".
4569 If a friend declaration appears in a local class and
4570 the name specified is an unqualified name, a prior
4571 declaration is looked up without considering scopes
4572 that are outside the innermost enclosing non-class
4573 scope. For a friend function declaration, if there is
4574 no prior declaration, the program is ill-formed. For a
4575 friend class declaration, if there is no prior
4576 declaration, the class that is specified belongs to the
4577 innermost enclosing non-class scope, but if it is
4578 subsequently referenced, its name is not found by name
4579 lookup until a matching declaration is provided in the
4580 innermost enclosing nonclass scope.
4582 So just keep looking for a non-hidden binding.
4584 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4592 /* Now lookup in namespace scopes. */
4594 val = unqualified_namespace_lookup (name, flags);
4596 /* If we have a single function from a using decl, pull it out. */
4597 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4598 val = OVL_FUNCTION (val);
4603 /* Wrapper for lookup_name_real_1. */
4606 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4607 int namespaces_only, int flags)
4610 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4611 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
4612 namespaces_only, flags);
4613 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4618 lookup_name_nonclass (tree name)
4620 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4624 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4627 lookup_arg_dependent (name,
4628 lookup_name_real (name, 0, 1, block_p, 0,
4634 lookup_name (tree name)
4636 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4640 lookup_name_prefer_type (tree name, int prefer_type)
4642 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4643 0, LOOKUP_COMPLAIN);
4646 /* Look up NAME for type used in elaborated name specifier in
4647 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4648 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4649 name, more scopes are checked if cleanup or template parameter
4650 scope is encountered.
4652 Unlike lookup_name_real, we make sure that NAME is actually
4653 declared in the desired scope, not from inheritance, nor using
4654 directive. For using declaration, there is DR138 still waiting
4655 to be resolved. Hidden name coming from an earlier friend
4656 declaration is also returned.
4658 A TYPE_DECL best matching the NAME is returned. Catching error
4659 and issuing diagnostics are caller's responsibility. */
4662 lookup_type_scope_1 (tree name, tag_scope scope)
4664 cxx_binding *iter = NULL;
4665 tree val = NULL_TREE;
4667 /* Look in non-namespace scope first. */
4668 if (current_binding_level->kind != sk_namespace)
4669 iter = outer_binding (name, NULL, /*class_p=*/ true);
4670 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4672 /* Check if this is the kind of thing we're looking for.
4673 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4674 base class. For ITER->VALUE, we can simply use
4675 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4678 We check ITER->TYPE before ITER->VALUE in order to handle
4679 typedef struct C {} C;
4682 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4683 && (scope != ts_current
4684 || LOCAL_BINDING_P (iter)
4685 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4687 else if ((scope != ts_current
4688 || !INHERITED_VALUE_BINDING_P (iter))
4689 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4696 /* Look in namespace scope. */
4699 iter = cxx_scope_find_binding_for_name
4700 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4704 /* If this is the kind of thing we're looking for, we're done. */
4705 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4707 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4713 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4714 and template parameter scopes. */
4717 struct cp_binding_level *b = current_binding_level;
4720 if (iter->scope == b)
4723 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4724 || b->kind == sk_function_parms)
4726 else if (b->kind == sk_class
4727 && scope == ts_within_enclosing_non_class)
4737 /* Wrapper for lookup_type_scope_1. */
4740 lookup_type_scope (tree name, tag_scope scope)
4743 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4744 ret = lookup_type_scope_1 (name, scope);
4745 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4750 /* Similar to `lookup_name' but look only in the innermost non-class
4754 lookup_name_innermost_nonclass_level_1 (tree name)
4756 struct cp_binding_level *b;
4759 b = innermost_nonclass_level ();
4761 if (b->kind == sk_namespace)
4763 t = IDENTIFIER_NAMESPACE_VALUE (name);
4765 /* extern "C" function() */
4766 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4769 else if (IDENTIFIER_BINDING (name)
4770 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4772 cxx_binding *binding;
4773 binding = IDENTIFIER_BINDING (name);
4776 if (binding->scope == b
4777 && !(TREE_CODE (binding->value) == VAR_DECL
4778 && DECL_DEAD_FOR_LOCAL (binding->value)))
4779 return binding->value;
4781 if (b->kind == sk_cleanup)
4791 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4794 lookup_name_innermost_nonclass_level (tree name)
4797 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4798 ret = lookup_name_innermost_nonclass_level_1 (name);
4799 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4804 /* Returns true iff DECL is a block-scope extern declaration of a function
4808 is_local_extern (tree decl)
4810 cxx_binding *binding;
4812 /* For functions, this is easy. */
4813 if (TREE_CODE (decl) == FUNCTION_DECL)
4814 return DECL_LOCAL_FUNCTION_P (decl);
4816 if (TREE_CODE (decl) != VAR_DECL)
4818 if (!current_function_decl)
4821 /* For variables, this is not easy. We need to look at the binding stack
4822 for the identifier to see whether the decl we have is a local. */
4823 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4824 binding && binding->scope->kind != sk_namespace;
4825 binding = binding->previous)
4826 if (binding->value == decl)
4827 return LOCAL_BINDING_P (binding);
4832 /* Like lookup_name_innermost_nonclass_level, but for types. */
4835 lookup_type_current_level (tree name)
4839 timevar_start (TV_NAME_LOOKUP);
4840 gcc_assert (current_binding_level->kind != sk_namespace);
4842 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4843 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4845 struct cp_binding_level *b = current_binding_level;
4848 if (purpose_member (name, b->type_shadowed))
4850 t = REAL_IDENTIFIER_TYPE_VALUE (name);
4853 if (b->kind == sk_cleanup)
4860 timevar_stop (TV_NAME_LOOKUP);
4864 /* [basic.lookup.koenig] */
4865 /* A nonzero return value in the functions below indicates an error. */
4871 VEC(tree,gc) *namespaces;
4872 VEC(tree,gc) *classes;
4876 static bool arg_assoc (struct arg_lookup*, tree);
4877 static bool arg_assoc_args (struct arg_lookup*, tree);
4878 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4879 static bool arg_assoc_type (struct arg_lookup*, tree);
4880 static bool add_function (struct arg_lookup *, tree);
4881 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4882 static bool arg_assoc_class_only (struct arg_lookup *, tree);
4883 static bool arg_assoc_bases (struct arg_lookup *, tree);
4884 static bool arg_assoc_class (struct arg_lookup *, tree);
4885 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4887 /* Add a function to the lookup structure.
4888 Returns true on error. */
4891 add_function (struct arg_lookup *k, tree fn)
4893 /* We used to check here to see if the function was already in the list,
4894 but that's O(n^2), which is just too expensive for function lookup.
4895 Now we deal with the occasional duplicate in joust. In doing this, we
4896 assume that the number of duplicates will be small compared to the
4897 total number of functions being compared, which should usually be the
4900 if (!is_overloaded_fn (fn))
4901 /* All names except those of (possibly overloaded) functions and
4902 function templates are ignored. */;
4903 else if (!k->functions)
4905 else if (fn == k->functions)
4909 k->functions = build_overload (fn, k->functions);
4910 if (TREE_CODE (k->functions) == OVERLOAD)
4911 OVL_ARG_DEPENDENT (k->functions) = true;
4917 /* Returns true iff CURRENT has declared itself to be an associated
4918 namespace of SCOPE via a strong using-directive (or transitive chain
4919 thereof). Both are namespaces. */
4922 is_associated_namespace (tree current, tree scope)
4924 VEC(tree,gc) *seen = make_tree_vector ();
4925 VEC(tree,gc) *todo = make_tree_vector ();
4931 if (scope == current)
4936 VEC_safe_push (tree, gc, seen, scope);
4937 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4938 if (!vec_member (TREE_PURPOSE (t), seen))
4939 VEC_safe_push (tree, gc, todo, TREE_PURPOSE (t));
4940 if (!VEC_empty (tree, todo))
4942 scope = VEC_last (tree, todo);
4943 VEC_pop (tree, todo);
4952 release_tree_vector (seen);
4953 release_tree_vector (todo);
4958 /* Add functions of a namespace to the lookup structure.
4959 Returns true on error. */
4962 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4966 if (vec_member (scope, k->namespaces))
4968 VEC_safe_push (tree, gc, k->namespaces, scope);
4970 /* Check out our super-users. */
4971 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4972 value = TREE_CHAIN (value))
4973 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4976 /* Also look down into inline namespaces. */
4977 for (value = DECL_NAMESPACE_USING (scope); value;
4978 value = TREE_CHAIN (value))
4979 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4980 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4983 value = namespace_binding (k->name, scope);
4987 for (; value; value = OVL_NEXT (value))
4989 /* We don't want to find arbitrary hidden functions via argument
4990 dependent lookup. We only want to find friends of associated
4991 classes, which we'll do via arg_assoc_class. */
4992 if (hidden_name_p (OVL_CURRENT (value)))
4995 if (add_function (k, OVL_CURRENT (value)))
5002 /* Adds everything associated with a template argument to the lookup
5003 structure. Returns true on error. */
5006 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
5008 /* [basic.lookup.koenig]
5010 If T is a template-id, its associated namespaces and classes are
5011 ... the namespaces and classes associated with the types of the
5012 template arguments provided for template type parameters
5013 (excluding template template parameters); the namespaces in which
5014 any template template arguments are defined; and the classes in
5015 which any member templates used as template template arguments
5016 are defined. [Note: non-type template arguments do not
5017 contribute to the set of associated namespaces. ] */
5019 /* Consider first template template arguments. */
5020 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5021 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
5023 else if (TREE_CODE (arg) == TEMPLATE_DECL)
5025 tree ctx = CP_DECL_CONTEXT (arg);
5027 /* It's not a member template. */
5028 if (TREE_CODE (ctx) == NAMESPACE_DECL)
5029 return arg_assoc_namespace (k, ctx);
5030 /* Otherwise, it must be member template. */
5032 return arg_assoc_class_only (k, ctx);
5034 /* It's an argument pack; handle it recursively. */
5035 else if (ARGUMENT_PACK_P (arg))
5037 tree args = ARGUMENT_PACK_ARGS (arg);
5038 int i, len = TREE_VEC_LENGTH (args);
5039 for (i = 0; i < len; ++i)
5040 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
5045 /* It's not a template template argument, but it is a type template
5047 else if (TYPE_P (arg))
5048 return arg_assoc_type (k, arg);
5049 /* It's a non-type template argument. */
5054 /* Adds the class and its friends to the lookup structure.
5055 Returns true on error. */
5058 arg_assoc_class_only (struct arg_lookup *k, tree type)
5060 tree list, friends, context;
5062 /* Backend-built structures, such as __builtin_va_list, aren't
5063 affected by all this. */
5064 if (!CLASS_TYPE_P (type))
5067 context = decl_namespace_context (type);
5068 if (arg_assoc_namespace (k, context))
5071 complete_type (type);
5073 /* Process friends. */
5074 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
5075 list = TREE_CHAIN (list))
5076 if (k->name == FRIEND_NAME (list))
5077 for (friends = FRIEND_DECLS (list); friends;
5078 friends = TREE_CHAIN (friends))
5080 tree fn = TREE_VALUE (friends);
5082 /* Only interested in global functions with potentially hidden
5083 (i.e. unqualified) declarations. */
5084 if (CP_DECL_CONTEXT (fn) != context)
5086 /* Template specializations are never found by name lookup.
5087 (Templates themselves can be found, but not template
5088 specializations.) */
5089 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
5091 if (add_function (k, fn))
5098 /* Adds the class and its bases to the lookup structure.
5099 Returns true on error. */
5102 arg_assoc_bases (struct arg_lookup *k, tree type)
5104 if (arg_assoc_class_only (k, type))
5107 if (TYPE_BINFO (type))
5109 /* Process baseclasses. */
5110 tree binfo, base_binfo;
5113 for (binfo = TYPE_BINFO (type), i = 0;
5114 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5115 if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
5122 /* Adds everything associated with a class argument type to the lookup
5123 structure. Returns true on error.
5125 If T is a class type (including unions), its associated classes are: the
5126 class itself; the class of which it is a member, if any; and its direct
5127 and indirect base classes. Its associated namespaces are the namespaces
5128 of which its associated classes are members. Furthermore, if T is a
5129 class template specialization, its associated namespaces and classes
5130 also include: the namespaces and classes associated with the types of
5131 the template arguments provided for template type parameters (excluding
5132 template template parameters); the namespaces of which any template
5133 template arguments are members; and the classes of which any member
5134 templates used as template template arguments are members. [ Note:
5135 non-type template arguments do not contribute to the set of associated
5136 namespaces. --end note] */
5139 arg_assoc_class (struct arg_lookup *k, tree type)
5144 /* Backend build structures, such as __builtin_va_list, aren't
5145 affected by all this. */
5146 if (!CLASS_TYPE_P (type))
5149 if (vec_member (type, k->classes))
5151 VEC_safe_push (tree, gc, k->classes, type);
5153 if (TYPE_CLASS_SCOPE_P (type)
5154 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5157 if (arg_assoc_bases (k, type))
5160 /* Process template arguments. */
5161 if (CLASSTYPE_TEMPLATE_INFO (type)
5162 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
5164 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
5165 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
5166 if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
5173 /* Adds everything associated with a given type.
5174 Returns 1 on error. */
5177 arg_assoc_type (struct arg_lookup *k, tree type)
5179 /* As we do not get the type of non-type dependent expressions
5180 right, we can end up with such things without a type. */
5184 if (TYPE_PTRMEM_P (type))
5186 /* Pointer to member: associate class type and value type. */
5187 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
5189 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
5191 else switch (TREE_CODE (type))
5201 case FIXED_POINT_TYPE:
5206 if (TYPE_PTRMEMFUNC_P (type))
5207 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
5209 return arg_assoc_class (k, type);
5211 case REFERENCE_TYPE:
5213 return arg_assoc_type (k, TREE_TYPE (type));
5215 if (TYPE_CLASS_SCOPE_P (type)
5216 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5218 return arg_assoc_namespace (k, decl_namespace_context (type));
5220 /* The basetype is referenced in the first arg type, so just
5223 /* Associate the parameter types. */
5224 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
5226 /* Associate the return type. */
5227 return arg_assoc_type (k, TREE_TYPE (type));
5228 case TEMPLATE_TYPE_PARM:
5229 case BOUND_TEMPLATE_TEMPLATE_PARM:
5234 gcc_assert (type == unknown_type_node
5235 || type == init_list_type_node);
5237 case TYPE_PACK_EXPANSION:
5238 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
5246 /* Adds everything associated with arguments. Returns true on error. */
5249 arg_assoc_args (struct arg_lookup *k, tree args)
5251 for (; args; args = TREE_CHAIN (args))
5252 if (arg_assoc (k, TREE_VALUE (args)))
5257 /* Adds everything associated with an argument vector. Returns true
5261 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
5266 FOR_EACH_VEC_ELT (tree, args, ix, arg)
5267 if (arg_assoc (k, arg))
5272 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5275 arg_assoc (struct arg_lookup *k, tree n)
5277 if (n == error_mark_node)
5281 return arg_assoc_type (k, n);
5283 if (! type_unknown_p (n))
5284 return arg_assoc_type (k, TREE_TYPE (n));
5286 if (TREE_CODE (n) == ADDR_EXPR)
5287 n = TREE_OPERAND (n, 0);
5288 if (TREE_CODE (n) == COMPONENT_REF)
5289 n = TREE_OPERAND (n, 1);
5290 if (TREE_CODE (n) == OFFSET_REF)
5291 n = TREE_OPERAND (n, 1);
5292 while (TREE_CODE (n) == TREE_LIST)
5294 if (TREE_CODE (n) == BASELINK)
5295 n = BASELINK_FUNCTIONS (n);
5297 if (TREE_CODE (n) == FUNCTION_DECL)
5298 return arg_assoc_type (k, TREE_TYPE (n));
5299 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
5301 /* The working paper doesn't currently say how to handle template-id
5302 arguments. The sensible thing would seem to be to handle the list
5303 of template candidates like a normal overload set, and handle the
5304 template arguments like we do for class template
5306 tree templ = TREE_OPERAND (n, 0);
5307 tree args = TREE_OPERAND (n, 1);
5310 /* First the templates. */
5311 if (arg_assoc (k, templ))
5314 /* Now the arguments. */
5316 for (ix = TREE_VEC_LENGTH (args); ix--;)
5317 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
5320 else if (TREE_CODE (n) == OVERLOAD)
5322 for (; n; n = OVL_NEXT (n))
5323 if (arg_assoc_type (k, TREE_TYPE (OVL_CURRENT (n))))
5330 /* Performs Koenig lookup depending on arguments, where fns
5331 are the functions found in normal lookup. */
5334 lookup_arg_dependent_1 (tree name, tree fns, VEC(tree,gc) *args,
5337 struct arg_lookup k;
5339 /* Remove any hidden friend functions from the list of functions
5340 found so far. They will be added back by arg_assoc_class as
5342 fns = remove_hidden_names (fns);
5347 k.classes = make_tree_vector ();
5349 /* We previously performed an optimization here by setting
5350 NAMESPACES to the current namespace when it was safe. However, DR
5351 164 says that namespaces that were already searched in the first
5352 stage of template processing are searched again (potentially
5353 picking up later definitions) in the second stage. */
5354 k.namespaces = make_tree_vector ();
5357 arg_assoc_namespace (&k, std_node);
5358 arg_assoc_args_vec (&k, args);
5363 && TREE_CODE (fns) != VAR_DECL
5364 && !is_overloaded_fn (fns))
5366 error ("argument dependent lookup finds %q+D", fns);
5367 error (" in call to %qD", name);
5368 fns = error_mark_node;
5371 release_tree_vector (k.classes);
5372 release_tree_vector (k.namespaces);
5377 /* Wrapper for lookup_arg_dependent_1. */
5380 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
5384 timevar_start (TV_NAME_LOOKUP);
5385 ret = lookup_arg_dependent_1 (name, fns, args, include_std);
5386 timevar_stop (TV_NAME_LOOKUP);
5391 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5392 changed (i.e. there was already a directive), or the fresh
5393 TREE_LIST otherwise. */
5396 push_using_directive_1 (tree used)
5398 tree ud = current_binding_level->using_directives;
5399 tree iter, ancestor;
5401 /* Check if we already have this. */
5402 if (purpose_member (used, ud) != NULL_TREE)
5405 ancestor = namespace_ancestor (current_decl_namespace (), used);
5406 ud = current_binding_level->using_directives;
5407 ud = tree_cons (used, ancestor, ud);
5408 current_binding_level->using_directives = ud;
5410 /* Recursively add all namespaces used. */
5411 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5412 push_using_directive (TREE_PURPOSE (iter));
5417 /* Wrapper for push_using_directive_1. */
5420 push_using_directive (tree used)
5423 timevar_start (TV_NAME_LOOKUP);
5424 ret = push_using_directive_1 (used);
5425 timevar_stop (TV_NAME_LOOKUP);
5429 /* The type TYPE is being declared. If it is a class template, or a
5430 specialization of a class template, do any processing required and
5431 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5432 being declared a friend. B is the binding level at which this TYPE
5435 Returns the TYPE_DECL for TYPE, which may have been altered by this
5439 maybe_process_template_type_declaration (tree type, int is_friend,
5442 tree decl = TYPE_NAME (type);
5444 if (processing_template_parmlist)
5445 /* You can't declare a new template type in a template parameter
5446 list. But, you can declare a non-template type:
5448 template <class A*> struct S;
5450 is a forward-declaration of `A'. */
5452 else if (b->kind == sk_namespace
5453 && current_binding_level->kind != sk_namespace)
5454 /* If this new type is being injected into a containing scope,
5455 then it's not a template type. */
5459 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5460 || TREE_CODE (type) == ENUMERAL_TYPE);
5462 if (processing_template_decl)
5464 /* This may change after the call to
5465 push_template_decl_real, but we want the original value. */
5466 tree name = DECL_NAME (decl);
5468 decl = push_template_decl_real (decl, is_friend);
5469 if (decl == error_mark_node)
5470 return error_mark_node;
5472 /* If the current binding level is the binding level for the
5473 template parameters (see the comment in
5474 begin_template_parm_list) and the enclosing level is a class
5475 scope, and we're not looking at a friend, push the
5476 declaration of the member class into the class scope. In the
5477 friend case, push_template_decl will already have put the
5478 friend into global scope, if appropriate. */
5479 if (TREE_CODE (type) != ENUMERAL_TYPE
5480 && !is_friend && b->kind == sk_template_parms
5481 && b->level_chain->kind == sk_class)
5483 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5485 if (!COMPLETE_TYPE_P (current_class_type))
5487 maybe_add_class_template_decl_list (current_class_type,
5488 type, /*friend_p=*/0);
5489 /* Put this UTD in the table of UTDs for the class. */
5490 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5491 CLASSTYPE_NESTED_UTDS (current_class_type) =
5492 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5494 binding_table_insert
5495 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5504 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5505 that the NAME is a class template, the tag is processed but not pushed.
5507 The pushed scope depend on the SCOPE parameter:
5508 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5510 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5511 non-template-parameter scope. This case is needed for forward
5513 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5514 TS_GLOBAL case except that names within template-parameter scopes
5515 are not pushed at all.
5517 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5520 pushtag_1 (tree name, tree type, tag_scope scope)
5522 struct cp_binding_level *b;
5525 b = current_binding_level;
5526 while (/* Cleanup scopes are not scopes from the point of view of
5528 b->kind == sk_cleanup
5529 /* Neither are function parameter scopes. */
5530 || b->kind == sk_function_parms
5531 /* Neither are the scopes used to hold template parameters
5532 for an explicit specialization. For an ordinary template
5533 declaration, these scopes are not scopes from the point of
5534 view of the language. */
5535 || (b->kind == sk_template_parms
5536 && (b->explicit_spec_p || scope == ts_global))
5537 || (b->kind == sk_class
5538 && (scope != ts_current
5539 /* We may be defining a new type in the initializer
5540 of a static member variable. We allow this when
5541 not pedantic, and it is particularly useful for
5542 type punning via an anonymous union. */
5543 || COMPLETE_TYPE_P (b->this_entity))))
5546 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5548 /* Do C++ gratuitous typedefing. */
5549 if (identifier_type_value_1 (name) != type)
5553 tree context = TYPE_CONTEXT (type);
5557 tree cs = current_scope ();
5559 if (scope == ts_current
5560 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5562 else if (cs != NULL_TREE && TYPE_P (cs))
5563 /* When declaring a friend class of a local class, we want
5564 to inject the newly named class into the scope
5565 containing the local class, not the namespace
5567 context = decl_function_context (get_type_decl (cs));
5570 context = current_namespace;
5572 if (b->kind == sk_class
5573 || (b->kind == sk_template_parms
5574 && b->level_chain->kind == sk_class))
5577 if (current_lang_name == lang_name_java)
5578 TYPE_FOR_JAVA (type) = 1;
5580 tdef = create_implicit_typedef (name, type);
5581 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5582 if (scope == ts_within_enclosing_non_class)
5584 /* This is a friend. Make this TYPE_DECL node hidden from
5585 ordinary name lookup. Its corresponding TEMPLATE_DECL
5586 will be marked in push_template_decl_real. */
5587 retrofit_lang_decl (tdef);
5588 DECL_ANTICIPATED (tdef) = 1;
5589 DECL_FRIEND_P (tdef) = 1;
5592 decl = maybe_process_template_type_declaration
5593 (type, scope == ts_within_enclosing_non_class, b);
5594 if (decl == error_mark_node)
5597 if (b->kind == sk_class)
5599 if (!TYPE_BEING_DEFINED (current_class_type))
5600 return error_mark_node;
5602 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5603 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5604 class. But if it's a member template class, we want
5605 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5607 finish_member_declaration (decl);
5609 pushdecl_class_level (decl);
5611 else if (b->kind != sk_template_parms)
5613 decl = pushdecl_with_scope_1 (decl, b, /*is_friend=*/false);
5614 if (decl == error_mark_node)
5619 set_identifier_type_value_with_scope (name, tdef, b);
5621 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5623 /* If this is a local class, keep track of it. We need this
5624 information for name-mangling, and so that it is possible to
5625 find all function definitions in a translation unit in a
5626 convenient way. (It's otherwise tricky to find a member
5627 function definition it's only pointed to from within a local
5629 if (TYPE_CONTEXT (type)
5630 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5631 VEC_safe_push (tree, gc, local_classes, type);
5633 if (b->kind == sk_class
5634 && !COMPLETE_TYPE_P (current_class_type))
5636 maybe_add_class_template_decl_list (current_class_type,
5637 type, /*friend_p=*/0);
5639 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5640 CLASSTYPE_NESTED_UTDS (current_class_type)
5641 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5643 binding_table_insert
5644 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5647 decl = TYPE_NAME (type);
5648 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5650 /* Set type visibility now if this is a forward declaration. */
5651 TREE_PUBLIC (decl) = 1;
5652 determine_visibility (decl);
5657 /* Wrapper for pushtag_1. */
5660 pushtag (tree name, tree type, tag_scope scope)
5663 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5664 ret = pushtag_1 (name, type, scope);
5665 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5669 /* Subroutines for reverting temporarily to top-level for instantiation
5670 of templates and such. We actually need to clear out the class- and
5671 local-value slots of all identifiers, so that only the global values
5672 are at all visible. Simply setting current_binding_level to the global
5673 scope isn't enough, because more binding levels may be pushed. */
5674 struct saved_scope *scope_chain;
5676 /* If ID has not already been marked, add an appropriate binding to
5680 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5682 cxx_saved_binding *saved;
5684 if (!id || !IDENTIFIER_BINDING (id))
5687 if (IDENTIFIER_MARKED (id))
5690 IDENTIFIER_MARKED (id) = 1;
5692 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5693 saved->identifier = id;
5694 saved->binding = IDENTIFIER_BINDING (id);
5695 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5696 IDENTIFIER_BINDING (id) = NULL;
5700 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5704 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5705 for (t = names; t; t = TREE_CHAIN (t))
5709 if (TREE_CODE (t) == TREE_LIST)
5710 id = TREE_PURPOSE (t);
5714 store_binding (id, old_bindings);
5716 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5719 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5720 objects, rather than a TREE_LIST. */
5723 store_class_bindings (VEC(cp_class_binding,gc) *names,
5724 VEC(cxx_saved_binding,gc) **old_bindings)
5727 cp_class_binding *cb;
5729 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5730 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5731 store_binding (cb->identifier, old_bindings);
5732 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5736 push_to_top_level (void)
5738 struct saved_scope *s;
5739 struct cp_binding_level *b;
5740 cxx_saved_binding *sb;
5744 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5745 s = ggc_alloc_cleared_saved_scope ();
5747 b = scope_chain ? current_binding_level : 0;
5749 /* If we're in the middle of some function, save our state. */
5753 push_function_context ();
5758 if (scope_chain && previous_class_level)
5759 store_class_bindings (previous_class_level->class_shadowed,
5762 /* Have to include the global scope, because class-scope decls
5763 aren't listed anywhere useful. */
5764 for (; b; b = b->level_chain)
5768 /* Template IDs are inserted into the global level. If they were
5769 inserted into namespace level, finish_file wouldn't find them
5770 when doing pending instantiations. Therefore, don't stop at
5771 namespace level, but continue until :: . */
5772 if (global_scope_p (b))
5775 store_bindings (b->names, &s->old_bindings);
5776 /* We also need to check class_shadowed to save class-level type
5777 bindings, since pushclass doesn't fill in b->names. */
5778 if (b->kind == sk_class)
5779 store_class_bindings (b->class_shadowed, &s->old_bindings);
5781 /* Unwind type-value slots back to top level. */
5782 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5783 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5786 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, sb)
5787 IDENTIFIER_MARKED (sb->identifier) = 0;
5789 s->prev = scope_chain;
5791 s->need_pop_function_context = need_pop;
5792 s->function_decl = current_function_decl;
5793 s->unevaluated_operand = cp_unevaluated_operand;
5794 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5797 current_function_decl = NULL_TREE;
5798 current_lang_base = VEC_alloc (tree, gc, 10);
5799 current_lang_name = lang_name_cplusplus;
5800 current_namespace = global_namespace;
5801 push_class_stack ();
5802 cp_unevaluated_operand = 0;
5803 c_inhibit_evaluation_warnings = 0;
5804 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5808 pop_from_top_level_1 (void)
5810 struct saved_scope *s = scope_chain;
5811 cxx_saved_binding *saved;
5814 /* Clear out class-level bindings cache. */
5815 if (previous_class_level)
5816 invalidate_class_lookup_cache ();
5819 current_lang_base = 0;
5821 scope_chain = s->prev;
5822 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, saved)
5824 tree id = saved->identifier;
5826 IDENTIFIER_BINDING (id) = saved->binding;
5827 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5830 /* If we were in the middle of compiling a function, restore our
5832 if (s->need_pop_function_context)
5833 pop_function_context ();
5834 current_function_decl = s->function_decl;
5835 cp_unevaluated_operand = s->unevaluated_operand;
5836 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5839 /* Wrapper for pop_from_top_level_1. */
5842 pop_from_top_level (void)
5844 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5845 pop_from_top_level_1 ();
5846 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5850 /* Pop off extraneous binding levels left over due to syntax errors.
5852 We don't pop past namespaces, as they might be valid. */
5855 pop_everything (void)
5857 if (ENABLE_SCOPE_CHECKING)
5858 verbatim ("XXX entering pop_everything ()\n");
5859 while (!toplevel_bindings_p ())
5861 if (current_binding_level->kind == sk_class)
5862 pop_nested_class ();
5866 if (ENABLE_SCOPE_CHECKING)
5867 verbatim ("XXX leaving pop_everything ()\n");
5870 /* Emit debugging information for using declarations and directives.
5871 If input tree is overloaded fn then emit debug info for all
5875 cp_emit_debug_info_for_using (tree t, tree context)
5877 /* Don't try to emit any debug information if we have errors. */
5881 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5882 of a builtin function. */
5883 if (TREE_CODE (t) == FUNCTION_DECL
5884 && DECL_EXTERNAL (t)
5885 && DECL_BUILT_IN (t))
5888 /* Do not supply context to imported_module_or_decl, if
5889 it is a global namespace. */
5890 if (context == global_namespace)
5891 context = NULL_TREE;
5894 t = BASELINK_FUNCTIONS (t);
5896 /* FIXME: Handle TEMPLATE_DECLs. */
5897 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5898 if (TREE_CODE (t) != TEMPLATE_DECL)
5900 if (building_stmt_list_p ())
5901 add_stmt (build_stmt (input_location, USING_STMT, t));
5903 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5907 #include "gt-cp-name-lookup.h"