1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
31 #include "diagnostic-core.h"
34 #include "c-family/c-pragma.h"
36 #include "pointer-set.h"
38 /* The bindings for a particular name in a particular scope. */
40 struct scope_binding {
44 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
46 static cp_binding_level *innermost_nonclass_level (void);
47 static cxx_binding *binding_for_name (cp_binding_level *, tree);
48 static tree push_overloaded_decl (tree, int, bool);
49 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
51 static bool qualified_lookup_using_namespace (tree, tree,
52 struct scope_binding *, int);
53 static tree lookup_type_current_level (tree);
54 static tree push_using_directive (tree);
55 static tree lookup_extern_c_fun_in_all_ns (tree);
56 static void diagnose_name_conflict (tree, tree);
58 /* The :: namespace. */
60 tree global_namespace;
62 /* The name of the anonymous namespace, throughout this translation
64 static GTY(()) tree anonymous_namespace_name;
66 /* Initialize anonymous_namespace_name if necessary, and return it. */
69 get_anonymous_namespace_name (void)
71 if (!anonymous_namespace_name)
73 /* The anonymous namespace has to have a unique name
74 if typeinfo objects are being compared by name. */
75 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
76 anonymous_namespace_name = get_file_function_name ("N");
78 /* The demangler expects anonymous namespaces to be called
79 something starting with '_GLOBAL__N_'. */
80 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
82 return anonymous_namespace_name;
85 /* Compute the chain index of a binding_entry given the HASH value of its
86 name and the total COUNT of chains. COUNT is assumed to be a power
89 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
91 /* A free list of "binding_entry"s awaiting for re-use. */
93 static GTY((deletable)) binding_entry free_binding_entry = NULL;
95 /* Create a binding_entry object for (NAME, TYPE). */
97 static inline binding_entry
98 binding_entry_make (tree name, tree type)
102 if (free_binding_entry)
104 entry = free_binding_entry;
105 free_binding_entry = entry->chain;
108 entry = ggc_alloc_binding_entry_s ();
117 /* Put ENTRY back on the free list. */
120 binding_entry_free (binding_entry entry)
124 entry->chain = free_binding_entry;
125 free_binding_entry = entry;
129 /* The datatype used to implement the mapping from names to types at
131 struct GTY(()) binding_table_s {
132 /* Array of chains of "binding_entry"s */
133 binding_entry * GTY((length ("%h.chain_count"))) chain;
135 /* The number of chains in this table. This is the length of the
136 member "chain" considered as an array. */
139 /* Number of "binding_entry"s in this table. */
143 /* Construct TABLE with an initial CHAIN_COUNT. */
146 binding_table_construct (binding_table table, size_t chain_count)
148 table->chain_count = chain_count;
149 table->entry_count = 0;
150 table->chain = ggc_alloc_cleared_vec_binding_entry (table->chain_count);
153 /* Make TABLE's entries ready for reuse. */
156 binding_table_free (binding_table table)
164 for (i = 0, count = table->chain_count; i < count; ++i)
166 binding_entry temp = table->chain[i];
169 binding_entry entry = temp;
171 binding_entry_free (entry);
173 table->chain[i] = NULL;
175 table->entry_count = 0;
179 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
181 static inline binding_table
182 binding_table_new (size_t chain_count)
184 binding_table table = ggc_alloc_binding_table_s ();
186 binding_table_construct (table, chain_count);
190 /* Expand TABLE to twice its current chain_count. */
193 binding_table_expand (binding_table table)
195 const size_t old_chain_count = table->chain_count;
196 const size_t old_entry_count = table->entry_count;
197 const size_t new_chain_count = 2 * old_chain_count;
198 binding_entry *old_chains = table->chain;
201 binding_table_construct (table, new_chain_count);
202 for (i = 0; i < old_chain_count; ++i)
204 binding_entry entry = old_chains[i];
205 for (; entry != NULL; entry = old_chains[i])
207 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
208 const size_t j = ENTRY_INDEX (hash, new_chain_count);
210 old_chains[i] = entry->chain;
211 entry->chain = table->chain[j];
212 table->chain[j] = entry;
215 table->entry_count = old_entry_count;
218 /* Insert a binding for NAME to TYPE into TABLE. */
221 binding_table_insert (binding_table table, tree name, tree type)
223 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
224 const size_t i = ENTRY_INDEX (hash, table->chain_count);
225 binding_entry entry = binding_entry_make (name, type);
227 entry->chain = table->chain[i];
228 table->chain[i] = entry;
229 ++table->entry_count;
231 if (3 * table->chain_count < 5 * table->entry_count)
232 binding_table_expand (table);
235 /* Return the binding_entry, if any, that maps NAME. */
238 binding_table_find (binding_table table, tree name)
240 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
241 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
243 while (entry != NULL && entry->name != name)
244 entry = entry->chain;
249 /* Apply PROC -- with DATA -- to all entries in TABLE. */
252 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
254 const size_t chain_count = table->chain_count;
257 for (i = 0; i < chain_count; ++i)
259 binding_entry entry = table->chain[i];
260 for (; entry != NULL; entry = entry->chain)
265 #ifndef ENABLE_SCOPE_CHECKING
266 # define ENABLE_SCOPE_CHECKING 0
268 # define ENABLE_SCOPE_CHECKING 1
271 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
273 static GTY((deletable)) cxx_binding *free_bindings;
275 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
279 cxx_binding_init (cxx_binding *binding, tree value, tree type)
281 binding->value = value;
282 binding->type = type;
283 binding->previous = NULL;
286 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
289 cxx_binding_make (tree value, tree type)
291 cxx_binding *binding;
294 binding = free_bindings;
295 free_bindings = binding->previous;
298 binding = ggc_alloc_cxx_binding ();
300 cxx_binding_init (binding, value, type);
305 /* Put BINDING back on the free list. */
308 cxx_binding_free (cxx_binding *binding)
310 binding->scope = NULL;
311 binding->previous = free_bindings;
312 free_bindings = binding;
315 /* Create a new binding for NAME (with the indicated VALUE and TYPE
316 bindings) in the class scope indicated by SCOPE. */
319 new_class_binding (tree name, tree value, tree type, cp_binding_level *scope)
321 cp_class_binding *cb;
322 cxx_binding *binding;
324 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
326 cb->identifier = name;
327 cb->base = binding = cxx_binding_make (value, type);
328 binding->scope = scope;
332 /* Make DECL the innermost binding for ID. The LEVEL is the binding
333 level at which this declaration is being bound. */
336 push_binding (tree id, tree decl, cp_binding_level* level)
338 cxx_binding *binding;
340 if (level != class_binding_level)
342 binding = cxx_binding_make (decl, NULL_TREE);
343 binding->scope = level;
346 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
348 /* Now, fill in the binding information. */
349 binding->previous = IDENTIFIER_BINDING (id);
350 INHERITED_VALUE_BINDING_P (binding) = 0;
351 LOCAL_BINDING_P (binding) = (level != class_binding_level);
353 /* And put it on the front of the list of bindings for ID. */
354 IDENTIFIER_BINDING (id) = binding;
357 /* Remove the binding for DECL which should be the innermost binding
361 pop_binding (tree id, tree decl)
363 cxx_binding *binding;
366 /* It's easiest to write the loops that call this function without
367 checking whether or not the entities involved have names. We
368 get here for such an entity. */
371 /* Get the innermost binding for ID. */
372 binding = IDENTIFIER_BINDING (id);
374 /* The name should be bound. */
375 gcc_assert (binding != NULL);
377 /* The DECL will be either the ordinary binding or the type
378 binding for this identifier. Remove that binding. */
379 if (binding->value == decl)
380 binding->value = NULL_TREE;
383 gcc_assert (binding->type == decl);
384 binding->type = NULL_TREE;
387 if (!binding->value && !binding->type)
389 /* We're completely done with the innermost binding for this
390 identifier. Unhook it from the list of bindings. */
391 IDENTIFIER_BINDING (id) = binding->previous;
393 /* Add it to the free list. */
394 cxx_binding_free (binding);
398 /* Strip non dependent using declarations. */
401 strip_using_decl (tree decl)
403 if (decl == NULL_TREE)
406 while (TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
407 decl = USING_DECL_DECLS (decl);
411 /* BINDING records an existing declaration for a name in the current scope.
412 But, DECL is another declaration for that same identifier in the
413 same scope. This is the `struct stat' hack whereby a non-typedef
414 class name or enum-name can be bound at the same level as some other
418 A class name (9.1) or enumeration name (7.2) can be hidden by the
419 name of an object, function, or enumerator declared in the same scope.
420 If a class or enumeration name and an object, function, or enumerator
421 are declared in the same scope (in any order) with the same name, the
422 class or enumeration name is hidden wherever the object, function, or
423 enumerator name is visible.
425 It's the responsibility of the caller to check that
426 inserting this name is valid here. Returns nonzero if the new binding
430 supplement_binding_1 (cxx_binding *binding, tree decl)
432 tree bval = binding->value;
434 tree target_bval = strip_using_decl (bval);
435 tree target_decl = strip_using_decl (decl);
437 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
438 && target_decl != target_bval
439 && (TREE_CODE (target_bval) != TYPE_DECL
440 /* We allow pushing an enum multiple times in a class
441 template in order to handle late matching of underlying
442 type on an opaque-enum-declaration followed by an
444 || (TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
445 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
446 && (dependent_type_p (ENUM_UNDERLYING_TYPE
447 (TREE_TYPE (target_decl)))
448 || dependent_type_p (ENUM_UNDERLYING_TYPE
449 (TREE_TYPE (target_bval)))))))
450 /* The new name is the type name. */
451 binding->type = decl;
452 else if (/* TARGET_BVAL is null when push_class_level_binding moves
453 an inherited type-binding out of the way to make room
454 for a new value binding. */
456 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
457 has been used in a non-class scope prior declaration.
458 In that case, we should have already issued a
459 diagnostic; for graceful error recovery purpose, pretend
460 this was the intended declaration for that name. */
461 || target_bval == error_mark_node
462 /* If TARGET_BVAL is anticipated but has not yet been
463 declared, pretend it is not there at all. */
464 || (TREE_CODE (target_bval) == FUNCTION_DECL
465 && DECL_ANTICIPATED (target_bval)
466 && !DECL_HIDDEN_FRIEND_P (target_bval)))
467 binding->value = decl;
468 else if (TREE_CODE (target_bval) == TYPE_DECL
469 && DECL_ARTIFICIAL (target_bval)
470 && target_decl != target_bval
471 && (TREE_CODE (target_decl) != TYPE_DECL
472 || same_type_p (TREE_TYPE (target_decl),
473 TREE_TYPE (target_bval))))
475 /* The old binding was a type name. It was placed in
476 VALUE field because it was thought, at the point it was
477 declared, to be the only entity with such a name. Move the
478 type name into the type slot; it is now hidden by the new
480 binding->type = bval;
481 binding->value = decl;
482 binding->value_is_inherited = false;
484 else if (TREE_CODE (target_bval) == TYPE_DECL
485 && TREE_CODE (target_decl) == TYPE_DECL
486 && DECL_NAME (target_decl) == DECL_NAME (target_bval)
487 && binding->scope->kind != sk_class
488 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval))
489 /* If either type involves template parameters, we must
490 wait until instantiation. */
491 || uses_template_parms (TREE_TYPE (target_decl))
492 || uses_template_parms (TREE_TYPE (target_bval))))
493 /* We have two typedef-names, both naming the same type to have
494 the same name. In general, this is OK because of:
498 In a given scope, a typedef specifier can be used to redefine
499 the name of any type declared in that scope to refer to the
500 type to which it already refers.
502 However, in class scopes, this rule does not apply due to the
503 stricter language in [class.mem] prohibiting redeclarations of
506 /* There can be two block-scope declarations of the same variable,
507 so long as they are `extern' declarations. However, there cannot
508 be two declarations of the same static data member:
512 A member shall not be declared twice in the
513 member-specification. */
514 else if (TREE_CODE (target_decl) == VAR_DECL
515 && TREE_CODE (target_bval) == VAR_DECL
516 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval)
517 && !DECL_CLASS_SCOPE_P (target_decl))
519 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
522 else if (TREE_CODE (decl) == NAMESPACE_DECL
523 && TREE_CODE (bval) == NAMESPACE_DECL
524 && DECL_NAMESPACE_ALIAS (decl)
525 && DECL_NAMESPACE_ALIAS (bval)
526 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
529 In a declarative region, a namespace-alias-definition can be
530 used to redefine a namespace-alias declared in that declarative
531 region to refer only to the namespace to which it already
536 diagnose_name_conflict (decl, bval);
543 /* Diagnose a name conflict between DECL and BVAL. */
546 diagnose_name_conflict (tree decl, tree bval)
548 if (TREE_CODE (decl) == TREE_CODE (bval)
549 && (TREE_CODE (decl) != TYPE_DECL
550 || (DECL_ARTIFICIAL (decl) && DECL_ARTIFICIAL (bval))
551 || (!DECL_ARTIFICIAL (decl) && !DECL_ARTIFICIAL (bval)))
552 && !is_overloaded_fn (decl))
553 error ("redeclaration of %q#D", decl);
555 error ("%q#D conflicts with a previous declaration", decl);
557 inform (input_location, "previous declaration %q+#D", bval);
560 /* Wrapper for supplement_binding_1. */
563 supplement_binding (cxx_binding *binding, tree decl)
566 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
567 ret = supplement_binding_1 (binding, decl);
568 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
572 /* Add DECL to the list of things declared in B. */
575 add_decl_to_level (tree decl, cp_binding_level *b)
577 /* We used to record virtual tables as if they were ordinary
578 variables, but no longer do so. */
579 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
581 if (TREE_CODE (decl) == NAMESPACE_DECL
582 && !DECL_NAMESPACE_ALIAS (decl))
584 DECL_CHAIN (decl) = b->namespaces;
585 b->namespaces = decl;
589 /* We build up the list in reverse order, and reverse it later if
591 TREE_CHAIN (decl) = b->names;
594 /* If appropriate, add decl to separate list of statics. We
595 include extern variables because they might turn out to be
596 static later. It's OK for this list to contain a few false
598 if (b->kind == sk_namespace)
599 if ((TREE_CODE (decl) == VAR_DECL
600 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
601 || (TREE_CODE (decl) == FUNCTION_DECL
602 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
603 VEC_safe_push (tree, gc, b->static_decls, decl);
607 /* Record a decl-node X as belonging to the current lexical scope.
608 Check for errors (such as an incompatible declaration for the same
609 name already seen in the same scope). IS_FRIEND is true if X is
610 declared as a friend.
612 Returns either X or an old decl for the same name.
613 If an old decl is returned, it may have been smashed
614 to agree with what X says. */
617 pushdecl_maybe_friend_1 (tree x, bool is_friend)
621 int need_new_binding;
623 if (x == error_mark_node)
624 return error_mark_node;
626 need_new_binding = 1;
628 if (DECL_TEMPLATE_PARM_P (x))
629 /* Template parameters have no context; they are not X::T even
630 when declared within a class or namespace. */
634 if (current_function_decl && x != current_function_decl
635 /* A local declaration for a function doesn't constitute
637 && TREE_CODE (x) != FUNCTION_DECL
638 /* A local declaration for an `extern' variable is in the
639 scope of the current namespace, not the current
641 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
642 /* When parsing the parameter list of a function declarator,
643 don't set DECL_CONTEXT to an enclosing function. When we
644 push the PARM_DECLs in order to process the function body,
645 current_binding_level->this_entity will be set. */
646 && !(TREE_CODE (x) == PARM_DECL
647 && current_binding_level->kind == sk_function_parms
648 && current_binding_level->this_entity == NULL)
649 && !DECL_CONTEXT (x))
650 DECL_CONTEXT (x) = current_function_decl;
652 /* If this is the declaration for a namespace-scope function,
653 but the declaration itself is in a local scope, mark the
655 if (TREE_CODE (x) == FUNCTION_DECL
656 && DECL_NAMESPACE_SCOPE_P (x)
657 && current_function_decl
658 && x != current_function_decl)
659 DECL_LOCAL_FUNCTION_P (x) = 1;
662 name = DECL_NAME (x);
665 int different_binding_level = 0;
667 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
668 name = TREE_OPERAND (name, 0);
670 /* In case this decl was explicitly namespace-qualified, look it
671 up in its namespace context. */
672 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
673 t = namespace_binding (name, DECL_CONTEXT (x));
675 t = lookup_name_innermost_nonclass_level (name);
677 /* [basic.link] If there is a visible declaration of an entity
678 with linkage having the same name and type, ignoring entities
679 declared outside the innermost enclosing namespace scope, the
680 block scope declaration declares that same entity and
681 receives the linkage of the previous declaration. */
682 if (! t && current_function_decl && x != current_function_decl
683 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
684 && DECL_EXTERNAL (x))
686 /* Look in block scope. */
687 t = innermost_non_namespace_value (name);
688 /* Or in the innermost namespace. */
690 t = namespace_binding (name, DECL_CONTEXT (x));
691 /* Does it have linkage? Note that if this isn't a DECL, it's an
692 OVERLOAD, which is OK. */
693 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
696 different_binding_level = 1;
699 /* If we are declaring a function, and the result of name-lookup
700 was an OVERLOAD, look for an overloaded instance that is
701 actually the same as the function we are declaring. (If
702 there is one, we have to merge our declaration with the
703 previous declaration.) */
704 if (t && TREE_CODE (t) == OVERLOAD)
708 if (TREE_CODE (x) == FUNCTION_DECL)
709 for (match = t; match; match = OVL_NEXT (match))
711 if (decls_match (OVL_CURRENT (match), x))
715 /* Just choose one. */
719 t = OVL_CURRENT (match);
724 if (t && t != error_mark_node)
726 if (different_binding_level)
728 if (decls_match (x, t))
729 /* The standard only says that the local extern
730 inherits linkage from the previous decl; in
731 particular, default args are not shared. Add
732 the decl into a hash table to make sure only
733 the previous decl in this case is seen by the
736 struct cxx_int_tree_map *h;
739 TREE_PUBLIC (x) = TREE_PUBLIC (t);
741 if (cp_function_chain->extern_decl_map == NULL)
742 cp_function_chain->extern_decl_map
743 = htab_create_ggc (20, cxx_int_tree_map_hash,
744 cxx_int_tree_map_eq, NULL);
746 h = ggc_alloc_cxx_int_tree_map ();
747 h->uid = DECL_UID (x);
749 loc = htab_find_slot_with_hash
750 (cp_function_chain->extern_decl_map, h,
752 *(struct cxx_int_tree_map **) loc = h;
755 else if (TREE_CODE (t) == PARM_DECL)
757 /* Check for duplicate params. */
758 tree d = duplicate_decls (x, t, is_friend);
762 else if ((DECL_EXTERN_C_FUNCTION_P (x)
763 || DECL_FUNCTION_TEMPLATE_P (x))
764 && is_overloaded_fn (t))
765 /* Don't do anything just yet. */;
766 else if (t == wchar_decl_node)
768 if (! DECL_IN_SYSTEM_HEADER (x))
769 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
772 /* Throw away the redeclaration. */
777 tree olddecl = duplicate_decls (x, t, is_friend);
779 /* If the redeclaration failed, we can stop at this
781 if (olddecl == error_mark_node)
782 return error_mark_node;
786 if (TREE_CODE (t) == TYPE_DECL)
787 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
791 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
793 /* A redeclaration of main, but not a duplicate of the
798 This function shall not be overloaded. */
799 error ("invalid redeclaration of %q+D", t);
801 /* We don't try to push this declaration since that
808 /* If x has C linkage-specification, (extern "C"),
809 lookup its binding, in case it's already bound to an object.
810 The lookup is done in all namespaces.
811 If we find an existing binding, make sure it has the same
812 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
813 if ((TREE_CODE (x) == FUNCTION_DECL)
814 && DECL_EXTERN_C_P (x)
815 /* We should ignore declarations happening in system headers. */
816 && !DECL_ARTIFICIAL (x)
817 && !DECL_IN_SYSTEM_HEADER (x))
819 tree previous = lookup_extern_c_fun_in_all_ns (x);
821 && !DECL_ARTIFICIAL (previous)
822 && !DECL_IN_SYSTEM_HEADER (previous)
823 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
825 /* In case either x or previous is declared to throw an exception,
826 make sure both exception specifications are equal. */
827 if (decls_match (x, previous))
829 tree x_exception_spec = NULL_TREE;
830 tree previous_exception_spec = NULL_TREE;
833 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
834 previous_exception_spec =
835 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
836 if (!comp_except_specs (previous_exception_spec,
840 pedwarn (input_location, 0,
841 "declaration of %q#D with C language linkage",
843 pedwarn (input_location, 0,
844 "conflicts with previous declaration %q+#D",
846 pedwarn (input_location, 0,
847 "due to different exception specifications");
848 return error_mark_node;
850 if (DECL_ASSEMBLER_NAME_SET_P (previous))
851 SET_DECL_ASSEMBLER_NAME (x,
852 DECL_ASSEMBLER_NAME (previous));
856 pedwarn (input_location, 0,
857 "declaration of %q#D with C language linkage", x);
858 pedwarn (input_location, 0,
859 "conflicts with previous declaration %q+#D",
865 check_template_shadow (x);
867 /* If this is a function conjured up by the back end, massage it
868 so it looks friendly. */
869 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
871 retrofit_lang_decl (x);
872 SET_DECL_LANGUAGE (x, lang_c);
876 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
878 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
879 if (!namespace_bindings_p ())
880 /* We do not need to create a binding for this name;
881 push_overloaded_decl will have already done so if
883 need_new_binding = 0;
885 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
887 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
889 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
892 if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
893 check_default_args (t);
895 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
898 /* If declaring a type as a typedef, copy the type (unless we're
899 at line 0), and install this TYPE_DECL as the new type's typedef
900 name. See the extensive comment of set_underlying_type (). */
901 if (TREE_CODE (x) == TYPE_DECL)
903 tree type = TREE_TYPE (x);
905 if (DECL_IS_BUILTIN (x)
906 || (TREE_TYPE (x) != error_mark_node
907 && TYPE_NAME (type) != x
908 /* We don't want to copy the type when all we're
909 doing is making a TYPE_DECL for the purposes of
911 && (!TYPE_NAME (type)
912 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
913 set_underlying_type (x);
915 if (type != error_mark_node
917 && TYPE_IDENTIFIER (type))
918 set_identifier_type_value (DECL_NAME (x), x);
920 /* If this is a locally defined typedef in a function that
921 is not a template instantation, record it to implement
922 -Wunused-local-typedefs. */
923 if (current_instantiation () == NULL
924 || (current_instantiation ()->decl != current_function_decl))
925 record_locally_defined_typedef (x);
928 /* Multiple external decls of the same identifier ought to match.
930 We get warnings about inline functions where they are defined.
931 We get warnings about other functions from push_overloaded_decl.
933 Avoid duplicate warnings where they are used. */
934 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
938 decl = IDENTIFIER_NAMESPACE_VALUE (name);
939 if (decl && TREE_CODE (decl) == OVERLOAD)
940 decl = OVL_FUNCTION (decl);
942 if (decl && decl != error_mark_node
943 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
944 /* If different sort of thing, we already gave an error. */
945 && TREE_CODE (decl) == TREE_CODE (x)
946 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
948 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
949 permerror (input_location, "previous external decl of %q+#D", decl);
953 if (TREE_CODE (x) == FUNCTION_DECL
955 && !flag_friend_injection)
957 /* This is a new declaration of a friend function, so hide
958 it from ordinary function lookup. */
959 DECL_ANTICIPATED (x) = 1;
960 DECL_HIDDEN_FRIEND_P (x) = 1;
963 /* This name is new in its binding level.
964 Install the new declaration and return it. */
965 if (namespace_bindings_p ())
967 /* Install a global value. */
969 /* If the first global decl has external linkage,
970 warn if we later see static one. */
971 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
972 TREE_PUBLIC (name) = 1;
974 /* Bind the name for the entity. */
975 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
977 && (TREE_CODE (x) == TYPE_DECL
978 || TREE_CODE (x) == VAR_DECL
979 || TREE_CODE (x) == NAMESPACE_DECL
980 || TREE_CODE (x) == CONST_DECL
981 || TREE_CODE (x) == TEMPLATE_DECL))
982 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
984 /* If new decl is `static' and an `extern' was seen previously,
986 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
987 warn_extern_redeclared_static (x, t);
991 /* Here to install a non-global value. */
992 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
993 tree oldlocal = NULL_TREE;
994 cp_binding_level *oldscope = NULL;
995 cxx_binding *oldbinding = outer_binding (name, NULL, true);
998 oldlocal = oldbinding->value;
999 oldscope = oldbinding->scope;
1002 if (need_new_binding)
1004 push_local_binding (name, x, 0);
1005 /* Because push_local_binding will hook X on to the
1006 current_binding_level's name list, we don't want to
1007 do that again below. */
1008 need_new_binding = 0;
1011 /* If this is a TYPE_DECL, push it into the type value slot. */
1012 if (TREE_CODE (x) == TYPE_DECL)
1013 set_identifier_type_value (name, x);
1015 /* Clear out any TYPE_DECL shadowed by a namespace so that
1016 we won't think this is a type. The C struct hack doesn't
1017 go through namespaces. */
1018 if (TREE_CODE (x) == NAMESPACE_DECL)
1019 set_identifier_type_value (name, NULL_TREE);
1026 && TREE_CODE (oldlocal) == VAR_DECL
1027 && DECL_DEAD_FOR_LOCAL (oldlocal))
1028 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
1030 if (oldlocal == NULL_TREE)
1031 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
1034 /* If this is an extern function declaration, see if we
1035 have a global definition or declaration for the function. */
1036 if (oldlocal == NULL_TREE
1037 && DECL_EXTERNAL (x)
1038 && oldglobal != NULL_TREE
1039 && TREE_CODE (x) == FUNCTION_DECL
1040 && TREE_CODE (oldglobal) == FUNCTION_DECL)
1042 /* We have one. Their types must agree. */
1043 if (decls_match (x, oldglobal))
1047 warning (0, "extern declaration of %q#D doesn%'t match", x);
1048 warning (0, "global declaration %q+#D", oldglobal);
1051 /* If we have a local external declaration,
1052 and no file-scope declaration has yet been seen,
1053 then if we later have a file-scope decl it must not be static. */
1054 if (oldlocal == NULL_TREE
1055 && oldglobal == NULL_TREE
1056 && DECL_EXTERNAL (x)
1058 TREE_PUBLIC (name) = 1;
1060 /* Don't complain about the parms we push and then pop
1061 while tentatively parsing a function declarator. */
1062 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1065 /* Warn if shadowing an argument at the top level of the body. */
1066 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1067 /* Inline decls shadow nothing. */
1068 && !DECL_FROM_INLINE (x)
1069 && (TREE_CODE (oldlocal) == PARM_DECL
1070 || TREE_CODE (oldlocal) == VAR_DECL
1071 /* If the old decl is a type decl, only warn if the
1072 old decl is an explicit typedef or if both the old
1073 and new decls are type decls. */
1074 || (TREE_CODE (oldlocal) == TYPE_DECL
1075 && (!DECL_ARTIFICIAL (oldlocal)
1076 || TREE_CODE (x) == TYPE_DECL)))
1077 /* Don't check for internally generated vars unless
1078 it's an implicit typedef (see create_implicit_typedef
1080 && (!DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x)))
1082 bool nowarn = false;
1084 /* Don't complain if it's from an enclosing function. */
1085 if (DECL_CONTEXT (oldlocal) == current_function_decl
1086 && TREE_CODE (x) != PARM_DECL
1087 && TREE_CODE (oldlocal) == PARM_DECL)
1089 /* Go to where the parms should be and see if we find
1091 cp_binding_level *b = current_binding_level->level_chain;
1093 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1094 /* Skip the ctor/dtor cleanup level. */
1098 if (b->kind == sk_function_parms)
1100 error ("declaration of %q#D shadows a parameter", x);
1105 /* The local structure or class can't use parameters of
1106 the containing function anyway. */
1107 if (DECL_CONTEXT (oldlocal) != current_function_decl)
1109 cp_binding_level *scope = current_binding_level;
1110 tree context = DECL_CONTEXT (oldlocal);
1111 for (; scope; scope = scope->level_chain)
1113 if (scope->kind == sk_function_parms
1114 && scope->this_entity == context)
1116 if (scope->kind == sk_class
1117 && !LAMBDA_TYPE_P (scope->this_entity))
1124 /* Error if redeclaring a local declared in a
1125 for-init-statement or in the condition of an if or
1126 switch statement when the new declaration is in the
1127 outermost block of the controlled statement.
1128 Redeclaring a variable from a for or while condition is
1129 detected elsewhere. */
1130 else if (TREE_CODE (oldlocal) == VAR_DECL
1131 && oldscope == current_binding_level->level_chain
1132 && (oldscope->kind == sk_cond
1133 || oldscope->kind == sk_for))
1135 error ("redeclaration of %q#D", x);
1136 error ("%q+#D previously declared here", oldlocal);
1139 if (warn_shadow && !nowarn)
1141 if (TREE_CODE (oldlocal) == PARM_DECL)
1142 warning_at (input_location, OPT_Wshadow,
1143 "declaration of %q#D shadows a parameter", x);
1144 else if (is_capture_proxy (oldlocal))
1145 warning_at (input_location, OPT_Wshadow,
1146 "declaration of %qD shadows a lambda capture",
1149 warning_at (input_location, OPT_Wshadow,
1150 "declaration of %qD shadows a previous local",
1152 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1153 "shadowed declaration is here");
1157 /* Maybe warn if shadowing something else. */
1158 else if (warn_shadow && !DECL_EXTERNAL (x)
1159 /* No shadow warnings for internally generated vars unless
1160 it's an implicit typedef (see create_implicit_typedef
1162 && (! DECL_ARTIFICIAL (x) || DECL_IMPLICIT_TYPEDEF_P (x))
1163 /* No shadow warnings for vars made for inlining. */
1164 && ! DECL_FROM_INLINE (x))
1168 if (current_class_ptr)
1169 member = lookup_member (current_class_type,
1172 /*want_type=*/false,
1173 tf_warning_or_error);
1177 if (member && !TREE_STATIC (member))
1179 /* Location of previous decl is not useful in this case. */
1180 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1183 else if (oldglobal != NULL_TREE
1184 && (TREE_CODE (oldglobal) == VAR_DECL
1185 /* If the old decl is a type decl, only warn if the
1186 old decl is an explicit typedef or if both the
1187 old and new decls are type decls. */
1188 || (TREE_CODE (oldglobal) == TYPE_DECL
1189 && (!DECL_ARTIFICIAL (oldglobal)
1190 || TREE_CODE (x) == TYPE_DECL))))
1191 /* XXX shadow warnings in outer-more namespaces */
1193 warning_at (input_location, OPT_Wshadow,
1194 "declaration of %qD shadows a global declaration", x);
1195 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1196 "shadowed declaration is here");
1201 if (TREE_CODE (x) == VAR_DECL)
1202 maybe_register_incomplete_var (x);
1205 if (need_new_binding)
1206 add_decl_to_level (x,
1207 DECL_NAMESPACE_SCOPE_P (x)
1208 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1209 : current_binding_level);
1214 /* Wrapper for pushdecl_maybe_friend_1. */
1217 pushdecl_maybe_friend (tree x, bool is_friend)
1220 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
1221 ret = pushdecl_maybe_friend_1 (x, is_friend);
1222 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
1226 /* Record a decl-node X as belonging to the current lexical scope. */
1231 return pushdecl_maybe_friend (x, false);
1234 /* Enter DECL into the symbol table, if that's appropriate. Returns
1235 DECL, or a modified version thereof. */
1238 maybe_push_decl (tree decl)
1240 tree type = TREE_TYPE (decl);
1242 /* Add this decl to the current binding level, but not if it comes
1243 from another scope, e.g. a static member variable. TEM may equal
1244 DECL or it may be a previous decl of the same name. */
1245 if (decl == error_mark_node
1246 || (TREE_CODE (decl) != PARM_DECL
1247 && DECL_CONTEXT (decl) != NULL_TREE
1248 /* Definitions of namespace members outside their namespace are
1250 && !DECL_NAMESPACE_SCOPE_P (decl))
1251 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1252 || type == unknown_type_node
1253 /* The declaration of a template specialization does not affect
1254 the functions available for overload resolution, so we do not
1256 || (TREE_CODE (decl) == FUNCTION_DECL
1257 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1260 return pushdecl (decl);
1263 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1264 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1265 doesn't really belong to this binding level, that it got here
1266 through a using-declaration. */
1269 push_local_binding (tree id, tree decl, int flags)
1271 cp_binding_level *b;
1273 /* Skip over any local classes. This makes sense if we call
1274 push_local_binding with a friend decl of a local class. */
1275 b = innermost_nonclass_level ();
1277 if (lookup_name_innermost_nonclass_level (id))
1279 /* Supplement the existing binding. */
1280 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1281 /* It didn't work. Something else must be bound at this
1282 level. Do not add DECL to the list of things to pop
1287 /* Create a new binding. */
1288 push_binding (id, decl, b);
1290 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1291 /* We must put the OVERLOAD into a TREE_LIST since the
1292 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1293 decls that got here through a using-declaration. */
1294 decl = build_tree_list (NULL_TREE, decl);
1296 /* And put DECL on the list of things declared by the current
1298 add_decl_to_level (decl, b);
1301 /* Check to see whether or not DECL is a variable that would have been
1302 in scope under the ARM, but is not in scope under the ANSI/ISO
1303 standard. If so, issue an error message. If name lookup would
1304 work in both cases, but return a different result, this function
1305 returns the result of ANSI/ISO lookup. Otherwise, it returns
1309 check_for_out_of_scope_variable (tree decl)
1313 /* We only care about out of scope variables. */
1314 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1317 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1318 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1319 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1320 && DECL_DEAD_FOR_LOCAL (shadowed))
1321 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1322 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1324 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1327 if (!DECL_ERROR_REPORTED (decl))
1329 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1330 warning (0, " matches this %q+D under ISO standard rules",
1332 warning (0, " matches this %q+D under old rules", decl);
1333 DECL_ERROR_REPORTED (decl) = 1;
1338 /* If we have already complained about this declaration, there's no
1339 need to do it again. */
1340 if (DECL_ERROR_REPORTED (decl))
1343 DECL_ERROR_REPORTED (decl) = 1;
1345 if (TREE_TYPE (decl) == error_mark_node)
1348 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1350 error ("name lookup of %qD changed for ISO %<for%> scoping",
1352 error (" cannot use obsolete binding at %q+D because "
1353 "it has a destructor", decl);
1354 return error_mark_node;
1358 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1360 if (flag_permissive)
1361 permerror (input_location, " using obsolete binding at %q+D", decl);
1367 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1376 /* true means unconditionally make a BLOCK for the next level pushed. */
1378 static bool keep_next_level_flag;
1380 static int binding_depth = 0;
1387 for (i = 0; i < depth * 2; i++)
1391 /* Return a string describing the kind of SCOPE we have. */
1393 cp_binding_level_descriptor (cp_binding_level *scope)
1395 /* The order of this table must match the "scope_kind"
1397 static const char* scope_kind_names[] = {
1403 "function-parameter-scope",
1406 "template-parameter-scope",
1407 "template-explicit-spec-scope"
1409 const scope_kind kind = scope->explicit_spec_p
1410 ? sk_template_spec : scope->kind;
1412 return scope_kind_names[kind];
1415 /* Output a debugging information about SCOPE when performing
1418 cp_binding_level_debug (cp_binding_level *scope, int line, const char *action)
1420 const char *desc = cp_binding_level_descriptor (scope);
1421 if (scope->this_entity)
1422 verbatim ("%s %s(%E) %p %d\n", action, desc,
1423 scope->this_entity, (void *) scope, line);
1425 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1428 /* Return the estimated initial size of the hashtable of a NAMESPACE
1431 static inline size_t
1432 namespace_scope_ht_size (tree ns)
1434 tree name = DECL_NAME (ns);
1436 return name == std_identifier
1437 ? NAMESPACE_STD_HT_SIZE
1438 : (name == global_scope_name
1439 ? GLOBAL_SCOPE_HT_SIZE
1440 : NAMESPACE_ORDINARY_HT_SIZE);
1443 /* A chain of binding_level structures awaiting reuse. */
1445 static GTY((deletable)) cp_binding_level *free_binding_level;
1447 /* Insert SCOPE as the innermost binding level. */
1450 push_binding_level (cp_binding_level *scope)
1452 /* Add it to the front of currently active scopes stack. */
1453 scope->level_chain = current_binding_level;
1454 current_binding_level = scope;
1455 keep_next_level_flag = false;
1457 if (ENABLE_SCOPE_CHECKING)
1459 scope->binding_depth = binding_depth;
1460 indent (binding_depth);
1461 cp_binding_level_debug (scope, input_line, "push");
1466 /* Create a new KIND scope and make it the top of the active scopes stack.
1467 ENTITY is the scope of the associated C++ entity (namespace, class,
1468 function, C++0x enumeration); it is NULL otherwise. */
1471 begin_scope (scope_kind kind, tree entity)
1473 cp_binding_level *scope;
1475 /* Reuse or create a struct for this binding level. */
1476 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1478 scope = free_binding_level;
1479 memset (scope, 0, sizeof (cp_binding_level));
1480 free_binding_level = scope->level_chain;
1483 scope = ggc_alloc_cleared_cp_binding_level ();
1485 scope->this_entity = entity;
1486 scope->more_cleanups_ok = true;
1493 case sk_template_spec:
1494 scope->explicit_spec_p = true;
1495 kind = sk_template_parms;
1497 case sk_template_parms:
1504 case sk_scoped_enum:
1505 case sk_function_parms:
1507 scope->keep = keep_next_level_flag;
1511 NAMESPACE_LEVEL (entity) = scope;
1512 scope->static_decls =
1513 VEC_alloc (tree, gc,
1514 DECL_NAME (entity) == std_identifier
1515 || DECL_NAME (entity) == global_scope_name
1520 /* Should not happen. */
1526 push_binding_level (scope);
1531 /* We're about to leave current scope. Pop the top of the stack of
1532 currently active scopes. Return the enclosing scope, now active. */
1537 cp_binding_level *scope = current_binding_level;
1539 if (scope->kind == sk_namespace && class_binding_level)
1540 current_binding_level = class_binding_level;
1542 /* We cannot leave a scope, if there are none left. */
1543 if (NAMESPACE_LEVEL (global_namespace))
1544 gcc_assert (!global_scope_p (scope));
1546 if (ENABLE_SCOPE_CHECKING)
1548 indent (--binding_depth);
1549 cp_binding_level_debug (scope, input_line, "leave");
1552 /* Move one nesting level up. */
1553 current_binding_level = scope->level_chain;
1555 /* Namespace-scopes are left most probably temporarily, not
1556 completely; they can be reopened later, e.g. in namespace-extension
1557 or any name binding activity that requires us to resume a
1558 namespace. For classes, we cache some binding levels. For other
1559 scopes, we just make the structure available for reuse. */
1560 if (scope->kind != sk_namespace
1561 && scope->kind != sk_class)
1563 scope->level_chain = free_binding_level;
1564 gcc_assert (!ENABLE_SCOPE_CHECKING
1565 || scope->binding_depth == binding_depth);
1566 free_binding_level = scope;
1569 /* Find the innermost enclosing class scope, and reset
1570 CLASS_BINDING_LEVEL appropriately. */
1571 if (scope->kind == sk_class)
1573 class_binding_level = NULL;
1574 for (scope = current_binding_level; scope; scope = scope->level_chain)
1575 if (scope->kind == sk_class)
1577 class_binding_level = scope;
1582 return current_binding_level;
1586 resume_scope (cp_binding_level* b)
1588 /* Resuming binding levels is meant only for namespaces,
1589 and those cannot nest into classes. */
1590 gcc_assert (!class_binding_level);
1591 /* Also, resuming a non-directly nested namespace is a no-no. */
1592 gcc_assert (b->level_chain == current_binding_level);
1593 current_binding_level = b;
1594 if (ENABLE_SCOPE_CHECKING)
1596 b->binding_depth = binding_depth;
1597 indent (binding_depth);
1598 cp_binding_level_debug (b, input_line, "resume");
1603 /* Return the innermost binding level that is not for a class scope. */
1605 static cp_binding_level *
1606 innermost_nonclass_level (void)
1608 cp_binding_level *b;
1610 b = current_binding_level;
1611 while (b->kind == sk_class)
1617 /* We're defining an object of type TYPE. If it needs a cleanup, but
1618 we're not allowed to add any more objects with cleanups to the current
1619 scope, create a new binding level. */
1622 maybe_push_cleanup_level (tree type)
1624 if (type != error_mark_node
1625 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1626 && current_binding_level->more_cleanups_ok == 0)
1628 begin_scope (sk_cleanup, NULL);
1629 current_binding_level->statement_list = push_stmt_list ();
1633 /* Return true if we are in the global binding level. */
1636 global_bindings_p (void)
1638 return global_scope_p (current_binding_level);
1641 /* True if we are currently in a toplevel binding level. This
1642 means either the global binding level or a namespace in a toplevel
1643 binding level. Since there are no non-toplevel namespace levels,
1644 this really means any namespace or template parameter level. We
1645 also include a class whose context is toplevel. */
1648 toplevel_bindings_p (void)
1650 cp_binding_level *b = innermost_nonclass_level ();
1652 return b->kind == sk_namespace || b->kind == sk_template_parms;
1655 /* True if this is a namespace scope, or if we are defining a class
1656 which is itself at namespace scope, or whose enclosing class is
1657 such a class, etc. */
1660 namespace_bindings_p (void)
1662 cp_binding_level *b = innermost_nonclass_level ();
1664 return b->kind == sk_namespace;
1667 /* True if the innermost non-class scope is a block scope. */
1670 local_bindings_p (void)
1672 cp_binding_level *b = innermost_nonclass_level ();
1673 return b->kind < sk_function_parms || b->kind == sk_omp;
1676 /* True if the current level needs to have a BLOCK made. */
1681 return (current_binding_level->blocks != NULL_TREE
1682 || current_binding_level->keep
1683 || current_binding_level->kind == sk_cleanup
1684 || current_binding_level->names != NULL_TREE
1685 || current_binding_level->using_directives);
1688 /* Returns the kind of the innermost scope. */
1691 innermost_scope_kind (void)
1693 return current_binding_level->kind;
1696 /* Returns true if this scope was created to store template parameters. */
1699 template_parm_scope_p (void)
1701 return innermost_scope_kind () == sk_template_parms;
1704 /* If KEEP is true, make a BLOCK node for the next binding level,
1705 unconditionally. Otherwise, use the normal logic to decide whether
1706 or not to create a BLOCK. */
1709 keep_next_level (bool keep)
1711 keep_next_level_flag = keep;
1714 /* Return the list of declarations of the current level.
1715 Note that this list is in reverse order unless/until
1716 you nreverse it; and when you do nreverse it, you must
1717 store the result back using `storedecls' or you will lose. */
1722 return current_binding_level->names;
1725 /* Return how many function prototypes we are currently nested inside. */
1728 function_parm_depth (void)
1731 cp_binding_level *b;
1733 for (b = current_binding_level;
1734 b->kind == sk_function_parms;
1741 /* For debugging. */
1742 static int no_print_functions = 0;
1743 static int no_print_builtins = 0;
1746 print_binding_level (cp_binding_level* lvl)
1750 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1751 if (lvl->more_cleanups_ok)
1752 fprintf (stderr, " more-cleanups-ok");
1753 if (lvl->have_cleanups)
1754 fprintf (stderr, " have-cleanups");
1755 fprintf (stderr, "\n");
1758 fprintf (stderr, " names:\t");
1759 /* We can probably fit 3 names to a line? */
1760 for (t = lvl->names; t; t = TREE_CHAIN (t))
1762 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1764 if (no_print_builtins
1765 && (TREE_CODE (t) == TYPE_DECL)
1766 && DECL_IS_BUILTIN (t))
1769 /* Function decls tend to have longer names. */
1770 if (TREE_CODE (t) == FUNCTION_DECL)
1777 fprintf (stderr, "\n\t");
1780 print_node_brief (stderr, "", t, 0);
1781 if (t == error_mark_node)
1785 fprintf (stderr, "\n");
1787 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1790 cp_class_binding *b;
1791 fprintf (stderr, " class-shadowed:");
1792 FOR_EACH_VEC_ELT (cp_class_binding, lvl->class_shadowed, i, b)
1793 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1794 fprintf (stderr, "\n");
1796 if (lvl->type_shadowed)
1798 fprintf (stderr, " type-shadowed:");
1799 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1801 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1803 fprintf (stderr, "\n");
1808 print_other_binding_stack (cp_binding_level *stack)
1810 cp_binding_level *level;
1811 for (level = stack; !global_scope_p (level); level = level->level_chain)
1813 fprintf (stderr, "binding level %p\n", (void *) level);
1814 print_binding_level (level);
1819 print_binding_stack (void)
1821 cp_binding_level *b;
1822 fprintf (stderr, "current_binding_level=%p\n"
1823 "class_binding_level=%p\n"
1824 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1825 (void *) current_binding_level, (void *) class_binding_level,
1826 (void *) NAMESPACE_LEVEL (global_namespace));
1827 if (class_binding_level)
1829 for (b = class_binding_level; b; b = b->level_chain)
1830 if (b == current_binding_level)
1833 b = class_binding_level;
1835 b = current_binding_level;
1838 b = current_binding_level;
1839 print_other_binding_stack (b);
1840 fprintf (stderr, "global:\n");
1841 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1844 /* Return the type associated with ID. */
1847 identifier_type_value_1 (tree id)
1849 /* There is no type with that name, anywhere. */
1850 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1852 /* This is not the type marker, but the real thing. */
1853 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1854 return REAL_IDENTIFIER_TYPE_VALUE (id);
1855 /* Have to search for it. It must be on the global level, now.
1856 Ask lookup_name not to return non-types. */
1857 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1859 return TREE_TYPE (id);
1863 /* Wrapper for identifier_type_value_1. */
1866 identifier_type_value (tree id)
1869 timevar_start (TV_NAME_LOOKUP);
1870 ret = identifier_type_value_1 (id);
1871 timevar_stop (TV_NAME_LOOKUP);
1876 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1877 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1880 identifier_global_value (tree t)
1882 return IDENTIFIER_GLOBAL_VALUE (t);
1885 /* Push a definition of struct, union or enum tag named ID. into
1886 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1887 the tag ID is not already defined. */
1890 set_identifier_type_value_with_scope (tree id, tree decl, cp_binding_level *b)
1894 if (b->kind != sk_namespace)
1896 /* Shadow the marker, not the real thing, so that the marker
1897 gets restored later. */
1898 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1900 = tree_cons (id, old_type_value, b->type_shadowed);
1901 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1902 TREE_TYPE (b->type_shadowed) = type;
1906 cxx_binding *binding =
1907 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1910 supplement_binding (binding, decl);
1912 binding->value = decl;
1914 /* Store marker instead of real type. */
1915 type = global_type_node;
1917 SET_IDENTIFIER_TYPE_VALUE (id, type);
1920 /* As set_identifier_type_value_with_scope, but using
1921 current_binding_level. */
1924 set_identifier_type_value (tree id, tree decl)
1926 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1929 /* Return the name for the constructor (or destructor) for the
1930 specified class TYPE. When given a template, this routine doesn't
1931 lose the specialization. */
1934 constructor_name_full (tree type)
1936 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1939 /* Return the name for the constructor (or destructor) for the
1940 specified class. When given a template, return the plain
1941 unspecialized name. */
1944 constructor_name (tree type)
1947 name = constructor_name_full (type);
1948 if (IDENTIFIER_TEMPLATE (name))
1949 name = IDENTIFIER_TEMPLATE (name);
1953 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1954 which must be a class type. */
1957 constructor_name_p (tree name, tree type)
1961 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1966 if (TREE_CODE (name) != IDENTIFIER_NODE)
1969 ctor_name = constructor_name_full (type);
1970 if (name == ctor_name)
1972 if (IDENTIFIER_TEMPLATE (ctor_name)
1973 && name == IDENTIFIER_TEMPLATE (ctor_name))
1978 /* Counter used to create anonymous type names. */
1980 static GTY(()) int anon_cnt;
1982 /* Return an IDENTIFIER which can be used as a name for
1983 anonymous structs and unions. */
1986 make_anon_name (void)
1990 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1991 return get_identifier (buf);
1994 /* This code is practically identical to that for creating
1995 anonymous names, but is just used for lambdas instead. This is necessary
1996 because anonymous names are recognized and cannot be passed to template
1998 /* FIXME is this still necessary? */
2000 static GTY(()) int lambda_cnt = 0;
2003 make_lambda_name (void)
2007 sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
2008 return get_identifier (buf);
2011 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
2013 static inline cxx_binding *
2014 find_binding (cp_binding_level *scope, cxx_binding *binding)
2016 for (; binding != NULL; binding = binding->previous)
2017 if (binding->scope == scope)
2020 return (cxx_binding *)0;
2023 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
2025 static inline cxx_binding *
2026 cp_binding_level_find_binding_for_name (cp_binding_level *scope, tree name)
2028 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
2031 /* Fold-in case where NAME is used only once. */
2032 if (scope == b->scope && b->previous == NULL)
2034 return find_binding (scope, b);
2039 /* Always returns a binding for name in scope. If no binding is
2040 found, make a new one. */
2042 static cxx_binding *
2043 binding_for_name (cp_binding_level *scope, tree name)
2045 cxx_binding *result;
2047 result = cp_binding_level_find_binding_for_name (scope, name);
2050 /* Not found, make a new one. */
2051 result = cxx_binding_make (NULL, NULL);
2052 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
2053 result->scope = scope;
2054 result->is_local = false;
2055 result->value_is_inherited = false;
2056 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
2060 /* Walk through the bindings associated to the name of FUNCTION,
2061 and return the first declaration of a function with a
2062 "C" linkage specification, a.k.a 'extern "C"'.
2063 This function looks for the binding, regardless of which scope it
2064 has been defined in. It basically looks in all the known scopes.
2065 Note that this function does not lookup for bindings of builtin functions
2066 or for functions declared in system headers. */
2068 lookup_extern_c_fun_in_all_ns (tree function)
2073 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
2075 name = DECL_NAME (function);
2076 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
2078 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2080 iter = iter->previous)
2083 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2085 tree decl = OVL_CURRENT (ovl);
2087 && TREE_CODE (decl) == FUNCTION_DECL
2088 && DECL_EXTERN_C_P (decl)
2089 && !DECL_ARTIFICIAL (decl))
2098 /* Returns a list of C-linkage decls with the name NAME. */
2101 c_linkage_bindings (tree name)
2103 tree decls = NULL_TREE;
2106 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
2108 iter = iter->previous)
2111 for (ovl = iter->value; ovl; ovl = OVL_NEXT (ovl))
2113 tree decl = OVL_CURRENT (ovl);
2115 && DECL_EXTERN_C_P (decl)
2116 && !DECL_ARTIFICIAL (decl))
2118 if (decls == NULL_TREE)
2121 decls = tree_cons (NULL_TREE, decl, decls);
2128 /* Insert another USING_DECL into the current binding level, returning
2129 this declaration. If this is a redeclaration, do nothing, and
2130 return NULL_TREE if this not in namespace scope (in namespace
2131 scope, a using decl might extend any previous bindings). */
2134 push_using_decl_1 (tree scope, tree name)
2138 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
2139 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2140 for (decl = current_binding_level->usings; decl; decl = DECL_CHAIN (decl))
2141 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
2144 return namespace_bindings_p () ? decl : NULL_TREE;
2145 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
2146 USING_DECL_SCOPE (decl) = scope;
2147 DECL_CHAIN (decl) = current_binding_level->usings;
2148 current_binding_level->usings = decl;
2152 /* Wrapper for push_using_decl_1. */
2155 push_using_decl (tree scope, tree name)
2158 timevar_start (TV_NAME_LOOKUP);
2159 ret = push_using_decl_1 (scope, name);
2160 timevar_stop (TV_NAME_LOOKUP);
2164 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
2165 caller to set DECL_CONTEXT properly.
2167 Note that this must only be used when X will be the new innermost
2168 binding for its name, as we tack it onto the front of IDENTIFIER_BINDING
2169 without checking to see if the current IDENTIFIER_BINDING comes from a
2170 closer binding level than LEVEL. */
2173 pushdecl_with_scope_1 (tree x, cp_binding_level *level, bool is_friend)
2175 cp_binding_level *b;
2176 tree function_decl = current_function_decl;
2178 current_function_decl = NULL_TREE;
2179 if (level->kind == sk_class)
2181 b = class_binding_level;
2182 class_binding_level = level;
2183 pushdecl_class_level (x);
2184 class_binding_level = b;
2188 b = current_binding_level;
2189 current_binding_level = level;
2190 x = pushdecl_maybe_friend (x, is_friend);
2191 current_binding_level = b;
2193 current_function_decl = function_decl;
2197 /* Wrapper for pushdecl_with_scope_1. */
2200 pushdecl_with_scope (tree x, cp_binding_level *level, bool is_friend)
2203 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2204 ret = pushdecl_with_scope_1 (x, level, is_friend);
2205 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2210 /* DECL is a FUNCTION_DECL for a non-member function, which may have
2211 other definitions already in place. We get around this by making
2212 the value of the identifier point to a list of all the things that
2213 want to be referenced by that name. It is then up to the users of
2214 that name to decide what to do with that list.
2216 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2217 DECL_TEMPLATE_RESULT. It is dealt with the same way.
2219 FLAGS is a bitwise-or of the following values:
2220 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2222 PUSH_USING: DECL is being pushed as the result of a using
2225 IS_FRIEND is true if this is a friend declaration.
2227 The value returned may be a previous declaration if we guessed wrong
2228 about what language DECL should belong to (C or C++). Otherwise,
2229 it's always DECL (and never something that's not a _DECL). */
2232 push_overloaded_decl_1 (tree decl, int flags, bool is_friend)
2234 tree name = DECL_NAME (decl);
2237 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2240 old = namespace_binding (name, DECL_CONTEXT (decl));
2242 old = lookup_name_innermost_nonclass_level (name);
2246 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2248 tree t = TREE_TYPE (old);
2249 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2250 && (! DECL_IN_SYSTEM_HEADER (decl)
2251 || ! DECL_IN_SYSTEM_HEADER (old)))
2252 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2255 else if (is_overloaded_fn (old))
2259 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2261 tree fn = OVL_CURRENT (tmp);
2264 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2265 && !(flags & PUSH_USING)
2266 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2267 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2268 && ! decls_match (fn, decl))
2269 error ("%q#D conflicts with previous using declaration %q#D",
2272 dup = duplicate_decls (decl, fn, is_friend);
2273 /* If DECL was a redeclaration of FN -- even an invalid
2274 one -- pass that information along to our caller. */
2275 if (dup == fn || dup == error_mark_node)
2279 /* We don't overload implicit built-ins. duplicate_decls()
2280 may fail to merge the decls if the new decl is e.g. a
2281 template function. */
2282 if (TREE_CODE (old) == FUNCTION_DECL
2283 && DECL_ANTICIPATED (old)
2284 && !DECL_HIDDEN_FRIEND_P (old))
2287 else if (old == error_mark_node)
2288 /* Ignore the undefined symbol marker. */
2292 error ("previous non-function declaration %q+#D", old);
2293 error ("conflicts with function declaration %q#D", decl);
2298 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2299 /* If it's a using declaration, we always need to build an OVERLOAD,
2300 because it's the only way to remember that the declaration comes
2301 from 'using', and have the lookup behave correctly. */
2302 || (flags & PUSH_USING))
2304 if (old && TREE_CODE (old) != OVERLOAD)
2305 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2307 new_binding = ovl_cons (decl, old);
2308 if (flags & PUSH_USING)
2309 OVL_USED (new_binding) = 1;
2312 /* NAME is not ambiguous. */
2316 set_namespace_binding (name, current_namespace, new_binding);
2319 /* We only create an OVERLOAD if there was a previous binding at
2320 this level, or if decl is a template. In the former case, we
2321 need to remove the old binding and replace it with the new
2322 binding. We must also run through the NAMES on the binding
2323 level where the name was bound to update the chain. */
2325 if (TREE_CODE (new_binding) == OVERLOAD && old)
2329 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2331 d = &TREE_CHAIN (*d))
2333 || (TREE_CODE (*d) == TREE_LIST
2334 && TREE_VALUE (*d) == old))
2336 if (TREE_CODE (*d) == TREE_LIST)
2337 /* Just replace the old binding with the new. */
2338 TREE_VALUE (*d) = new_binding;
2340 /* Build a TREE_LIST to wrap the OVERLOAD. */
2341 *d = tree_cons (NULL_TREE, new_binding,
2344 /* And update the cxx_binding node. */
2345 IDENTIFIER_BINDING (name)->value = new_binding;
2349 /* We should always find a previous binding in this case. */
2353 /* Install the new binding. */
2354 push_local_binding (name, new_binding, flags);
2360 /* Wrapper for push_overloaded_decl_1. */
2363 push_overloaded_decl (tree decl, int flags, bool is_friend)
2366 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2367 ret = push_overloaded_decl_1 (decl, flags, is_friend);
2368 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2372 /* Check a non-member using-declaration. Return the name and scope
2373 being used, and the USING_DECL, or NULL_TREE on failure. */
2376 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2378 /* [namespace.udecl]
2379 A using-declaration for a class member shall be a
2380 member-declaration. */
2383 error ("%qT is not a namespace", scope);
2386 else if (scope == error_mark_node)
2389 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2392 A using-declaration shall not name a template-id. */
2393 error ("a using-declaration cannot specify a template-id. "
2394 "Try %<using %D%>", name);
2398 if (TREE_CODE (decl) == NAMESPACE_DECL)
2400 error ("namespace %qD not allowed in using-declaration", decl);
2404 if (TREE_CODE (decl) == SCOPE_REF)
2406 /* It's a nested name with template parameter dependent scope.
2407 This can only be using-declaration for class member. */
2408 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2412 if (is_overloaded_fn (decl))
2413 decl = get_first_fn (decl);
2415 gcc_assert (DECL_P (decl));
2417 /* Make a USING_DECL. */
2418 return push_using_decl (scope, name);
2421 /* Process local and global using-declarations. */
2424 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2425 tree *newval, tree *newtype)
2427 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2429 *newval = *newtype = NULL_TREE;
2430 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2434 if (!decls.value && !decls.type)
2436 error ("%qD not declared", name);
2440 /* Shift the old and new bindings around so we're comparing class and
2441 enumeration names to each other. */
2442 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2448 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2450 decls.type = decls.value;
2451 decls.value = NULL_TREE;
2454 /* It is impossible to overload a built-in function; any explicit
2455 declaration eliminates the built-in declaration. So, if OLDVAL
2456 is a built-in, then we can just pretend it isn't there. */
2458 && TREE_CODE (oldval) == FUNCTION_DECL
2459 && DECL_ANTICIPATED (oldval)
2460 && !DECL_HIDDEN_FRIEND_P (oldval))
2465 /* Check for using functions. */
2466 if (is_overloaded_fn (decls.value))
2470 if (oldval && !is_overloaded_fn (oldval))
2472 error ("%qD is already declared in this scope", name);
2477 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2479 tree new_fn = OVL_CURRENT (tmp);
2481 /* [namespace.udecl]
2483 If a function declaration in namespace scope or block
2484 scope has the same name and the same parameter types as a
2485 function introduced by a using declaration the program is
2487 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2489 tree old_fn = OVL_CURRENT (tmp1);
2491 if (new_fn == old_fn)
2492 /* The function already exists in the current namespace. */
2494 else if (OVL_USED (tmp1))
2495 continue; /* this is a using decl */
2496 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2497 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2499 gcc_assert (!DECL_ANTICIPATED (old_fn)
2500 || DECL_HIDDEN_FRIEND_P (old_fn));
2502 /* There was already a non-using declaration in
2503 this scope with the same parameter types. If both
2504 are the same extern "C" functions, that's ok. */
2505 if (decls_match (new_fn, old_fn))
2509 error ("%qD is already declared in this scope", name);
2515 /* If we broke out of the loop, there's no reason to add
2516 this function to the using declarations for this
2521 /* If we are adding to an existing OVERLOAD, then we no
2522 longer know the type of the set of functions. */
2523 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2524 TREE_TYPE (*newval) = unknown_type_node;
2525 /* Add this new function to the set. */
2526 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2527 /* If there is only one function, then we use its type. (A
2528 using-declaration naming a single function can be used in
2529 contexts where overload resolution cannot be
2531 if (TREE_CODE (*newval) != OVERLOAD)
2533 *newval = ovl_cons (*newval, NULL_TREE);
2534 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2536 OVL_USED (*newval) = 1;
2541 *newval = decls.value;
2542 if (oldval && !decls_match (*newval, oldval))
2543 error ("%qD is already declared in this scope", name);
2549 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2551 error ("reference to %qD is ambiguous", name);
2552 print_candidates (decls.type);
2556 *newtype = decls.type;
2557 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2558 error ("%qD is already declared in this scope", name);
2561 /* If *newval is empty, shift any class or enumeration name down. */
2565 *newtype = NULL_TREE;
2569 /* Process a using-declaration at function scope. */
2572 do_local_using_decl (tree decl, tree scope, tree name)
2574 tree oldval, oldtype, newval, newtype;
2575 tree orig_decl = decl;
2577 decl = validate_nonmember_using_decl (decl, scope, name);
2578 if (decl == NULL_TREE)
2581 if (building_stmt_list_p ()
2582 && at_function_scope_p ())
2583 add_decl_expr (decl);
2585 oldval = lookup_name_innermost_nonclass_level (name);
2586 oldtype = lookup_type_current_level (name);
2588 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2592 if (is_overloaded_fn (newval))
2596 /* We only need to push declarations for those functions
2597 that were not already bound in the current level.
2598 The old value might be NULL_TREE, it might be a single
2599 function, or an OVERLOAD. */
2600 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2601 term = OVL_FUNCTION (oldval);
2604 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2606 push_overloaded_decl (OVL_CURRENT (fn),
2607 PUSH_LOCAL | PUSH_USING,
2611 push_local_binding (name, newval, PUSH_USING);
2615 push_local_binding (name, newtype, PUSH_USING);
2616 set_identifier_type_value (name, newtype);
2619 /* Emit debug info. */
2620 if (!processing_template_decl)
2621 cp_emit_debug_info_for_using (orig_decl, current_scope());
2624 /* Returns true if ROOT (a namespace, class, or function) encloses
2625 CHILD. CHILD may be either a class type or a namespace. */
2628 is_ancestor (tree root, tree child)
2630 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2631 || TREE_CODE (root) == FUNCTION_DECL
2632 || CLASS_TYPE_P (root)));
2633 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2634 || CLASS_TYPE_P (child)));
2636 /* The global namespace encloses everything. */
2637 if (root == global_namespace)
2642 /* If we've run out of scopes, stop. */
2645 /* If we've reached the ROOT, it encloses CHILD. */
2648 /* Go out one level. */
2650 child = TYPE_NAME (child);
2651 child = DECL_CONTEXT (child);
2655 /* Enter the class or namespace scope indicated by T suitable for name
2656 lookup. T can be arbitrary scope, not necessary nested inside the
2657 current scope. Returns a non-null scope to pop iff pop_scope
2658 should be called later to exit this scope. */
2663 if (TREE_CODE (t) == NAMESPACE_DECL)
2664 push_decl_namespace (t);
2665 else if (CLASS_TYPE_P (t))
2667 if (!at_class_scope_p ()
2668 || !same_type_p (current_class_type, t))
2669 push_nested_class (t);
2671 /* T is the same as the current scope. There is therefore no
2672 need to re-enter the scope. Since we are not actually
2673 pushing a new scope, our caller should not call
2681 /* Leave scope pushed by push_scope. */
2688 if (TREE_CODE (t) == NAMESPACE_DECL)
2689 pop_decl_namespace ();
2690 else if CLASS_TYPE_P (t)
2691 pop_nested_class ();
2694 /* Subroutine of push_inner_scope. */
2697 push_inner_scope_r (tree outer, tree inner)
2702 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2705 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2707 push_inner_scope_r (outer, prev);
2708 if (TREE_CODE (inner) == NAMESPACE_DECL)
2710 cp_binding_level *save_template_parm = 0;
2711 /* Temporary take out template parameter scopes. They are saved
2712 in reversed order in save_template_parm. */
2713 while (current_binding_level->kind == sk_template_parms)
2715 cp_binding_level *b = current_binding_level;
2716 current_binding_level = b->level_chain;
2717 b->level_chain = save_template_parm;
2718 save_template_parm = b;
2721 resume_scope (NAMESPACE_LEVEL (inner));
2722 current_namespace = inner;
2724 /* Restore template parameter scopes. */
2725 while (save_template_parm)
2727 cp_binding_level *b = save_template_parm;
2728 save_template_parm = b->level_chain;
2729 b->level_chain = current_binding_level;
2730 current_binding_level = b;
2737 /* Enter the scope INNER from current scope. INNER must be a scope
2738 nested inside current scope. This works with both name lookup and
2739 pushing name into scope. In case a template parameter scope is present,
2740 namespace is pushed under the template parameter scope according to
2741 name lookup rule in 14.6.1/6.
2743 Return the former current scope suitable for pop_inner_scope. */
2746 push_inner_scope (tree inner)
2748 tree outer = current_scope ();
2750 outer = current_namespace;
2752 push_inner_scope_r (outer, inner);
2756 /* Exit the current scope INNER back to scope OUTER. */
2759 pop_inner_scope (tree outer, tree inner)
2762 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2765 while (outer != inner)
2767 if (TREE_CODE (inner) == NAMESPACE_DECL)
2769 cp_binding_level *save_template_parm = 0;
2770 /* Temporary take out template parameter scopes. They are saved
2771 in reversed order in save_template_parm. */
2772 while (current_binding_level->kind == sk_template_parms)
2774 cp_binding_level *b = current_binding_level;
2775 current_binding_level = b->level_chain;
2776 b->level_chain = save_template_parm;
2777 save_template_parm = b;
2782 /* Restore template parameter scopes. */
2783 while (save_template_parm)
2785 cp_binding_level *b = save_template_parm;
2786 save_template_parm = b->level_chain;
2787 b->level_chain = current_binding_level;
2788 current_binding_level = b;
2794 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2798 /* Do a pushlevel for class declarations. */
2801 pushlevel_class (void)
2803 class_binding_level = begin_scope (sk_class, current_class_type);
2806 /* ...and a poplevel for class declarations. */
2809 poplevel_class (void)
2811 cp_binding_level *level = class_binding_level;
2812 cp_class_binding *cb;
2816 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
2817 gcc_assert (level != 0);
2819 /* If we're leaving a toplevel class, cache its binding level. */
2820 if (current_class_depth == 1)
2821 previous_class_level = level;
2822 for (shadowed = level->type_shadowed;
2824 shadowed = TREE_CHAIN (shadowed))
2825 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2827 /* Remove the bindings for all of the class-level declarations. */
2828 if (level->class_shadowed)
2830 FOR_EACH_VEC_ELT (cp_class_binding, level->class_shadowed, i, cb)
2832 IDENTIFIER_BINDING (cb->identifier) = cb->base->previous;
2833 cxx_binding_free (cb->base);
2835 ggc_free (level->class_shadowed);
2836 level->class_shadowed = NULL;
2839 /* Now, pop out of the binding level which we created up in the
2840 `pushlevel_class' routine. */
2841 gcc_assert (current_binding_level == level);
2843 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2846 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2847 appropriate. DECL is the value to which a name has just been
2848 bound. CLASS_TYPE is the class in which the lookup occurred. */
2851 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2854 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2858 if (TREE_CODE (decl) == OVERLOAD)
2859 context = ovl_scope (decl);
2862 gcc_assert (DECL_P (decl));
2863 context = context_for_name_lookup (decl);
2866 if (is_properly_derived_from (class_type, context))
2867 INHERITED_VALUE_BINDING_P (binding) = 1;
2869 INHERITED_VALUE_BINDING_P (binding) = 0;
2871 else if (binding->value == decl)
2872 /* We only encounter a TREE_LIST when there is an ambiguity in the
2873 base classes. Such an ambiguity can be overridden by a
2874 definition in this class. */
2875 INHERITED_VALUE_BINDING_P (binding) = 1;
2877 INHERITED_VALUE_BINDING_P (binding) = 0;
2880 /* Make the declaration of X appear in CLASS scope. */
2883 pushdecl_class_level (tree x)
2886 bool is_valid = true;
2889 /* Do nothing if we're adding to an outer lambda closure type,
2890 outer_binding will add it later if it's needed. */
2891 if (current_class_type != class_binding_level->this_entity)
2894 subtime = timevar_cond_start (TV_NAME_LOOKUP);
2895 /* Get the name of X. */
2896 if (TREE_CODE (x) == OVERLOAD)
2897 name = DECL_NAME (get_first_fn (x));
2899 name = DECL_NAME (x);
2903 is_valid = push_class_level_binding (name, x);
2904 if (TREE_CODE (x) == TYPE_DECL)
2905 set_identifier_type_value (name, x);
2907 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2909 /* If X is an anonymous aggregate, all of its members are
2910 treated as if they were members of the class containing the
2911 aggregate, for naming purposes. */
2914 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = DECL_CHAIN (f))
2916 location_t save_location = input_location;
2917 input_location = DECL_SOURCE_LOCATION (f);
2918 if (!pushdecl_class_level (f))
2920 input_location = save_location;
2923 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
2927 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2928 scope. If the value returned is non-NULL, and the PREVIOUS field
2929 is not set, callers must set the PREVIOUS field explicitly. */
2931 static cxx_binding *
2932 get_class_binding (tree name, cp_binding_level *scope)
2937 cxx_binding *binding;
2939 class_type = scope->this_entity;
2941 /* Get the type binding. */
2942 type_binding = lookup_member (class_type, name,
2943 /*protect=*/2, /*want_type=*/true,
2944 tf_warning_or_error);
2945 /* Get the value binding. */
2946 value_binding = lookup_member (class_type, name,
2947 /*protect=*/2, /*want_type=*/false,
2948 tf_warning_or_error);
2951 && (TREE_CODE (value_binding) == TYPE_DECL
2952 || DECL_CLASS_TEMPLATE_P (value_binding)
2953 || (TREE_CODE (value_binding) == TREE_LIST
2954 && TREE_TYPE (value_binding) == error_mark_node
2955 && (TREE_CODE (TREE_VALUE (value_binding))
2957 /* We found a type binding, even when looking for a non-type
2958 binding. This means that we already processed this binding
2961 else if (value_binding)
2963 if (TREE_CODE (value_binding) == TREE_LIST
2964 && TREE_TYPE (value_binding) == error_mark_node)
2965 /* NAME is ambiguous. */
2967 else if (BASELINK_P (value_binding))
2968 /* NAME is some overloaded functions. */
2969 value_binding = BASELINK_FUNCTIONS (value_binding);
2972 /* If we found either a type binding or a value binding, create a
2973 new binding object. */
2974 if (type_binding || value_binding)
2976 binding = new_class_binding (name,
2980 /* This is a class-scope binding, not a block-scope binding. */
2981 LOCAL_BINDING_P (binding) = 0;
2982 set_inherited_value_binding_p (binding, value_binding, class_type);
2990 /* Make the declaration(s) of X appear in CLASS scope under the name
2991 NAME. Returns true if the binding is valid. */
2994 push_class_level_binding_1 (tree name, tree x)
2996 cxx_binding *binding;
3000 /* The class_binding_level will be NULL if x is a template
3001 parameter name in a member template. */
3002 if (!class_binding_level)
3005 if (name == error_mark_node)
3008 /* Check for invalid member names. */
3009 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
3010 /* Check that we're pushing into the right binding level. */
3011 gcc_assert (current_class_type == class_binding_level->this_entity);
3013 /* We could have been passed a tree list if this is an ambiguous
3014 declaration. If so, pull the declaration out because
3015 check_template_shadow will not handle a TREE_LIST. */
3016 if (TREE_CODE (decl) == TREE_LIST
3017 && TREE_TYPE (decl) == error_mark_node)
3018 decl = TREE_VALUE (decl);
3020 if (!check_template_shadow (decl))
3025 If T is the name of a class, then each of the following shall
3026 have a name different from T:
3028 -- every static data member of class T;
3030 -- every member of class T that is itself a type;
3032 -- every enumerator of every member of class T that is an
3035 -- every member of every anonymous union that is a member of
3038 (Non-static data members were also forbidden to have the same
3039 name as T until TC1.) */
3040 if ((TREE_CODE (x) == VAR_DECL
3041 || TREE_CODE (x) == CONST_DECL
3042 || (TREE_CODE (x) == TYPE_DECL
3043 && !DECL_SELF_REFERENCE_P (x))
3044 /* A data member of an anonymous union. */
3045 || (TREE_CODE (x) == FIELD_DECL
3046 && DECL_CONTEXT (x) != current_class_type))
3047 && DECL_NAME (x) == constructor_name (current_class_type))
3049 tree scope = context_for_name_lookup (x);
3050 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
3052 error ("%qD has the same name as the class in which it is "
3059 /* Get the current binding for NAME in this class, if any. */
3060 binding = IDENTIFIER_BINDING (name);
3061 if (!binding || binding->scope != class_binding_level)
3063 binding = get_class_binding (name, class_binding_level);
3064 /* If a new binding was created, put it at the front of the
3065 IDENTIFIER_BINDING list. */
3068 binding->previous = IDENTIFIER_BINDING (name);
3069 IDENTIFIER_BINDING (name) = binding;
3073 /* If there is already a binding, then we may need to update the
3075 if (binding && binding->value)
3077 tree bval = binding->value;
3078 tree old_decl = NULL_TREE;
3079 tree target_decl = strip_using_decl (decl);
3080 tree target_bval = strip_using_decl (bval);
3082 if (INHERITED_VALUE_BINDING_P (binding))
3084 /* If the old binding was from a base class, and was for a
3085 tag name, slide it over to make room for the new binding.
3086 The old binding is still visible if explicitly qualified
3087 with a class-key. */
3088 if (TREE_CODE (target_bval) == TYPE_DECL
3089 && DECL_ARTIFICIAL (target_bval)
3090 && !(TREE_CODE (target_decl) == TYPE_DECL
3091 && DECL_ARTIFICIAL (target_decl)))
3093 old_decl = binding->type;
3094 binding->type = bval;
3095 binding->value = NULL_TREE;
3096 INHERITED_VALUE_BINDING_P (binding) = 0;
3101 /* Any inherited type declaration is hidden by the type
3102 declaration in the derived class. */
3103 if (TREE_CODE (target_decl) == TYPE_DECL
3104 && DECL_ARTIFICIAL (target_decl))
3105 binding->type = NULL_TREE;
3108 else if (TREE_CODE (target_decl) == OVERLOAD
3109 && is_overloaded_fn (target_bval))
3111 else if (TREE_CODE (decl) == USING_DECL
3112 && TREE_CODE (bval) == USING_DECL
3113 && same_type_p (USING_DECL_SCOPE (decl),
3114 USING_DECL_SCOPE (bval)))
3115 /* This is a using redeclaration that will be diagnosed later
3116 in supplement_binding */
3118 else if (TREE_CODE (decl) == USING_DECL
3119 && TREE_CODE (bval) == USING_DECL
3120 && DECL_DEPENDENT_P (decl)
3121 && DECL_DEPENDENT_P (bval))
3123 else if (TREE_CODE (decl) == USING_DECL
3124 && is_overloaded_fn (target_bval))
3126 else if (TREE_CODE (bval) == USING_DECL
3127 && is_overloaded_fn (target_decl))
3130 if (old_decl && binding->scope == class_binding_level)
3133 /* It is always safe to clear INHERITED_VALUE_BINDING_P
3134 here. This function is only used to register bindings
3135 from with the class definition itself. */
3136 INHERITED_VALUE_BINDING_P (binding) = 0;
3141 /* Note that we declared this value so that we can issue an error if
3142 this is an invalid redeclaration of a name already used for some
3144 note_name_declared_in_class (name, decl);
3146 /* If we didn't replace an existing binding, put the binding on the
3147 stack of bindings for the identifier, and update the shadowed
3149 if (binding && binding->scope == class_binding_level)
3150 /* Supplement the existing binding. */
3151 ok = supplement_binding (binding, decl);
3154 /* Create a new binding. */
3155 push_binding (name, decl, class_binding_level);
3162 /* Wrapper for push_class_level_binding_1. */
3165 push_class_level_binding (tree name, tree x)
3168 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3169 ret = push_class_level_binding_1 (name, x);
3170 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3174 /* Process "using SCOPE::NAME" in a class scope. Return the
3175 USING_DECL created. */
3178 do_class_using_decl (tree scope, tree name)
3180 /* The USING_DECL returned by this function. */
3182 /* The declaration (or declarations) name by this using
3183 declaration. NULL if we are in a template and cannot figure out
3184 what has been named. */
3186 /* True if SCOPE is a dependent type. */
3187 bool scope_dependent_p;
3188 /* True if SCOPE::NAME is dependent. */
3189 bool name_dependent_p;
3190 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
3191 bool bases_dependent_p;
3196 if (name == error_mark_node)
3199 if (!scope || !TYPE_P (scope))
3201 error ("using-declaration for non-member at class scope");
3205 /* Make sure the name is not invalid */
3206 if (TREE_CODE (name) == BIT_NOT_EXPR)
3208 error ("%<%T::%D%> names destructor", scope, name);
3211 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
3213 error ("%<%T::%D%> names constructor", scope, name);
3216 if (constructor_name_p (name, current_class_type))
3218 error ("%<%T::%D%> names constructor in %qT",
3219 scope, name, current_class_type);
3223 scope_dependent_p = dependent_scope_p (scope);
3224 name_dependent_p = (scope_dependent_p
3225 || (IDENTIFIER_TYPENAME_P (name)
3226 && dependent_type_p (TREE_TYPE (name))));
3228 bases_dependent_p = false;
3229 if (processing_template_decl)
3230 for (binfo = TYPE_BINFO (current_class_type), i = 0;
3231 BINFO_BASE_ITERATE (binfo, i, base_binfo);
3233 if (dependent_type_p (TREE_TYPE (base_binfo)))
3235 bases_dependent_p = true;
3241 /* From [namespace.udecl]:
3243 A using-declaration used as a member-declaration shall refer to a
3244 member of a base class of the class being defined.
3246 In general, we cannot check this constraint in a template because
3247 we do not know the entire set of base classes of the current
3248 class type. Morover, if SCOPE is dependent, it might match a
3249 non-dependent base. */
3251 if (!scope_dependent_p)
3254 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
3255 if (b_kind < bk_proper_base)
3257 if (!bases_dependent_p)
3259 error_not_base_type (scope, current_class_type);
3263 else if (!name_dependent_p)
3265 decl = lookup_member (binfo, name, 0, false, tf_warning_or_error);
3268 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3272 /* The binfo from which the functions came does not matter. */
3273 if (BASELINK_P (decl))
3274 decl = BASELINK_FUNCTIONS (decl);
3278 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3279 USING_DECL_DECLS (value) = decl;
3280 USING_DECL_SCOPE (value) = scope;
3281 DECL_DEPENDENT_P (value) = !decl;
3287 /* Return the binding value for name in scope. */
3291 namespace_binding_1 (tree name, tree scope)
3293 cxx_binding *binding;
3295 if (SCOPE_FILE_SCOPE_P (scope))
3296 scope = global_namespace;
3298 /* Unnecessary for the global namespace because it can't be an alias. */
3299 scope = ORIGINAL_NAMESPACE (scope);
3301 binding = cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3303 return binding ? binding->value : NULL_TREE;
3307 namespace_binding (tree name, tree scope)
3310 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3311 ret = namespace_binding_1 (name, scope);
3312 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3316 /* Set the binding value for name in scope. */
3319 set_namespace_binding_1 (tree name, tree scope, tree val)
3323 if (scope == NULL_TREE)
3324 scope = global_namespace;
3325 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3326 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3329 supplement_binding (b, val);
3332 /* Wrapper for set_namespace_binding_1. */
3335 set_namespace_binding (tree name, tree scope, tree val)
3337 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3338 set_namespace_binding_1 (name, scope, val);
3339 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3342 /* Set the context of a declaration to scope. Complain if we are not
3346 set_decl_namespace (tree decl, tree scope, bool friendp)
3350 /* Get rid of namespace aliases. */
3351 scope = ORIGINAL_NAMESPACE (scope);
3353 /* It is ok for friends to be qualified in parallel space. */
3354 if (!friendp && !is_ancestor (current_namespace, scope))
3355 error ("declaration of %qD not in a namespace surrounding %qD",
3357 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3359 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3360 if (scope == current_namespace)
3362 if (at_namespace_scope_p ())
3363 error ("explicit qualification in declaration of %qD",
3368 /* See whether this has been declared in the namespace. */
3369 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3370 if (old == error_mark_node)
3371 /* No old declaration at all. */
3373 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
3374 if (TREE_CODE (old) == TREE_LIST)
3376 error ("reference to %qD is ambiguous", decl);
3377 print_candidates (old);
3380 if (!is_overloaded_fn (decl))
3382 /* We might have found OLD in an inline namespace inside SCOPE. */
3383 if (TREE_CODE (decl) == TREE_CODE (old))
3384 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3385 /* Don't compare non-function decls with decls_match here, since
3386 it can't check for the correct constness at this
3387 point. pushdecl will find those errors later. */
3390 /* Since decl is a function, old should contain a function decl. */
3391 if (!is_overloaded_fn (old))
3393 /* A template can be explicitly specialized in any namespace. */
3394 if (processing_explicit_instantiation)
3396 if (processing_template_decl || processing_specialization)
3397 /* We have not yet called push_template_decl to turn a
3398 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3399 match. But, we'll check later, when we construct the
3402 /* Instantiations or specializations of templates may be declared as
3403 friends in any namespace. */
3404 if (friendp && DECL_USE_TEMPLATE (decl))
3406 if (is_overloaded_fn (old))
3408 tree found = NULL_TREE;
3410 for (; elt; elt = OVL_NEXT (elt))
3412 tree ofn = OVL_CURRENT (elt);
3413 /* Adjust DECL_CONTEXT first so decls_match will return true
3414 if DECL will match a declaration in an inline namespace. */
3415 DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3416 if (decls_match (decl, ofn))
3418 if (found && !decls_match (found, ofn))
3420 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3421 error ("reference to %qD is ambiguous", decl);
3422 print_candidates (old);
3430 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3432 DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3438 DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3439 if (decls_match (decl, old))
3443 /* It didn't work, go back to the explicit scope. */
3444 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3446 error ("%qD should have been declared inside %qD", decl, scope);
3449 /* Return the namespace where the current declaration is declared. */
3452 current_decl_namespace (void)
3455 /* If we have been pushed into a different namespace, use it. */
3456 if (!VEC_empty (tree, decl_namespace_list))
3457 return VEC_last (tree, decl_namespace_list);
3459 if (current_class_type)
3460 result = decl_namespace_context (current_class_type);
3461 else if (current_function_decl)
3462 result = decl_namespace_context (current_function_decl);
3464 result = current_namespace;
3468 /* Process any ATTRIBUTES on a namespace definition. Currently only
3469 attribute visibility is meaningful, which is a property of the syntactic
3470 block rather than the namespace as a whole, so we don't touch the
3471 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3474 handle_namespace_attrs (tree ns, tree attributes)
3477 bool saw_vis = false;
3479 for (d = attributes; d; d = TREE_CHAIN (d))
3481 tree name = TREE_PURPOSE (d);
3482 tree args = TREE_VALUE (d);
3484 if (is_attribute_p ("visibility", name))
3486 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3487 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3489 warning (OPT_Wattributes,
3490 "%qD attribute requires a single NTBS argument",
3495 if (!TREE_PUBLIC (ns))
3496 warning (OPT_Wattributes,
3497 "%qD attribute is meaningless since members of the "
3498 "anonymous namespace get local symbols", name);
3500 push_visibility (TREE_STRING_POINTER (x), 1);
3505 warning (OPT_Wattributes, "%qD attribute directive ignored",
3514 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3515 select a name that is unique to this compilation unit. */
3518 push_namespace (tree name)
3522 int implicit_use = 0;
3525 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3527 /* We should not get here if the global_namespace is not yet constructed
3528 nor if NAME designates the global namespace: The global scope is
3529 constructed elsewhere. */
3530 gcc_assert (global_namespace != NULL && name != global_scope_name);
3534 name = get_anonymous_namespace_name();
3535 d = IDENTIFIER_NAMESPACE_VALUE (name);
3537 /* Reopening anonymous namespace. */
3543 /* Check whether this is an extended namespace definition. */
3544 d = IDENTIFIER_NAMESPACE_VALUE (name);
3545 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3548 if (DECL_NAMESPACE_ALIAS (d))
3550 error ("namespace alias %qD not allowed here, assuming %qD",
3551 d, DECL_NAMESPACE_ALIAS (d));
3552 d = DECL_NAMESPACE_ALIAS (d);
3559 /* Make a new namespace, binding the name to it. */
3560 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3561 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3562 /* The name of this namespace is not visible to other translation
3563 units if it is an anonymous namespace or member thereof. */
3564 if (anon || decl_anon_ns_mem_p (current_namespace))
3565 TREE_PUBLIC (d) = 0;
3567 TREE_PUBLIC (d) = 1;
3571 /* Clear DECL_NAME for the benefit of debugging back ends. */
3572 SET_DECL_ASSEMBLER_NAME (d, name);
3573 DECL_NAME (d) = NULL_TREE;
3575 begin_scope (sk_namespace, d);
3578 resume_scope (NAMESPACE_LEVEL (d));
3581 do_using_directive (d);
3582 /* Enter the name space. */
3583 current_namespace = d;
3585 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3588 /* Pop from the scope of the current namespace. */
3591 pop_namespace (void)
3593 gcc_assert (current_namespace != global_namespace);
3594 current_namespace = CP_DECL_CONTEXT (current_namespace);
3595 /* The binding level is not popped, as it might be re-opened later. */
3599 /* Push into the scope of the namespace NS, even if it is deeply
3600 nested within another namespace. */
3603 push_nested_namespace (tree ns)
3605 if (ns == global_namespace)
3606 push_to_top_level ();
3609 push_nested_namespace (CP_DECL_CONTEXT (ns));
3610 push_namespace (DECL_NAME (ns));
3614 /* Pop back from the scope of the namespace NS, which was previously
3615 entered with push_nested_namespace. */
3618 pop_nested_namespace (tree ns)
3620 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3621 gcc_assert (current_namespace == ns);
3622 while (ns != global_namespace)
3625 ns = CP_DECL_CONTEXT (ns);
3628 pop_from_top_level ();
3629 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3632 /* Temporarily set the namespace for the current declaration. */
3635 push_decl_namespace (tree decl)
3637 if (TREE_CODE (decl) != NAMESPACE_DECL)
3638 decl = decl_namespace_context (decl);
3639 VEC_safe_push (tree, gc, decl_namespace_list, ORIGINAL_NAMESPACE (decl));
3642 /* [namespace.memdef]/2 */
3645 pop_decl_namespace (void)
3647 VEC_pop (tree, decl_namespace_list);
3650 /* Return the namespace that is the common ancestor
3651 of two given namespaces. */
3654 namespace_ancestor_1 (tree ns1, tree ns2)
3657 if (is_ancestor (ns1, ns2))
3660 nsr = namespace_ancestor_1 (CP_DECL_CONTEXT (ns1), ns2);
3664 /* Wrapper for namespace_ancestor_1. */
3667 namespace_ancestor (tree ns1, tree ns2)
3670 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3671 nsr = namespace_ancestor_1 (ns1, ns2);
3672 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3676 /* Process a namespace-alias declaration. */
3679 do_namespace_alias (tree alias, tree name_space)
3681 if (name_space == error_mark_node)
3684 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3686 name_space = ORIGINAL_NAMESPACE (name_space);
3688 /* Build the alias. */
3689 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3690 DECL_NAMESPACE_ALIAS (alias) = name_space;
3691 DECL_EXTERNAL (alias) = 1;
3692 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3695 /* Emit debug info for namespace alias. */
3696 if (!building_stmt_list_p ())
3697 (*debug_hooks->global_decl) (alias);
3700 /* Like pushdecl, only it places X in the current namespace,
3704 pushdecl_namespace_level (tree x, bool is_friend)
3706 cp_binding_level *b = current_binding_level;
3709 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3710 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3712 /* Now, the type_shadowed stack may screw us. Munge it so it does
3714 if (TREE_CODE (t) == TYPE_DECL)
3716 tree name = DECL_NAME (t);
3718 tree *ptr = (tree *)0;
3719 for (; !global_scope_p (b); b = b->level_chain)
3721 tree shadowed = b->type_shadowed;
3722 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3723 if (TREE_PURPOSE (shadowed) == name)
3725 ptr = &TREE_VALUE (shadowed);
3726 /* Can't break out of the loop here because sometimes
3727 a binding level will have duplicate bindings for
3728 PT names. It's gross, but I haven't time to fix it. */
3731 newval = TREE_TYPE (t);
3732 if (ptr == (tree *)0)
3734 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3735 up here if this is changed to an assertion. --KR */
3736 SET_IDENTIFIER_TYPE_VALUE (name, t);
3743 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3747 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3748 directive is not directly from the source. Also find the common
3749 ancestor and let our users know about the new namespace */
3752 add_using_namespace_1 (tree user, tree used, bool indirect)
3755 /* Using oneself is a no-op. */
3758 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3759 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3760 /* Check if we already have this. */
3761 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3765 /* Promote to direct usage. */
3766 TREE_INDIRECT_USING (t) = 0;
3770 /* Add used to the user's using list. */
3771 DECL_NAMESPACE_USING (user)
3772 = tree_cons (used, namespace_ancestor (user, used),
3773 DECL_NAMESPACE_USING (user));
3775 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3777 /* Add user to the used's users list. */
3778 DECL_NAMESPACE_USERS (used)
3779 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3781 /* Recursively add all namespaces used. */
3782 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3783 /* indirect usage */
3784 add_using_namespace_1 (user, TREE_PURPOSE (t), 1);
3786 /* Tell everyone using us about the new used namespaces. */
3787 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3788 add_using_namespace_1 (TREE_PURPOSE (t), used, 1);
3791 /* Wrapper for add_using_namespace_1. */
3794 add_using_namespace (tree user, tree used, bool indirect)
3796 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3797 add_using_namespace_1 (user, used, indirect);
3798 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3801 /* Process a using-declaration not appearing in class or local scope. */
3804 do_toplevel_using_decl (tree decl, tree scope, tree name)
3806 tree oldval, oldtype, newval, newtype;
3807 tree orig_decl = decl;
3808 cxx_binding *binding;
3810 decl = validate_nonmember_using_decl (decl, scope, name);
3811 if (decl == NULL_TREE)
3814 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3816 oldval = binding->value;
3817 oldtype = binding->type;
3819 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3821 /* Emit debug info. */
3822 if (!processing_template_decl)
3823 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3825 /* Copy declarations found. */
3827 binding->value = newval;
3829 binding->type = newtype;
3832 /* Process a using-directive. */
3835 do_using_directive (tree name_space)
3837 tree context = NULL_TREE;
3839 if (name_space == error_mark_node)
3842 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3844 if (building_stmt_list_p ())
3845 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3846 name_space = ORIGINAL_NAMESPACE (name_space);
3848 if (!toplevel_bindings_p ())
3850 push_using_directive (name_space);
3855 add_using_namespace (current_namespace, name_space, 0);
3856 if (current_namespace != global_namespace)
3857 context = current_namespace;
3859 /* Emit debugging info. */
3860 if (!processing_template_decl)
3861 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3866 /* Deal with a using-directive seen by the parser. Currently we only
3867 handle attributes here, since they cannot appear inside a template. */
3870 parse_using_directive (tree name_space, tree attribs)
3874 do_using_directive (name_space);
3876 for (a = attribs; a; a = TREE_CHAIN (a))
3878 tree name = TREE_PURPOSE (a);
3879 if (is_attribute_p ("strong", name))
3881 if (!toplevel_bindings_p ())
3882 error ("strong using only meaningful at namespace scope");
3883 else if (name_space != error_mark_node)
3885 if (!is_ancestor (current_namespace, name_space))
3886 error ("current namespace %qD does not enclose strongly used namespace %qD",
3887 current_namespace, name_space);
3888 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3889 = tree_cons (current_namespace, 0,
3890 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3894 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3898 /* Like pushdecl, only it places X in the global scope if appropriate.
3899 Calls cp_finish_decl to register the variable, initializing it with
3900 *INIT, if INIT is non-NULL. */
3903 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3905 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3906 push_to_top_level ();
3907 x = pushdecl_namespace_level (x, is_friend);
3909 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3910 pop_from_top_level ();
3911 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3915 /* Like pushdecl, only it places X in the global scope if appropriate. */
3918 pushdecl_top_level (tree x)
3920 return pushdecl_top_level_1 (x, NULL, false);
3923 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3926 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3928 return pushdecl_top_level_1 (x, NULL, is_friend);
3931 /* Like pushdecl, only it places X in the global scope if
3932 appropriate. Calls cp_finish_decl to register the variable,
3933 initializing it with INIT. */
3936 pushdecl_top_level_and_finish (tree x, tree init)
3938 return pushdecl_top_level_1 (x, &init, false);
3941 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3942 duplicates. The first list becomes the tail of the result.
3944 The algorithm is O(n^2). We could get this down to O(n log n) by
3945 doing a sort on the addresses of the functions, if that becomes
3949 merge_functions (tree s1, tree s2)
3951 for (; s2; s2 = OVL_NEXT (s2))
3953 tree fn2 = OVL_CURRENT (s2);
3956 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3958 tree fn1 = OVL_CURRENT (fns1);
3960 /* If the function from S2 is already in S1, there is no
3961 need to add it again. For `extern "C"' functions, we
3962 might have two FUNCTION_DECLs for the same function, in
3963 different namespaces, but let's leave them in in case
3964 they have different default arguments. */
3969 /* If we exhausted all of the functions in S1, FN2 is new. */
3971 s1 = build_overload (fn2, s1);
3976 /* Returns TRUE iff OLD and NEW are the same entity.
3978 3 [basic]/3: An entity is a value, object, reference, function,
3979 enumerator, type, class member, template, template specialization,
3980 namespace, parameter pack, or this.
3982 7.3.4 [namespace.udir]/4: If name lookup finds a declaration for a name
3983 in two different namespaces, and the declarations do not declare the
3984 same entity and do not declare functions, the use of the name is
3988 same_entity_p (tree one, tree two)
3994 if (TREE_CODE (one) == TYPE_DECL
3995 && TREE_CODE (two) == TYPE_DECL
3996 && same_type_p (TREE_TYPE (one), TREE_TYPE (two)))
4001 /* This should return an error not all definitions define functions.
4002 It is not an error if we find two functions with exactly the
4003 same signature, only if these are selected in overload resolution.
4004 old is the current set of bindings, new_binding the freshly-found binding.
4005 XXX Do we want to give *all* candidates in case of ambiguity?
4006 XXX In what way should I treat extern declarations?
4007 XXX I don't want to repeat the entire duplicate_decls here */
4010 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
4013 gcc_assert (old != NULL);
4015 /* Copy the type. */
4016 type = new_binding->type;
4017 if (LOOKUP_NAMESPACES_ONLY (flags)
4018 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
4021 /* Copy the value. */
4022 val = new_binding->value;
4025 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
4028 switch (TREE_CODE (val))
4031 /* If we expect types or namespaces, and not templates,
4032 or this is not a template class. */
4033 if ((LOOKUP_QUALIFIERS_ONLY (flags)
4034 && !DECL_CLASS_TEMPLATE_P (val)))
4038 if (LOOKUP_NAMESPACES_ONLY (flags)
4039 || (type && (flags & LOOKUP_PREFER_TYPES)))
4042 case NAMESPACE_DECL:
4043 if (LOOKUP_TYPES_ONLY (flags))
4047 /* Ignore built-in functions that are still anticipated. */
4048 if (LOOKUP_QUALIFIERS_ONLY (flags))
4052 if (LOOKUP_QUALIFIERS_ONLY (flags))
4057 /* If val is hidden, shift down any class or enumeration name. */
4066 else if (val && !same_entity_p (val, old->value))
4068 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
4069 old->value = merge_functions (old->value, val);
4072 old->value = tree_cons (NULL_TREE, old->value,
4073 build_tree_list (NULL_TREE, val));
4074 TREE_TYPE (old->value) = error_mark_node;
4080 else if (type && old->type != type)
4082 old->type = tree_cons (NULL_TREE, old->type,
4083 build_tree_list (NULL_TREE, type));
4084 TREE_TYPE (old->type) = error_mark_node;
4088 /* Return the declarations that are members of the namespace NS. */
4091 cp_namespace_decls (tree ns)
4093 return NAMESPACE_LEVEL (ns)->names;
4096 /* Combine prefer_type and namespaces_only into flags. */
4099 lookup_flags (int prefer_type, int namespaces_only)
4101 if (namespaces_only)
4102 return LOOKUP_PREFER_NAMESPACES;
4103 if (prefer_type > 1)
4104 return LOOKUP_PREFER_TYPES;
4105 if (prefer_type > 0)
4106 return LOOKUP_PREFER_BOTH;
4110 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
4111 ignore it or not. Subroutine of lookup_name_real and
4112 lookup_type_scope. */
4115 qualify_lookup (tree val, int flags)
4117 if (val == NULL_TREE)
4119 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
4121 if (flags & LOOKUP_PREFER_TYPES)
4123 tree target_val = strip_using_decl (val);
4124 if (TREE_CODE (target_val) == TYPE_DECL
4125 || TREE_CODE (target_val) == TEMPLATE_DECL)
4128 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
4130 /* Look through lambda things that we shouldn't be able to see. */
4131 if (is_lambda_ignored_entity (val))
4136 /* Given a lookup that returned VAL, decide if we want to ignore it or
4137 not based on DECL_ANTICIPATED. */
4140 hidden_name_p (tree val)
4143 && DECL_LANG_SPECIFIC (val)
4144 && DECL_ANTICIPATED (val))
4149 /* Remove any hidden friend functions from a possibly overloaded set
4153 remove_hidden_names (tree fns)
4158 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
4160 else if (TREE_CODE (fns) == OVERLOAD)
4164 for (o = fns; o; o = OVL_NEXT (o))
4165 if (hidden_name_p (OVL_CURRENT (o)))
4171 for (o = fns; o; o = OVL_NEXT (o))
4172 if (!hidden_name_p (OVL_CURRENT (o)))
4173 n = build_overload (OVL_CURRENT (o), n);
4181 /* Suggest alternatives for NAME, an IDENTIFIER_NODE for which name
4182 lookup failed. Search through all available namespaces and print out
4183 possible candidates. */
4186 suggest_alternatives_for (location_t location, tree name)
4188 VEC(tree,heap) *candidates = NULL;
4189 VEC(tree,heap) *namespaces_to_search = NULL;
4190 int max_to_search = PARAM_VALUE (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP);
4195 VEC_safe_push (tree, heap, namespaces_to_search, global_namespace);
4197 while (!VEC_empty (tree, namespaces_to_search)
4198 && n_searched < max_to_search)
4200 tree scope = VEC_pop (tree, namespaces_to_search);
4201 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4202 cp_binding_level *level = NAMESPACE_LEVEL (scope);
4204 /* Look in this namespace. */
4205 qualified_lookup_using_namespace (name, scope, &binding, 0);
4210 VEC_safe_push (tree, heap, candidates, binding.value);
4212 /* Add child namespaces. */
4213 for (t = level->namespaces; t; t = DECL_CHAIN (t))
4214 VEC_safe_push (tree, heap, namespaces_to_search, t);
4217 /* If we stopped before we could examine all namespaces, inform the
4218 user. Do this even if we don't have any candidates, since there
4219 might be more candidates further down that we weren't able to
4221 if (n_searched >= max_to_search
4222 && !VEC_empty (tree, namespaces_to_search))
4224 "maximum limit of %d namespaces searched for %qE",
4225 max_to_search, name);
4227 VEC_free (tree, heap, namespaces_to_search);
4229 /* Nothing useful to report. */
4230 if (VEC_empty (tree, candidates))
4233 inform_n (location, VEC_length (tree, candidates),
4234 "suggested alternative:",
4235 "suggested alternatives:");
4237 FOR_EACH_VEC_ELT (tree, candidates, ix, t)
4238 inform (location_of (t), " %qE", t);
4240 VEC_free (tree, heap, candidates);
4243 /* Unscoped lookup of a global: iterate over current namespaces,
4244 considering using-directives. */
4247 unqualified_namespace_lookup_1 (tree name, int flags)
4249 tree initial = current_decl_namespace ();
4250 tree scope = initial;
4252 cp_binding_level *level;
4253 tree val = NULL_TREE;
4255 for (; !val; scope = CP_DECL_CONTEXT (scope))
4257 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4259 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4262 ambiguous_decl (&binding, b, flags);
4264 /* Add all _DECLs seen through local using-directives. */
4265 for (level = current_binding_level;
4266 level->kind != sk_namespace;
4267 level = level->level_chain)
4268 if (!lookup_using_namespace (name, &binding, level->using_directives,
4270 /* Give up because of error. */
4271 return error_mark_node;
4273 /* Add all _DECLs seen through global using-directives. */
4274 /* XXX local and global using lists should work equally. */
4278 if (!lookup_using_namespace (name, &binding,
4279 DECL_NAMESPACE_USING (siter),
4281 /* Give up because of error. */
4282 return error_mark_node;
4283 if (siter == scope) break;
4284 siter = CP_DECL_CONTEXT (siter);
4287 val = binding.value;
4288 if (scope == global_namespace)
4294 /* Wrapper for unqualified_namespace_lookup_1. */
4297 unqualified_namespace_lookup (tree name, int flags)
4300 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4301 ret = unqualified_namespace_lookup_1 (name, flags);
4302 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4306 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
4307 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
4310 Returns a DECL (or OVERLOAD, or BASELINK) representing the
4311 declaration found. If no suitable declaration can be found,
4312 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
4313 neither a class-type nor a namespace a diagnostic is issued. */
4316 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
4321 if (TREE_CODE (scope) == NAMESPACE_DECL)
4323 struct scope_binding binding = EMPTY_SCOPE_BINDING;
4325 flags |= LOOKUP_COMPLAIN;
4327 flags |= LOOKUP_PREFER_TYPES;
4328 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
4331 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
4332 t = lookup_enumerator (scope, name);
4333 else if (is_class_type (scope, complain))
4334 t = lookup_member (scope, name, 2, is_type_p, tf_warning_or_error);
4337 return error_mark_node;
4341 /* Subroutine of unqualified_namespace_lookup:
4342 Add the bindings of NAME in used namespaces to VAL.
4343 We are currently looking for names in namespace SCOPE, so we
4344 look through USINGS for using-directives of namespaces
4345 which have SCOPE as a common ancestor with the current scope.
4346 Returns false on errors. */
4349 lookup_using_namespace (tree name, struct scope_binding *val,
4350 tree usings, tree scope, int flags)
4353 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4354 /* Iterate over all used namespaces in current, searching for using
4355 directives of scope. */
4356 for (iter = usings; iter; iter = TREE_CHAIN (iter))
4357 if (TREE_VALUE (iter) == scope)
4359 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
4361 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (used), name);
4362 /* Resolve ambiguities. */
4364 ambiguous_decl (val, val1, flags);
4366 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4367 return val->value != error_mark_node;
4370 /* Returns true iff VEC contains TARGET. */
4373 tree_vec_contains (VEC(tree,gc)* vec, tree target)
4377 FOR_EACH_VEC_ELT (tree,vec,i,elt)
4384 Accepts the NAME to lookup and its qualifying SCOPE.
4385 Returns the name/type pair found into the cxx_binding *RESULT,
4386 or false on error. */
4389 qualified_lookup_using_namespace (tree name, tree scope,
4390 struct scope_binding *result, int flags)
4392 /* Maintain a list of namespaces visited... */
4393 VEC(tree,gc) *seen = NULL;
4394 VEC(tree,gc) *seen_inline = NULL;
4395 /* ... and a list of namespace yet to see. */
4396 VEC(tree,gc) *todo = NULL;
4397 VEC(tree,gc) *todo_maybe = NULL;
4398 VEC(tree,gc) *todo_inline = NULL;
4400 timevar_start (TV_NAME_LOOKUP);
4401 /* Look through namespace aliases. */
4402 scope = ORIGINAL_NAMESPACE (scope);
4404 /* Algorithm: Starting with SCOPE, walk through the set of used
4405 namespaces. For each used namespace, look through its inline
4406 namespace set for any bindings and usings. If no bindings are
4407 found, add any usings seen to the set of used namespaces. */
4408 VEC_safe_push (tree, gc, todo, scope);
4410 while (VEC_length (tree, todo))
4413 scope = VEC_pop (tree, todo);
4414 if (tree_vec_contains (seen, scope))
4416 VEC_safe_push (tree, gc, seen, scope);
4417 VEC_safe_push (tree, gc, todo_inline, scope);
4420 while (VEC_length (tree, todo_inline))
4422 cxx_binding *binding;
4424 scope = VEC_pop (tree, todo_inline);
4425 if (tree_vec_contains (seen_inline, scope))
4427 VEC_safe_push (tree, gc, seen_inline, scope);
4430 cp_binding_level_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4434 ambiguous_decl (result, binding, flags);
4437 for (usings = DECL_NAMESPACE_USING (scope); usings;
4438 usings = TREE_CHAIN (usings))
4439 if (!TREE_INDIRECT_USING (usings))
4441 if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4442 VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4444 VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4449 VEC_truncate (tree, todo_maybe, 0);
4451 while (VEC_length (tree, todo_maybe))
4452 VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4454 VEC_free (tree,gc,todo);
4455 VEC_free (tree,gc,todo_maybe);
4456 VEC_free (tree,gc,todo_inline);
4457 VEC_free (tree,gc,seen);
4458 VEC_free (tree,gc,seen_inline);
4459 timevar_stop (TV_NAME_LOOKUP);
4460 return result->value != error_mark_node;
4463 /* Subroutine of outer_binding.
4465 Returns TRUE if BINDING is a binding to a template parameter of
4466 SCOPE. In that case SCOPE is the scope of a primary template
4467 parameter -- in the sense of G++, i.e, a template that has its own
4470 Returns FALSE otherwise. */
4473 binding_to_template_parms_of_scope_p (cxx_binding *binding,
4474 cp_binding_level *scope)
4478 if (!binding || !scope)
4481 binding_value = binding->value ? binding->value : binding->type;
4484 && scope->this_entity
4485 && get_template_info (scope->this_entity)
4486 && PRIMARY_TEMPLATE_P (TI_TEMPLATE
4487 (get_template_info (scope->this_entity)))
4488 && parameter_of_template_p (binding_value,
4489 TI_TEMPLATE (get_template_info \
4490 (scope->this_entity))));
4493 /* Return the innermost non-namespace binding for NAME from a scope
4494 containing BINDING, or, if BINDING is NULL, the current scope.
4495 Please note that for a given template, the template parameters are
4496 considered to be in the scope containing the current scope.
4497 If CLASS_P is false, then class bindings are ignored. */
4500 outer_binding (tree name,
4501 cxx_binding *binding,
4505 cp_binding_level *scope;
4506 cp_binding_level *outer_scope;
4510 scope = binding->scope->level_chain;
4511 outer = binding->previous;
4515 scope = current_binding_level;
4516 outer = IDENTIFIER_BINDING (name);
4518 outer_scope = outer ? outer->scope : NULL;
4520 /* Because we create class bindings lazily, we might be missing a
4521 class binding for NAME. If there are any class binding levels
4522 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4523 declared, we must lookup NAME in those class scopes. */
4525 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4527 if (scope->kind == sk_class)
4529 cxx_binding *class_binding;
4531 class_binding = get_class_binding (name, scope);
4534 /* Thread this new class-scope binding onto the
4535 IDENTIFIER_BINDING list so that future lookups
4537 class_binding->previous = outer;
4539 binding->previous = class_binding;
4541 IDENTIFIER_BINDING (name) = class_binding;
4542 return class_binding;
4545 /* If we are in a member template, the template parms of the member
4546 template are considered to be inside the scope of the containing
4547 class, but within G++ the class bindings are all pushed between the
4548 template parms and the function body. So if the outer binding is
4549 a template parm for the current scope, return it now rather than
4550 look for a class binding. */
4551 if (outer_scope && outer_scope->kind == sk_template_parms
4552 && binding_to_template_parms_of_scope_p (outer, scope))
4555 scope = scope->level_chain;
4561 /* Return the innermost block-scope or class-scope value binding for
4562 NAME, or NULL_TREE if there is no such binding. */
4565 innermost_non_namespace_value (tree name)
4567 cxx_binding *binding;
4568 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4569 return binding ? binding->value : NULL_TREE;
4572 /* Look up NAME in the current binding level and its superiors in the
4573 namespace of variables, functions and typedefs. Return a ..._DECL
4574 node of some kind representing its definition if there is only one
4575 such declaration, or return a TREE_LIST with all the overloaded
4576 definitions if there are many, or return 0 if it is undefined.
4577 Hidden name, either friend declaration or built-in function, are
4580 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4581 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4582 Otherwise we prefer non-TYPE_DECLs.
4584 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4585 BLOCK_P is false, bindings in block scopes are ignored. */
4588 lookup_name_real_1 (tree name, int prefer_type, int nonclass, bool block_p,
4589 int namespaces_only, int flags)
4592 tree val = NULL_TREE;
4594 /* Conversion operators are handled specially because ordinary
4595 unqualified name lookup will not find template conversion
4597 if (IDENTIFIER_TYPENAME_P (name))
4599 cp_binding_level *level;
4601 for (level = current_binding_level;
4602 level && level->kind != sk_namespace;
4603 level = level->level_chain)
4608 /* A conversion operator can only be declared in a class
4610 if (level->kind != sk_class)
4613 /* Lookup the conversion operator in the class. */
4614 class_type = level->this_entity;
4615 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4623 flags |= lookup_flags (prefer_type, namespaces_only);
4625 /* First, look in non-namespace scopes. */
4627 if (current_class_type == NULL_TREE)
4630 if (block_p || !nonclass)
4631 for (iter = outer_binding (name, NULL, !nonclass);
4633 iter = outer_binding (name, iter, !nonclass))
4637 /* Skip entities we don't want. */
4638 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4641 /* If this is the kind of thing we're looking for, we're done. */
4642 if (qualify_lookup (iter->value, flags))
4643 binding = iter->value;
4644 else if ((flags & LOOKUP_PREFER_TYPES)
4645 && qualify_lookup (iter->type, flags))
4646 binding = iter->type;
4648 binding = NULL_TREE;
4652 if (hidden_name_p (binding))
4654 /* A non namespace-scope binding can only be hidden in the
4655 presence of a local class, due to friend declarations.
4657 In particular, consider:
4665 B* b; // error: B is hidden
4666 C* c; // OK, finds ::C
4669 B *b; // error: B is hidden
4670 C *c; // OK, finds ::C
4675 The standard says that "B" is a local class in "f"
4676 (but not nested within "A") -- but that name lookup
4677 for "B" does not find this declaration until it is
4678 declared directly with "f".
4684 If a friend declaration appears in a local class and
4685 the name specified is an unqualified name, a prior
4686 declaration is looked up without considering scopes
4687 that are outside the innermost enclosing non-class
4688 scope. For a friend function declaration, if there is
4689 no prior declaration, the program is ill-formed. For a
4690 friend class declaration, if there is no prior
4691 declaration, the class that is specified belongs to the
4692 innermost enclosing non-class scope, but if it is
4693 subsequently referenced, its name is not found by name
4694 lookup until a matching declaration is provided in the
4695 innermost enclosing nonclass scope.
4697 So just keep looking for a non-hidden binding.
4699 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4707 /* Now lookup in namespace scopes. */
4709 val = unqualified_namespace_lookup (name, flags);
4711 /* If we have a single function from a using decl, pull it out. */
4712 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4713 val = OVL_FUNCTION (val);
4718 /* Wrapper for lookup_name_real_1. */
4721 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4722 int namespaces_only, int flags)
4725 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4726 ret = lookup_name_real_1 (name, prefer_type, nonclass, block_p,
4727 namespaces_only, flags);
4728 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4733 lookup_name_nonclass (tree name)
4735 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4739 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4742 lookup_arg_dependent (name,
4743 lookup_name_real (name, 0, 1, block_p, 0,
4749 lookup_name (tree name)
4751 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4755 lookup_name_prefer_type (tree name, int prefer_type)
4757 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4758 0, LOOKUP_COMPLAIN);
4761 /* Look up NAME for type used in elaborated name specifier in
4762 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4763 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4764 name, more scopes are checked if cleanup or template parameter
4765 scope is encountered.
4767 Unlike lookup_name_real, we make sure that NAME is actually
4768 declared in the desired scope, not from inheritance, nor using
4769 directive. For using declaration, there is DR138 still waiting
4770 to be resolved. Hidden name coming from an earlier friend
4771 declaration is also returned.
4773 A TYPE_DECL best matching the NAME is returned. Catching error
4774 and issuing diagnostics are caller's responsibility. */
4777 lookup_type_scope_1 (tree name, tag_scope scope)
4779 cxx_binding *iter = NULL;
4780 tree val = NULL_TREE;
4782 /* Look in non-namespace scope first. */
4783 if (current_binding_level->kind != sk_namespace)
4784 iter = outer_binding (name, NULL, /*class_p=*/ true);
4785 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4787 /* Check if this is the kind of thing we're looking for.
4788 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4789 base class. For ITER->VALUE, we can simply use
4790 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4793 We check ITER->TYPE before ITER->VALUE in order to handle
4794 typedef struct C {} C;
4797 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4798 && (scope != ts_current
4799 || LOCAL_BINDING_P (iter)
4800 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4802 else if ((scope != ts_current
4803 || !INHERITED_VALUE_BINDING_P (iter))
4804 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4811 /* Look in namespace scope. */
4814 iter = cp_binding_level_find_binding_for_name
4815 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4819 /* If this is the kind of thing we're looking for, we're done. */
4820 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4822 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4828 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4829 and template parameter scopes. */
4832 cp_binding_level *b = current_binding_level;
4835 if (iter->scope == b)
4838 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4839 || b->kind == sk_function_parms)
4841 else if (b->kind == sk_class
4842 && scope == ts_within_enclosing_non_class)
4852 /* Wrapper for lookup_type_scope_1. */
4855 lookup_type_scope (tree name, tag_scope scope)
4858 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4859 ret = lookup_type_scope_1 (name, scope);
4860 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4865 /* Similar to `lookup_name' but look only in the innermost non-class
4869 lookup_name_innermost_nonclass_level_1 (tree name)
4871 cp_binding_level *b;
4874 b = innermost_nonclass_level ();
4876 if (b->kind == sk_namespace)
4878 t = IDENTIFIER_NAMESPACE_VALUE (name);
4880 /* extern "C" function() */
4881 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4884 else if (IDENTIFIER_BINDING (name)
4885 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4887 cxx_binding *binding;
4888 binding = IDENTIFIER_BINDING (name);
4891 if (binding->scope == b
4892 && !(TREE_CODE (binding->value) == VAR_DECL
4893 && DECL_DEAD_FOR_LOCAL (binding->value)))
4894 return binding->value;
4896 if (b->kind == sk_cleanup)
4906 /* Wrapper for lookup_name_innermost_nonclass_level_1. */
4909 lookup_name_innermost_nonclass_level (tree name)
4912 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
4913 ret = lookup_name_innermost_nonclass_level_1 (name);
4914 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
4919 /* Returns true iff DECL is a block-scope extern declaration of a function
4923 is_local_extern (tree decl)
4925 cxx_binding *binding;
4927 /* For functions, this is easy. */
4928 if (TREE_CODE (decl) == FUNCTION_DECL)
4929 return DECL_LOCAL_FUNCTION_P (decl);
4931 if (TREE_CODE (decl) != VAR_DECL)
4933 if (!current_function_decl)
4936 /* For variables, this is not easy. We need to look at the binding stack
4937 for the identifier to see whether the decl we have is a local. */
4938 for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4939 binding && binding->scope->kind != sk_namespace;
4940 binding = binding->previous)
4941 if (binding->value == decl)
4942 return LOCAL_BINDING_P (binding);
4947 /* Like lookup_name_innermost_nonclass_level, but for types. */
4950 lookup_type_current_level (tree name)
4954 timevar_start (TV_NAME_LOOKUP);
4955 gcc_assert (current_binding_level->kind != sk_namespace);
4957 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4958 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4960 cp_binding_level *b = current_binding_level;
4963 if (purpose_member (name, b->type_shadowed))
4965 t = REAL_IDENTIFIER_TYPE_VALUE (name);
4968 if (b->kind == sk_cleanup)
4975 timevar_stop (TV_NAME_LOOKUP);
4979 /* [basic.lookup.koenig] */
4980 /* A nonzero return value in the functions below indicates an error. */
4986 VEC(tree,gc) *namespaces;
4987 VEC(tree,gc) *classes;
4989 struct pointer_set_t *fn_set;
4992 static bool arg_assoc (struct arg_lookup*, tree);
4993 static bool arg_assoc_args (struct arg_lookup*, tree);
4994 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4995 static bool arg_assoc_type (struct arg_lookup*, tree);
4996 static bool add_function (struct arg_lookup *, tree);
4997 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4998 static bool arg_assoc_class_only (struct arg_lookup *, tree);
4999 static bool arg_assoc_bases (struct arg_lookup *, tree);
5000 static bool arg_assoc_class (struct arg_lookup *, tree);
5001 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
5003 /* Add a function to the lookup structure.
5004 Returns true on error. */
5007 add_function (struct arg_lookup *k, tree fn)
5009 if (!is_overloaded_fn (fn))
5010 /* All names except those of (possibly overloaded) functions and
5011 function templates are ignored. */;
5012 else if (k->fn_set && pointer_set_insert (k->fn_set, fn))
5013 /* It's already in the list. */;
5014 else if (!k->functions)
5016 else if (fn == k->functions)
5020 k->functions = build_overload (fn, k->functions);
5021 if (TREE_CODE (k->functions) == OVERLOAD)
5022 OVL_ARG_DEPENDENT (k->functions) = true;
5028 /* Returns true iff CURRENT has declared itself to be an associated
5029 namespace of SCOPE via a strong using-directive (or transitive chain
5030 thereof). Both are namespaces. */
5033 is_associated_namespace (tree current, tree scope)
5035 VEC(tree,gc) *seen = make_tree_vector ();
5036 VEC(tree,gc) *todo = make_tree_vector ();
5042 if (scope == current)
5047 VEC_safe_push (tree, gc, seen, scope);
5048 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
5049 if (!vec_member (TREE_PURPOSE (t), seen))
5050 VEC_safe_push (tree, gc, todo, TREE_PURPOSE (t));
5051 if (!VEC_empty (tree, todo))
5053 scope = VEC_last (tree, todo);
5054 VEC_pop (tree, todo);
5063 release_tree_vector (seen);
5064 release_tree_vector (todo);
5069 /* Add functions of a namespace to the lookup structure.
5070 Returns true on error. */
5073 arg_assoc_namespace (struct arg_lookup *k, tree scope)
5077 if (vec_member (scope, k->namespaces))
5079 VEC_safe_push (tree, gc, k->namespaces, scope);
5081 /* Check out our super-users. */
5082 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
5083 value = TREE_CHAIN (value))
5084 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
5087 /* Also look down into inline namespaces. */
5088 for (value = DECL_NAMESPACE_USING (scope); value;
5089 value = TREE_CHAIN (value))
5090 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
5091 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
5094 value = namespace_binding (k->name, scope);
5098 for (; value; value = OVL_NEXT (value))
5100 /* We don't want to find arbitrary hidden functions via argument
5101 dependent lookup. We only want to find friends of associated
5102 classes, which we'll do via arg_assoc_class. */
5103 if (hidden_name_p (OVL_CURRENT (value)))
5106 if (add_function (k, OVL_CURRENT (value)))
5113 /* Adds everything associated with a template argument to the lookup
5114 structure. Returns true on error. */
5117 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
5119 /* [basic.lookup.koenig]
5121 If T is a template-id, its associated namespaces and classes are
5122 ... the namespaces and classes associated with the types of the
5123 template arguments provided for template type parameters
5124 (excluding template template parameters); the namespaces in which
5125 any template template arguments are defined; and the classes in
5126 which any member templates used as template template arguments
5127 are defined. [Note: non-type template arguments do not
5128 contribute to the set of associated namespaces. ] */
5130 /* Consider first template template arguments. */
5131 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
5132 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
5134 else if (TREE_CODE (arg) == TEMPLATE_DECL)
5136 tree ctx = CP_DECL_CONTEXT (arg);
5138 /* It's not a member template. */
5139 if (TREE_CODE (ctx) == NAMESPACE_DECL)
5140 return arg_assoc_namespace (k, ctx);
5141 /* Otherwise, it must be member template. */
5143 return arg_assoc_class_only (k, ctx);
5145 /* It's an argument pack; handle it recursively. */
5146 else if (ARGUMENT_PACK_P (arg))
5148 tree args = ARGUMENT_PACK_ARGS (arg);
5149 int i, len = TREE_VEC_LENGTH (args);
5150 for (i = 0; i < len; ++i)
5151 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
5156 /* It's not a template template argument, but it is a type template
5158 else if (TYPE_P (arg))
5159 return arg_assoc_type (k, arg);
5160 /* It's a non-type template argument. */
5165 /* Adds the class and its friends to the lookup structure.
5166 Returns true on error. */
5169 arg_assoc_class_only (struct arg_lookup *k, tree type)
5171 tree list, friends, context;
5173 /* Backend-built structures, such as __builtin_va_list, aren't
5174 affected by all this. */
5175 if (!CLASS_TYPE_P (type))
5178 context = decl_namespace_context (type);
5179 if (arg_assoc_namespace (k, context))
5182 complete_type (type);
5184 /* Process friends. */
5185 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
5186 list = TREE_CHAIN (list))
5187 if (k->name == FRIEND_NAME (list))
5188 for (friends = FRIEND_DECLS (list); friends;
5189 friends = TREE_CHAIN (friends))
5191 tree fn = TREE_VALUE (friends);
5193 /* Only interested in global functions with potentially hidden
5194 (i.e. unqualified) declarations. */
5195 if (CP_DECL_CONTEXT (fn) != context)
5197 /* Template specializations are never found by name lookup.
5198 (Templates themselves can be found, but not template
5199 specializations.) */
5200 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
5202 if (add_function (k, fn))
5209 /* Adds the class and its bases to the lookup structure.
5210 Returns true on error. */
5213 arg_assoc_bases (struct arg_lookup *k, tree type)
5215 if (arg_assoc_class_only (k, type))
5218 if (TYPE_BINFO (type))
5220 /* Process baseclasses. */
5221 tree binfo, base_binfo;
5224 for (binfo = TYPE_BINFO (type), i = 0;
5225 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
5226 if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
5233 /* Adds everything associated with a class argument type to the lookup
5234 structure. Returns true on error.
5236 If T is a class type (including unions), its associated classes are: the
5237 class itself; the class of which it is a member, if any; and its direct
5238 and indirect base classes. Its associated namespaces are the namespaces
5239 of which its associated classes are members. Furthermore, if T is a
5240 class template specialization, its associated namespaces and classes
5241 also include: the namespaces and classes associated with the types of
5242 the template arguments provided for template type parameters (excluding
5243 template template parameters); the namespaces of which any template
5244 template arguments are members; and the classes of which any member
5245 templates used as template template arguments are members. [ Note:
5246 non-type template arguments do not contribute to the set of associated
5247 namespaces. --end note] */
5250 arg_assoc_class (struct arg_lookup *k, tree type)
5255 /* Backend build structures, such as __builtin_va_list, aren't
5256 affected by all this. */
5257 if (!CLASS_TYPE_P (type))
5260 if (vec_member (type, k->classes))
5262 VEC_safe_push (tree, gc, k->classes, type);
5264 if (TYPE_CLASS_SCOPE_P (type)
5265 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5268 if (arg_assoc_bases (k, type))
5271 /* Process template arguments. */
5272 if (CLASSTYPE_TEMPLATE_INFO (type)
5273 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
5275 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
5276 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
5277 if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
5284 /* Adds everything associated with a given type.
5285 Returns 1 on error. */
5288 arg_assoc_type (struct arg_lookup *k, tree type)
5290 /* As we do not get the type of non-type dependent expressions
5291 right, we can end up with such things without a type. */
5295 if (TYPE_PTRMEM_P (type))
5297 /* Pointer to member: associate class type and value type. */
5298 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
5300 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
5302 else switch (TREE_CODE (type))
5312 case FIXED_POINT_TYPE:
5317 if (TYPE_PTRMEMFUNC_P (type))
5318 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
5320 return arg_assoc_class (k, type);
5322 case REFERENCE_TYPE:
5324 return arg_assoc_type (k, TREE_TYPE (type));
5326 if (TYPE_CLASS_SCOPE_P (type)
5327 && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
5329 return arg_assoc_namespace (k, decl_namespace_context (type));
5331 /* The basetype is referenced in the first arg type, so just
5334 /* Associate the parameter types. */
5335 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
5337 /* Associate the return type. */
5338 return arg_assoc_type (k, TREE_TYPE (type));
5339 case TEMPLATE_TYPE_PARM:
5340 case BOUND_TEMPLATE_TEMPLATE_PARM:
5345 gcc_assert (type == unknown_type_node
5346 || type == init_list_type_node);
5348 case TYPE_PACK_EXPANSION:
5349 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
5357 /* Adds everything associated with arguments. Returns true on error. */
5360 arg_assoc_args (struct arg_lookup *k, tree args)
5362 for (; args; args = TREE_CHAIN (args))
5363 if (arg_assoc (k, TREE_VALUE (args)))
5368 /* Adds everything associated with an argument vector. Returns true
5372 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
5377 FOR_EACH_VEC_ELT (tree, args, ix, arg)
5378 if (arg_assoc (k, arg))
5383 /* Adds everything associated with a given tree_node. Returns 1 on error. */
5386 arg_assoc (struct arg_lookup *k, tree n)
5388 if (n == error_mark_node)
5392 return arg_assoc_type (k, n);
5394 if (! type_unknown_p (n))
5395 return arg_assoc_type (k, TREE_TYPE (n));
5397 if (TREE_CODE (n) == ADDR_EXPR)
5398 n = TREE_OPERAND (n, 0);
5399 if (TREE_CODE (n) == COMPONENT_REF)
5400 n = TREE_OPERAND (n, 1);
5401 if (TREE_CODE (n) == OFFSET_REF)
5402 n = TREE_OPERAND (n, 1);
5403 while (TREE_CODE (n) == TREE_LIST)
5406 n = BASELINK_FUNCTIONS (n);
5408 if (TREE_CODE (n) == FUNCTION_DECL)
5409 return arg_assoc_type (k, TREE_TYPE (n));
5410 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
5412 /* The working paper doesn't currently say how to handle template-id
5413 arguments. The sensible thing would seem to be to handle the list
5414 of template candidates like a normal overload set, and handle the
5415 template arguments like we do for class template
5417 tree templ = TREE_OPERAND (n, 0);
5418 tree args = TREE_OPERAND (n, 1);
5421 /* First the templates. */
5422 if (arg_assoc (k, templ))
5425 /* Now the arguments. */
5427 for (ix = TREE_VEC_LENGTH (args); ix--;)
5428 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
5431 else if (TREE_CODE (n) == OVERLOAD)
5433 for (; n; n = OVL_NEXT (n))
5434 if (arg_assoc_type (k, TREE_TYPE (OVL_CURRENT (n))))
5441 /* Performs Koenig lookup depending on arguments, where fns
5442 are the functions found in normal lookup. */
5445 lookup_arg_dependent_1 (tree name, tree fns, VEC(tree,gc) *args,
5448 struct arg_lookup k;
5450 /* Remove any hidden friend functions from the list of functions
5451 found so far. They will be added back by arg_assoc_class as
5453 fns = remove_hidden_names (fns);
5458 k.classes = make_tree_vector ();
5460 /* We previously performed an optimization here by setting
5461 NAMESPACES to the current namespace when it was safe. However, DR
5462 164 says that namespaces that were already searched in the first
5463 stage of template processing are searched again (potentially
5464 picking up later definitions) in the second stage. */
5465 k.namespaces = make_tree_vector ();
5467 /* We used to allow duplicates and let joust discard them, but
5468 since the above change for DR 164 we end up with duplicates of
5469 all the functions found by unqualified lookup. So keep track
5470 of which ones we've seen. */
5474 /* We shouldn't be here if lookup found something other than
5475 namespace-scope functions. */
5476 gcc_assert (DECL_NAMESPACE_SCOPE_P (OVL_CURRENT (fns)));
5477 k.fn_set = pointer_set_create ();
5478 for (ovl = fns; ovl; ovl = OVL_NEXT (ovl))
5479 pointer_set_insert (k.fn_set, OVL_CURRENT (ovl));
5485 arg_assoc_namespace (&k, std_node);
5486 arg_assoc_args_vec (&k, args);
5491 && TREE_CODE (fns) != VAR_DECL
5492 && !is_overloaded_fn (fns))
5494 error ("argument dependent lookup finds %q+D", fns);
5495 error (" in call to %qD", name);
5496 fns = error_mark_node;
5499 release_tree_vector (k.classes);
5500 release_tree_vector (k.namespaces);
5502 pointer_set_destroy (k.fn_set);
5507 /* Wrapper for lookup_arg_dependent_1. */
5510 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args,
5515 subtime = timevar_cond_start (TV_NAME_LOOKUP);
5516 ret = lookup_arg_dependent_1 (name, fns, args, include_std);
5517 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5522 /* Add namespace to using_directives. Return NULL_TREE if nothing was
5523 changed (i.e. there was already a directive), or the fresh
5524 TREE_LIST otherwise. */
5527 push_using_directive_1 (tree used)
5529 tree ud = current_binding_level->using_directives;
5530 tree iter, ancestor;
5532 /* Check if we already have this. */
5533 if (purpose_member (used, ud) != NULL_TREE)
5536 ancestor = namespace_ancestor (current_decl_namespace (), used);
5537 ud = current_binding_level->using_directives;
5538 ud = tree_cons (used, ancestor, ud);
5539 current_binding_level->using_directives = ud;
5541 /* Recursively add all namespaces used. */
5542 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5543 push_using_directive (TREE_PURPOSE (iter));
5548 /* Wrapper for push_using_directive_1. */
5551 push_using_directive (tree used)
5554 timevar_start (TV_NAME_LOOKUP);
5555 ret = push_using_directive_1 (used);
5556 timevar_stop (TV_NAME_LOOKUP);
5560 /* The type TYPE is being declared. If it is a class template, or a
5561 specialization of a class template, do any processing required and
5562 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
5563 being declared a friend. B is the binding level at which this TYPE
5566 Returns the TYPE_DECL for TYPE, which may have been altered by this
5570 maybe_process_template_type_declaration (tree type, int is_friend,
5571 cp_binding_level *b)
5573 tree decl = TYPE_NAME (type);
5575 if (processing_template_parmlist)
5576 /* You can't declare a new template type in a template parameter
5577 list. But, you can declare a non-template type:
5579 template <class A*> struct S;
5581 is a forward-declaration of `A'. */
5583 else if (b->kind == sk_namespace
5584 && current_binding_level->kind != sk_namespace)
5585 /* If this new type is being injected into a containing scope,
5586 then it's not a template type. */
5590 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5591 || TREE_CODE (type) == ENUMERAL_TYPE);
5593 if (processing_template_decl)
5595 /* This may change after the call to
5596 push_template_decl_real, but we want the original value. */
5597 tree name = DECL_NAME (decl);
5599 decl = push_template_decl_real (decl, is_friend);
5600 if (decl == error_mark_node)
5601 return error_mark_node;
5603 /* If the current binding level is the binding level for the
5604 template parameters (see the comment in
5605 begin_template_parm_list) and the enclosing level is a class
5606 scope, and we're not looking at a friend, push the
5607 declaration of the member class into the class scope. In the
5608 friend case, push_template_decl will already have put the
5609 friend into global scope, if appropriate. */
5610 if (TREE_CODE (type) != ENUMERAL_TYPE
5611 && !is_friend && b->kind == sk_template_parms
5612 && b->level_chain->kind == sk_class)
5614 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5616 if (!COMPLETE_TYPE_P (current_class_type))
5618 maybe_add_class_template_decl_list (current_class_type,
5619 type, /*friend_p=*/0);
5620 /* Put this UTD in the table of UTDs for the class. */
5621 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5622 CLASSTYPE_NESTED_UTDS (current_class_type) =
5623 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5625 binding_table_insert
5626 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5635 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5636 that the NAME is a class template, the tag is processed but not pushed.
5638 The pushed scope depend on the SCOPE parameter:
5639 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5641 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5642 non-template-parameter scope. This case is needed for forward
5644 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5645 TS_GLOBAL case except that names within template-parameter scopes
5646 are not pushed at all.
5648 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5651 pushtag_1 (tree name, tree type, tag_scope scope)
5653 cp_binding_level *b;
5656 b = current_binding_level;
5657 while (/* Cleanup scopes are not scopes from the point of view of
5659 b->kind == sk_cleanup
5660 /* Neither are function parameter scopes. */
5661 || b->kind == sk_function_parms
5662 /* Neither are the scopes used to hold template parameters
5663 for an explicit specialization. For an ordinary template
5664 declaration, these scopes are not scopes from the point of
5665 view of the language. */
5666 || (b->kind == sk_template_parms
5667 && (b->explicit_spec_p || scope == ts_global))
5668 || (b->kind == sk_class
5669 && (scope != ts_current
5670 /* We may be defining a new type in the initializer
5671 of a static member variable. We allow this when
5672 not pedantic, and it is particularly useful for
5673 type punning via an anonymous union. */
5674 || COMPLETE_TYPE_P (b->this_entity))))
5677 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5679 /* Do C++ gratuitous typedefing. */
5680 if (identifier_type_value_1 (name) != type)
5684 tree context = TYPE_CONTEXT (type);
5688 tree cs = current_scope ();
5690 if (scope == ts_current
5691 || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5693 else if (cs != NULL_TREE && TYPE_P (cs))
5694 /* When declaring a friend class of a local class, we want
5695 to inject the newly named class into the scope
5696 containing the local class, not the namespace
5698 context = decl_function_context (get_type_decl (cs));
5701 context = current_namespace;
5703 if (b->kind == sk_class
5704 || (b->kind == sk_template_parms
5705 && b->level_chain->kind == sk_class))
5708 if (current_lang_name == lang_name_java)
5709 TYPE_FOR_JAVA (type) = 1;
5711 tdef = create_implicit_typedef (name, type);
5712 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5713 if (scope == ts_within_enclosing_non_class)
5715 /* This is a friend. Make this TYPE_DECL node hidden from
5716 ordinary name lookup. Its corresponding TEMPLATE_DECL
5717 will be marked in push_template_decl_real. */
5718 retrofit_lang_decl (tdef);
5719 DECL_ANTICIPATED (tdef) = 1;
5720 DECL_FRIEND_P (tdef) = 1;
5723 decl = maybe_process_template_type_declaration
5724 (type, scope == ts_within_enclosing_non_class, b);
5725 if (decl == error_mark_node)
5728 if (b->kind == sk_class)
5730 if (!TYPE_BEING_DEFINED (current_class_type))
5731 return error_mark_node;
5733 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5734 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5735 class. But if it's a member template class, we want
5736 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5738 finish_member_declaration (decl);
5740 pushdecl_class_level (decl);
5742 else if (b->kind != sk_template_parms)
5744 decl = pushdecl_with_scope_1 (decl, b, /*is_friend=*/false);
5745 if (decl == error_mark_node)
5750 set_identifier_type_value_with_scope (name, tdef, b);
5752 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5754 /* If this is a local class, keep track of it. We need this
5755 information for name-mangling, and so that it is possible to
5756 find all function definitions in a translation unit in a
5757 convenient way. (It's otherwise tricky to find a member
5758 function definition it's only pointed to from within a local
5760 if (TYPE_CONTEXT (type)
5761 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5762 VEC_safe_push (tree, gc, local_classes, type);
5764 if (b->kind == sk_class
5765 && !COMPLETE_TYPE_P (current_class_type))
5767 maybe_add_class_template_decl_list (current_class_type,
5768 type, /*friend_p=*/0);
5770 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5771 CLASSTYPE_NESTED_UTDS (current_class_type)
5772 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5774 binding_table_insert
5775 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5778 decl = TYPE_NAME (type);
5779 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5781 /* Set type visibility now if this is a forward declaration. */
5782 TREE_PUBLIC (decl) = 1;
5783 determine_visibility (decl);
5788 /* Wrapper for pushtag_1. */
5791 pushtag (tree name, tree type, tag_scope scope)
5794 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5795 ret = pushtag_1 (name, type, scope);
5796 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5800 /* Subroutines for reverting temporarily to top-level for instantiation
5801 of templates and such. We actually need to clear out the class- and
5802 local-value slots of all identifiers, so that only the global values
5803 are at all visible. Simply setting current_binding_level to the global
5804 scope isn't enough, because more binding levels may be pushed. */
5805 struct saved_scope *scope_chain;
5807 /* If ID has not already been marked, add an appropriate binding to
5811 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5813 cxx_saved_binding *saved;
5815 if (!id || !IDENTIFIER_BINDING (id))
5818 if (IDENTIFIER_MARKED (id))
5821 IDENTIFIER_MARKED (id) = 1;
5823 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5824 saved->identifier = id;
5825 saved->binding = IDENTIFIER_BINDING (id);
5826 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5827 IDENTIFIER_BINDING (id) = NULL;
5831 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5835 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5836 for (t = names; t; t = TREE_CHAIN (t))
5840 if (TREE_CODE (t) == TREE_LIST)
5841 id = TREE_PURPOSE (t);
5845 store_binding (id, old_bindings);
5847 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5850 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5851 objects, rather than a TREE_LIST. */
5854 store_class_bindings (VEC(cp_class_binding,gc) *names,
5855 VEC(cxx_saved_binding,gc) **old_bindings)
5858 cp_class_binding *cb;
5860 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5861 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5862 store_binding (cb->identifier, old_bindings);
5863 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5867 push_to_top_level (void)
5869 struct saved_scope *s;
5870 cp_binding_level *b;
5871 cxx_saved_binding *sb;
5875 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5876 s = ggc_alloc_cleared_saved_scope ();
5878 b = scope_chain ? current_binding_level : 0;
5880 /* If we're in the middle of some function, save our state. */
5884 push_function_context ();
5889 if (scope_chain && previous_class_level)
5890 store_class_bindings (previous_class_level->class_shadowed,
5893 /* Have to include the global scope, because class-scope decls
5894 aren't listed anywhere useful. */
5895 for (; b; b = b->level_chain)
5899 /* Template IDs are inserted into the global level. If they were
5900 inserted into namespace level, finish_file wouldn't find them
5901 when doing pending instantiations. Therefore, don't stop at
5902 namespace level, but continue until :: . */
5903 if (global_scope_p (b))
5906 store_bindings (b->names, &s->old_bindings);
5907 /* We also need to check class_shadowed to save class-level type
5908 bindings, since pushclass doesn't fill in b->names. */
5909 if (b->kind == sk_class)
5910 store_class_bindings (b->class_shadowed, &s->old_bindings);
5912 /* Unwind type-value slots back to top level. */
5913 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5914 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5917 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, sb)
5918 IDENTIFIER_MARKED (sb->identifier) = 0;
5920 s->prev = scope_chain;
5922 s->need_pop_function_context = need_pop;
5923 s->function_decl = current_function_decl;
5924 s->unevaluated_operand = cp_unevaluated_operand;
5925 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5926 s->x_stmt_tree.stmts_are_full_exprs_p = true;
5929 current_function_decl = NULL_TREE;
5930 current_lang_base = VEC_alloc (tree, gc, 10);
5931 current_lang_name = lang_name_cplusplus;
5932 current_namespace = global_namespace;
5933 push_class_stack ();
5934 cp_unevaluated_operand = 0;
5935 c_inhibit_evaluation_warnings = 0;
5936 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5940 pop_from_top_level_1 (void)
5942 struct saved_scope *s = scope_chain;
5943 cxx_saved_binding *saved;
5946 /* Clear out class-level bindings cache. */
5947 if (previous_class_level)
5948 invalidate_class_lookup_cache ();
5951 current_lang_base = 0;
5953 scope_chain = s->prev;
5954 FOR_EACH_VEC_ELT (cxx_saved_binding, s->old_bindings, i, saved)
5956 tree id = saved->identifier;
5958 IDENTIFIER_BINDING (id) = saved->binding;
5959 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5962 /* If we were in the middle of compiling a function, restore our
5964 if (s->need_pop_function_context)
5965 pop_function_context ();
5966 current_function_decl = s->function_decl;
5967 cp_unevaluated_operand = s->unevaluated_operand;
5968 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5971 /* Wrapper for pop_from_top_level_1. */
5974 pop_from_top_level (void)
5976 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
5977 pop_from_top_level_1 ();
5978 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
5982 /* Pop off extraneous binding levels left over due to syntax errors.
5984 We don't pop past namespaces, as they might be valid. */
5987 pop_everything (void)
5989 if (ENABLE_SCOPE_CHECKING)
5990 verbatim ("XXX entering pop_everything ()\n");
5991 while (!toplevel_bindings_p ())
5993 if (current_binding_level->kind == sk_class)
5994 pop_nested_class ();
5998 if (ENABLE_SCOPE_CHECKING)
5999 verbatim ("XXX leaving pop_everything ()\n");
6002 /* Emit debugging information for using declarations and directives.
6003 If input tree is overloaded fn then emit debug info for all
6007 cp_emit_debug_info_for_using (tree t, tree context)
6009 /* Don't try to emit any debug information if we have errors. */
6013 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
6014 of a builtin function. */
6015 if (TREE_CODE (t) == FUNCTION_DECL
6016 && DECL_EXTERNAL (t)
6017 && DECL_BUILT_IN (t))
6020 /* Do not supply context to imported_module_or_decl, if
6021 it is a global namespace. */
6022 if (context == global_namespace)
6023 context = NULL_TREE;
6026 t = BASELINK_FUNCTIONS (t);
6028 /* FIXME: Handle TEMPLATE_DECLs. */
6029 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
6030 if (TREE_CODE (t) != TEMPLATE_DECL)
6032 if (building_stmt_list_p ())
6033 add_stmt (build_stmt (input_location, USING_STMT, t));
6035 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
6039 #include "gt-cp-name-lookup.h"