1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding {
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope *innermost_nonclass_level (void);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree push_overloaded_decl (tree, int, bool);
47 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
49 static bool qualified_lookup_using_namespace (tree, tree,
50 struct scope_binding *, int);
51 static tree lookup_type_current_level (tree);
52 static tree push_using_directive (tree);
54 /* The :: namespace. */
56 tree global_namespace;
58 /* The name of the anonymous namespace, throughout this translation
60 static GTY(()) tree anonymous_namespace_name;
62 /* Initialize anonymous_namespace_name if necessary, and return it. */
65 get_anonymous_namespace_name(void)
67 if (!anonymous_namespace_name)
69 /* The anonymous namespace has to have a unique name
70 if typeinfo objects are being compared by name. */
71 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
72 anonymous_namespace_name = get_file_function_name ("N");
74 /* The demangler expects anonymous namespaces to be called
75 something starting with '_GLOBAL__N_'. */
76 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
78 return anonymous_namespace_name;
81 /* Compute the chain index of a binding_entry given the HASH value of its
82 name and the total COUNT of chains. COUNT is assumed to be a power
85 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
87 /* A free list of "binding_entry"s awaiting for re-use. */
89 static GTY((deletable)) binding_entry free_binding_entry = NULL;
91 /* Create a binding_entry object for (NAME, TYPE). */
93 static inline binding_entry
94 binding_entry_make (tree name, tree type)
98 if (free_binding_entry)
100 entry = free_binding_entry;
101 free_binding_entry = entry->chain;
104 entry = GGC_NEW (struct binding_entry_s);
113 /* Put ENTRY back on the free list. */
116 binding_entry_free (binding_entry entry)
120 entry->chain = free_binding_entry;
121 free_binding_entry = entry;
125 /* The datatype used to implement the mapping from names to types at
127 struct binding_table_s GTY(())
129 /* Array of chains of "binding_entry"s */
130 binding_entry * GTY((length ("%h.chain_count"))) chain;
132 /* The number of chains in this table. This is the length of the
133 the member "chain" considered as an array. */
136 /* Number of "binding_entry"s in this table. */
140 /* Construct TABLE with an initial CHAIN_COUNT. */
143 binding_table_construct (binding_table table, size_t chain_count)
145 table->chain_count = chain_count;
146 table->entry_count = 0;
147 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
150 /* Make TABLE's entries ready for reuse. */
153 binding_table_free (binding_table table)
161 for (i = 0, count = table->chain_count; i < count; ++i)
163 binding_entry temp = table->chain[i];
166 binding_entry entry = temp;
168 binding_entry_free (entry);
170 table->chain[i] = NULL;
172 table->entry_count = 0;
176 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
178 static inline binding_table
179 binding_table_new (size_t chain_count)
181 binding_table table = GGC_NEW (struct binding_table_s);
183 binding_table_construct (table, chain_count);
187 /* Expand TABLE to twice its current chain_count. */
190 binding_table_expand (binding_table table)
192 const size_t old_chain_count = table->chain_count;
193 const size_t old_entry_count = table->entry_count;
194 const size_t new_chain_count = 2 * old_chain_count;
195 binding_entry *old_chains = table->chain;
198 binding_table_construct (table, new_chain_count);
199 for (i = 0; i < old_chain_count; ++i)
201 binding_entry entry = old_chains[i];
202 for (; entry != NULL; entry = old_chains[i])
204 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
205 const size_t j = ENTRY_INDEX (hash, new_chain_count);
207 old_chains[i] = entry->chain;
208 entry->chain = table->chain[j];
209 table->chain[j] = entry;
212 table->entry_count = old_entry_count;
215 /* Insert a binding for NAME to TYPE into TABLE. */
218 binding_table_insert (binding_table table, tree name, tree type)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 const size_t i = ENTRY_INDEX (hash, table->chain_count);
222 binding_entry entry = binding_entry_make (name, type);
224 entry->chain = table->chain[i];
225 table->chain[i] = entry;
226 ++table->entry_count;
228 if (3 * table->chain_count < 5 * table->entry_count)
229 binding_table_expand (table);
232 /* Return the binding_entry, if any, that maps NAME. */
235 binding_table_find (binding_table table, tree name)
237 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
238 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
240 while (entry != NULL && entry->name != name)
241 entry = entry->chain;
246 /* Apply PROC -- with DATA -- to all entries in TABLE. */
249 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
251 const size_t chain_count = table->chain_count;
254 for (i = 0; i < chain_count; ++i)
256 binding_entry entry = table->chain[i];
257 for (; entry != NULL; entry = entry->chain)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable)) cxx_binding *free_bindings;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding *binding, tree value, tree type)
278 binding->value = value;
279 binding->type = type;
280 binding->previous = NULL;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value, tree type)
288 cxx_binding *binding;
291 binding = free_bindings;
292 free_bindings = binding->previous;
295 binding = GGC_NEW (cxx_binding);
297 cxx_binding_init (binding, value, type);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding *binding)
307 binding->scope = NULL;
308 binding->previous = free_bindings;
309 free_bindings = binding;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
318 cp_class_binding *cb;
319 cxx_binding *binding;
321 if (VEC_length (cp_class_binding, scope->class_shadowed))
323 cp_class_binding *old_base;
324 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
325 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
327 /* Fixup the current bindings, as they might have moved. */
331 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
335 b = &IDENTIFIER_BINDING (cb->identifier);
336 while (*b != &old_base[i].base)
337 b = &((*b)->previous);
341 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
344 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
346 cb->identifier = name;
348 binding->scope = scope;
349 cxx_binding_init (binding, value, type);
353 /* Make DECL the innermost binding for ID. The LEVEL is the binding
354 level at which this declaration is being bound. */
357 push_binding (tree id, tree decl, cxx_scope* level)
359 cxx_binding *binding;
361 if (level != class_binding_level)
363 binding = cxx_binding_make (decl, NULL_TREE);
364 binding->scope = level;
367 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
369 /* Now, fill in the binding information. */
370 binding->previous = IDENTIFIER_BINDING (id);
371 INHERITED_VALUE_BINDING_P (binding) = 0;
372 LOCAL_BINDING_P (binding) = (level != class_binding_level);
374 /* And put it on the front of the list of bindings for ID. */
375 IDENTIFIER_BINDING (id) = binding;
378 /* Remove the binding for DECL which should be the innermost binding
382 pop_binding (tree id, tree decl)
384 cxx_binding *binding;
387 /* It's easiest to write the loops that call this function without
388 checking whether or not the entities involved have names. We
389 get here for such an entity. */
392 /* Get the innermost binding for ID. */
393 binding = IDENTIFIER_BINDING (id);
395 /* The name should be bound. */
396 gcc_assert (binding != NULL);
398 /* The DECL will be either the ordinary binding or the type
399 binding for this identifier. Remove that binding. */
400 if (binding->value == decl)
401 binding->value = NULL_TREE;
404 gcc_assert (binding->type == decl);
405 binding->type = NULL_TREE;
408 if (!binding->value && !binding->type)
410 /* We're completely done with the innermost binding for this
411 identifier. Unhook it from the list of bindings. */
412 IDENTIFIER_BINDING (id) = binding->previous;
414 /* Add it to the free list. */
415 cxx_binding_free (binding);
419 /* BINDING records an existing declaration for a name in the current scope.
420 But, DECL is another declaration for that same identifier in the
421 same scope. This is the `struct stat' hack whereby a non-typedef
422 class name or enum-name can be bound at the same level as some other
426 A class name (9.1) or enumeration name (7.2) can be hidden by the
427 name of an object, function, or enumerator declared in the same scope.
428 If a class or enumeration name and an object, function, or enumerator
429 are declared in the same scope (in any order) with the same name, the
430 class or enumeration name is hidden wherever the object, function, or
431 enumerator name is visible.
433 It's the responsibility of the caller to check that
434 inserting this name is valid here. Returns nonzero if the new binding
438 supplement_binding (cxx_binding *binding, tree decl)
440 tree bval = binding->value;
443 timevar_push (TV_NAME_LOOKUP);
444 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
445 /* The new name is the type name. */
446 binding->type = decl;
447 else if (/* BVAL is null when push_class_level_binding moves an
448 inherited type-binding out of the way to make room for a
449 new value binding. */
451 /* BVAL is error_mark_node when DECL's name has been used
452 in a non-class scope prior declaration. In that case,
453 we should have already issued a diagnostic; for graceful
454 error recovery purpose, pretend this was the intended
455 declaration for that name. */
456 || bval == error_mark_node
457 /* If BVAL is anticipated but has not yet been declared,
458 pretend it is not there at all. */
459 || (TREE_CODE (bval) == FUNCTION_DECL
460 && DECL_ANTICIPATED (bval)
461 && !DECL_HIDDEN_FRIEND_P (bval)))
462 binding->value = decl;
463 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
465 /* The old binding was a type name. It was placed in
466 VALUE field because it was thought, at the point it was
467 declared, to be the only entity with such a name. Move the
468 type name into the type slot; it is now hidden by the new
470 binding->type = bval;
471 binding->value = decl;
472 binding->value_is_inherited = false;
474 else if (TREE_CODE (bval) == TYPE_DECL
475 && TREE_CODE (decl) == TYPE_DECL
476 && DECL_NAME (decl) == DECL_NAME (bval)
477 && binding->scope->kind != sk_class
478 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
479 /* If either type involves template parameters, we must
480 wait until instantiation. */
481 || uses_template_parms (TREE_TYPE (decl))
482 || uses_template_parms (TREE_TYPE (bval))))
483 /* We have two typedef-names, both naming the same type to have
484 the same name. In general, this is OK because of:
488 In a given scope, a typedef specifier can be used to redefine
489 the name of any type declared in that scope to refer to the
490 type to which it already refers.
492 However, in class scopes, this rule does not apply due to the
493 stricter language in [class.mem] prohibiting redeclarations of
496 /* There can be two block-scope declarations of the same variable,
497 so long as they are `extern' declarations. However, there cannot
498 be two declarations of the same static data member:
502 A member shall not be declared twice in the
503 member-specification. */
504 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
505 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
506 && !DECL_CLASS_SCOPE_P (decl))
508 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
511 else if (TREE_CODE (decl) == NAMESPACE_DECL
512 && TREE_CODE (bval) == NAMESPACE_DECL
513 && DECL_NAMESPACE_ALIAS (decl)
514 && DECL_NAMESPACE_ALIAS (bval)
515 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
518 In a declarative region, a namespace-alias-definition can be
519 used to redefine a namespace-alias declared in that declarative
520 region to refer only to the namespace to which it already
525 error ("declaration of %q#D", decl);
526 error ("conflicts with previous declaration %q+#D", bval);
530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
533 /* Add DECL to the list of things declared in B. */
536 add_decl_to_level (tree decl, cxx_scope *b)
538 /* We used to record virtual tables as if they were ordinary
539 variables, but no longer do so. */
540 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
542 if (TREE_CODE (decl) == NAMESPACE_DECL
543 && !DECL_NAMESPACE_ALIAS (decl))
545 TREE_CHAIN (decl) = b->namespaces;
546 b->namespaces = decl;
550 /* We build up the list in reverse order, and reverse it later if
552 TREE_CHAIN (decl) = b->names;
556 /* If appropriate, add decl to separate list of statics. We
557 include extern variables because they might turn out to be
558 static later. It's OK for this list to contain a few false
560 if (b->kind == sk_namespace)
561 if ((TREE_CODE (decl) == VAR_DECL
562 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
563 || (TREE_CODE (decl) == FUNCTION_DECL
564 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
565 VEC_safe_push (tree, gc, b->static_decls, decl);
569 /* Record a decl-node X as belonging to the current lexical scope.
570 Check for errors (such as an incompatible declaration for the same
571 name already seen in the same scope). IS_FRIEND is true if X is
572 declared as a friend.
574 Returns either X or an old decl for the same name.
575 If an old decl is returned, it may have been smashed
576 to agree with what X says. */
579 pushdecl_maybe_friend (tree x, bool is_friend)
583 int need_new_binding;
585 timevar_push (TV_NAME_LOOKUP);
587 if (x == error_mark_node)
588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
590 need_new_binding = 1;
592 if (DECL_TEMPLATE_PARM_P (x))
593 /* Template parameters have no context; they are not X::T even
594 when declared within a class or namespace. */
598 if (current_function_decl && x != current_function_decl
599 /* A local declaration for a function doesn't constitute
601 && TREE_CODE (x) != FUNCTION_DECL
602 /* A local declaration for an `extern' variable is in the
603 scope of the current namespace, not the current
605 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
606 && !DECL_CONTEXT (x))
607 DECL_CONTEXT (x) = current_function_decl;
609 /* If this is the declaration for a namespace-scope function,
610 but the declaration itself is in a local scope, mark the
612 if (TREE_CODE (x) == FUNCTION_DECL
613 && DECL_NAMESPACE_SCOPE_P (x)
614 && current_function_decl
615 && x != current_function_decl)
616 DECL_LOCAL_FUNCTION_P (x) = 1;
619 name = DECL_NAME (x);
622 int different_binding_level = 0;
624 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
625 name = TREE_OPERAND (name, 0);
627 /* In case this decl was explicitly namespace-qualified, look it
628 up in its namespace context. */
629 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
630 t = namespace_binding (name, DECL_CONTEXT (x));
632 t = lookup_name_innermost_nonclass_level (name);
634 /* [basic.link] If there is a visible declaration of an entity
635 with linkage having the same name and type, ignoring entities
636 declared outside the innermost enclosing namespace scope, the
637 block scope declaration declares that same entity and
638 receives the linkage of the previous declaration. */
639 if (! t && current_function_decl && x != current_function_decl
640 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
641 && DECL_EXTERNAL (x))
643 /* Look in block scope. */
644 t = innermost_non_namespace_value (name);
645 /* Or in the innermost namespace. */
647 t = namespace_binding (name, DECL_CONTEXT (x));
648 /* Does it have linkage? Note that if this isn't a DECL, it's an
649 OVERLOAD, which is OK. */
650 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
653 different_binding_level = 1;
656 /* If we are declaring a function, and the result of name-lookup
657 was an OVERLOAD, look for an overloaded instance that is
658 actually the same as the function we are declaring. (If
659 there is one, we have to merge our declaration with the
660 previous declaration.) */
661 if (t && TREE_CODE (t) == OVERLOAD)
665 if (TREE_CODE (x) == FUNCTION_DECL)
666 for (match = t; match; match = OVL_NEXT (match))
668 if (decls_match (OVL_CURRENT (match), x))
672 /* Just choose one. */
676 t = OVL_CURRENT (match);
681 if (t && t != error_mark_node)
683 if (different_binding_level)
685 if (decls_match (x, t))
686 /* The standard only says that the local extern
687 inherits linkage from the previous decl; in
688 particular, default args are not shared. Add
689 the decl into a hash table to make sure only
690 the previous decl in this case is seen by the
693 struct cxx_int_tree_map *h;
696 TREE_PUBLIC (x) = TREE_PUBLIC (t);
698 if (cp_function_chain->extern_decl_map == NULL)
699 cp_function_chain->extern_decl_map
700 = htab_create_ggc (20, cxx_int_tree_map_hash,
701 cxx_int_tree_map_eq, NULL);
703 h = GGC_NEW (struct cxx_int_tree_map);
704 h->uid = DECL_UID (x);
706 loc = htab_find_slot_with_hash
707 (cp_function_chain->extern_decl_map, h,
709 *(struct cxx_int_tree_map **) loc = h;
712 else if (TREE_CODE (t) == PARM_DECL)
714 gcc_assert (DECL_CONTEXT (t));
716 /* Check for duplicate params. */
717 if (duplicate_decls (x, t, is_friend))
718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
720 else if ((DECL_EXTERN_C_FUNCTION_P (x)
721 || DECL_FUNCTION_TEMPLATE_P (x))
722 && is_overloaded_fn (t))
723 /* Don't do anything just yet. */;
724 else if (t == wchar_decl_node)
726 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
727 pedwarn ("redeclaration of %<wchar_t%> as %qT",
730 /* Throw away the redeclaration. */
731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
735 tree olddecl = duplicate_decls (x, t, is_friend);
737 /* If the redeclaration failed, we can stop at this
739 if (olddecl == error_mark_node)
740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
744 if (TREE_CODE (t) == TYPE_DECL)
745 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
749 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
751 /* A redeclaration of main, but not a duplicate of the
756 This function shall not be overloaded. */
757 error ("invalid redeclaration of %q+D", t);
759 /* We don't try to push this declaration since that
761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
766 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
767 check_default_args (x);
769 check_template_shadow (x);
771 /* If this is a function conjured up by the back end, massage it
772 so it looks friendly. */
773 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
775 retrofit_lang_decl (x);
776 SET_DECL_LANGUAGE (x, lang_c);
779 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
781 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
783 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
784 if (!namespace_bindings_p ())
785 /* We do not need to create a binding for this name;
786 push_overloaded_decl will have already done so if
788 need_new_binding = 0;
790 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
792 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
794 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
795 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
798 /* If declaring a type as a typedef, copy the type (unless we're
799 at line 0), and install this TYPE_DECL as the new type's typedef
800 name. See the extensive comment in ../c-decl.c (pushdecl). */
801 if (TREE_CODE (x) == TYPE_DECL)
803 tree type = TREE_TYPE (x);
804 if (DECL_IS_BUILTIN (x))
806 if (TYPE_NAME (type) == 0)
807 TYPE_NAME (type) = x;
809 else if (type != error_mark_node && TYPE_NAME (type) != x
810 /* We don't want to copy the type when all we're
811 doing is making a TYPE_DECL for the purposes of
813 && (!TYPE_NAME (type)
814 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
816 DECL_ORIGINAL_TYPE (x) = type;
817 type = build_variant_type_copy (type);
818 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
819 TYPE_NAME (type) = x;
820 TREE_TYPE (x) = type;
823 if (type != error_mark_node
825 && TYPE_IDENTIFIER (type))
826 set_identifier_type_value (DECL_NAME (x), x);
829 /* Multiple external decls of the same identifier ought to match.
831 We get warnings about inline functions where they are defined.
832 We get warnings about other functions from push_overloaded_decl.
834 Avoid duplicate warnings where they are used. */
835 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
839 decl = IDENTIFIER_NAMESPACE_VALUE (name);
840 if (decl && TREE_CODE (decl) == OVERLOAD)
841 decl = OVL_FUNCTION (decl);
843 if (decl && decl != error_mark_node
844 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
845 /* If different sort of thing, we already gave an error. */
846 && TREE_CODE (decl) == TREE_CODE (x)
847 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
849 permerror ("type mismatch with previous external decl of %q#D", x);
850 permerror ("previous external decl of %q+#D", decl);
854 if (TREE_CODE (x) == FUNCTION_DECL
856 && !flag_friend_injection)
858 /* This is a new declaration of a friend function, so hide
859 it from ordinary function lookup. */
860 DECL_ANTICIPATED (x) = 1;
861 DECL_HIDDEN_FRIEND_P (x) = 1;
864 /* This name is new in its binding level.
865 Install the new declaration and return it. */
866 if (namespace_bindings_p ())
868 /* Install a global value. */
870 /* If the first global decl has external linkage,
871 warn if we later see static one. */
872 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
873 TREE_PUBLIC (name) = 1;
875 /* Bind the name for the entity. */
876 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
878 && (TREE_CODE (x) == TYPE_DECL
879 || TREE_CODE (x) == VAR_DECL
880 || TREE_CODE (x) == NAMESPACE_DECL
881 || TREE_CODE (x) == CONST_DECL
882 || TREE_CODE (x) == TEMPLATE_DECL))
883 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
885 /* If new decl is `static' and an `extern' was seen previously,
887 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
888 warn_extern_redeclared_static (x, t);
892 /* Here to install a non-global value. */
893 tree oldlocal = innermost_non_namespace_value (name);
894 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
896 if (need_new_binding)
898 push_local_binding (name, x, 0);
899 /* Because push_local_binding will hook X on to the
900 current_binding_level's name list, we don't want to
901 do that again below. */
902 need_new_binding = 0;
905 /* If this is a TYPE_DECL, push it into the type value slot. */
906 if (TREE_CODE (x) == TYPE_DECL)
907 set_identifier_type_value (name, x);
909 /* Clear out any TYPE_DECL shadowed by a namespace so that
910 we won't think this is a type. The C struct hack doesn't
911 go through namespaces. */
912 if (TREE_CODE (x) == NAMESPACE_DECL)
913 set_identifier_type_value (name, NULL_TREE);
920 && TREE_CODE (oldlocal) == VAR_DECL
921 && DECL_DEAD_FOR_LOCAL (oldlocal))
922 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
924 if (oldlocal == NULL_TREE)
925 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
928 /* If this is an extern function declaration, see if we
929 have a global definition or declaration for the function. */
930 if (oldlocal == NULL_TREE
932 && oldglobal != NULL_TREE
933 && TREE_CODE (x) == FUNCTION_DECL
934 && TREE_CODE (oldglobal) == FUNCTION_DECL)
936 /* We have one. Their types must agree. */
937 if (decls_match (x, oldglobal))
941 warning (0, "extern declaration of %q#D doesn't match", x);
942 warning (0, "global declaration %q+#D", oldglobal);
945 /* If we have a local external declaration,
946 and no file-scope declaration has yet been seen,
947 then if we later have a file-scope decl it must not be static. */
948 if (oldlocal == NULL_TREE
949 && oldglobal == NULL_TREE
952 TREE_PUBLIC (name) = 1;
954 /* Warn if shadowing an argument at the top level of the body. */
955 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
956 /* Inline decls shadow nothing. */
957 && !DECL_FROM_INLINE (x)
958 && TREE_CODE (oldlocal) == PARM_DECL
959 /* Don't check the `this' parameter. */
960 && !DECL_ARTIFICIAL (oldlocal))
964 /* Don't complain if it's from an enclosing function. */
965 if (DECL_CONTEXT (oldlocal) == current_function_decl
966 && TREE_CODE (x) != PARM_DECL)
968 /* Go to where the parms should be and see if we find
970 struct cp_binding_level *b = current_binding_level->level_chain;
972 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
973 /* Skip the ctor/dtor cleanup level. */
977 if (b->kind == sk_function_parms)
979 error ("declaration of %q#D shadows a parameter", x);
984 if (warn_shadow && !err)
986 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
987 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
991 /* Maybe warn if shadowing something else. */
992 else if (warn_shadow && !DECL_EXTERNAL (x)
993 /* No shadow warnings for internally generated vars. */
994 && ! DECL_ARTIFICIAL (x)
995 /* No shadow warnings for vars made for inlining. */
996 && ! DECL_FROM_INLINE (x))
1000 if (current_class_ptr)
1001 member = lookup_member (current_class_type,
1004 /*want_type=*/false);
1008 if (member && !TREE_STATIC (member))
1010 /* Location of previous decl is not useful in this case. */
1011 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1014 else if (oldlocal != NULL_TREE
1015 && TREE_CODE (oldlocal) == VAR_DECL)
1017 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1018 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1020 else if (oldglobal != NULL_TREE
1021 && TREE_CODE (oldglobal) == VAR_DECL)
1022 /* XXX shadow warnings in outer-more namespaces */
1024 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1026 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1031 if (TREE_CODE (x) == VAR_DECL)
1032 maybe_register_incomplete_var (x);
1035 if (need_new_binding)
1036 add_decl_to_level (x,
1037 DECL_NAMESPACE_SCOPE_P (x)
1038 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1039 : current_binding_level);
1041 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1044 /* Record a decl-node X as belonging to the current lexical scope. */
1049 return pushdecl_maybe_friend (x, false);
1052 /* Enter DECL into the symbol table, if that's appropriate. Returns
1053 DECL, or a modified version thereof. */
1056 maybe_push_decl (tree decl)
1058 tree type = TREE_TYPE (decl);
1060 /* Add this decl to the current binding level, but not if it comes
1061 from another scope, e.g. a static member variable. TEM may equal
1062 DECL or it may be a previous decl of the same name. */
1063 if (decl == error_mark_node
1064 || (TREE_CODE (decl) != PARM_DECL
1065 && DECL_CONTEXT (decl) != NULL_TREE
1066 /* Definitions of namespace members outside their namespace are
1068 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1069 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1070 || TREE_CODE (type) == UNKNOWN_TYPE
1071 /* The declaration of a template specialization does not affect
1072 the functions available for overload resolution, so we do not
1074 || (TREE_CODE (decl) == FUNCTION_DECL
1075 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1078 return pushdecl (decl);
1081 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1082 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1083 doesn't really belong to this binding level, that it got here
1084 through a using-declaration. */
1087 push_local_binding (tree id, tree decl, int flags)
1089 struct cp_binding_level *b;
1091 /* Skip over any local classes. This makes sense if we call
1092 push_local_binding with a friend decl of a local class. */
1093 b = innermost_nonclass_level ();
1095 if (lookup_name_innermost_nonclass_level (id))
1097 /* Supplement the existing binding. */
1098 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1099 /* It didn't work. Something else must be bound at this
1100 level. Do not add DECL to the list of things to pop
1105 /* Create a new binding. */
1106 push_binding (id, decl, b);
1108 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1109 /* We must put the OVERLOAD into a TREE_LIST since the
1110 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1111 decls that got here through a using-declaration. */
1112 decl = build_tree_list (NULL_TREE, decl);
1114 /* And put DECL on the list of things declared by the current
1116 add_decl_to_level (decl, b);
1119 /* Check to see whether or not DECL is a variable that would have been
1120 in scope under the ARM, but is not in scope under the ANSI/ISO
1121 standard. If so, issue an error message. If name lookup would
1122 work in both cases, but return a different result, this function
1123 returns the result of ANSI/ISO lookup. Otherwise, it returns
1127 check_for_out_of_scope_variable (tree decl)
1131 /* We only care about out of scope variables. */
1132 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1135 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1136 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1137 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1138 && DECL_DEAD_FOR_LOCAL (shadowed))
1139 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1140 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1142 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1145 if (!DECL_ERROR_REPORTED (decl))
1147 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1148 warning (0, " matches this %q+D under ISO standard rules",
1150 warning (0, " matches this %q+D under old rules", decl);
1151 DECL_ERROR_REPORTED (decl) = 1;
1156 /* If we have already complained about this declaration, there's no
1157 need to do it again. */
1158 if (DECL_ERROR_REPORTED (decl))
1161 DECL_ERROR_REPORTED (decl) = 1;
1163 if (TREE_TYPE (decl) == error_mark_node)
1166 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1168 error ("name lookup of %qD changed for ISO %<for%> scoping",
1170 error (" cannot use obsolete binding at %q+D because "
1171 "it has a destructor", decl);
1172 return error_mark_node;
1176 permerror ("name lookup of %qD changed for ISO %<for%> scoping",
1178 if (flag_permissive)
1179 permerror (" using obsolete binding at %q+D", decl);
1185 inform ("(if you use %<-fpermissive%> G++ will accept your code)");
1194 /* true means unconditionally make a BLOCK for the next level pushed. */
1196 static bool keep_next_level_flag;
1198 static int binding_depth = 0;
1199 static int is_class_level = 0;
1206 for (i = 0; i < depth * 2; i++)
1210 /* Return a string describing the kind of SCOPE we have. */
1212 cxx_scope_descriptor (cxx_scope *scope)
1214 /* The order of this table must match the "scope_kind"
1216 static const char* scope_kind_names[] = {
1222 "function-parameter-scope",
1225 "template-parameter-scope",
1226 "template-explicit-spec-scope"
1228 const scope_kind kind = scope->explicit_spec_p
1229 ? sk_template_spec : scope->kind;
1231 return scope_kind_names[kind];
1234 /* Output a debugging information about SCOPE when performing
1237 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1239 const char *desc = cxx_scope_descriptor (scope);
1240 if (scope->this_entity)
1241 verbatim ("%s %s(%E) %p %d\n", action, desc,
1242 scope->this_entity, (void *) scope, line);
1244 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1247 /* Return the estimated initial size of the hashtable of a NAMESPACE
1250 static inline size_t
1251 namespace_scope_ht_size (tree ns)
1253 tree name = DECL_NAME (ns);
1255 return name == std_identifier
1256 ? NAMESPACE_STD_HT_SIZE
1257 : (name == global_scope_name
1258 ? GLOBAL_SCOPE_HT_SIZE
1259 : NAMESPACE_ORDINARY_HT_SIZE);
1262 /* A chain of binding_level structures awaiting reuse. */
1264 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1266 /* Insert SCOPE as the innermost binding level. */
1269 push_binding_level (struct cp_binding_level *scope)
1271 /* Add it to the front of currently active scopes stack. */
1272 scope->level_chain = current_binding_level;
1273 current_binding_level = scope;
1274 keep_next_level_flag = false;
1276 if (ENABLE_SCOPE_CHECKING)
1278 scope->binding_depth = binding_depth;
1279 indent (binding_depth);
1280 cxx_scope_debug (scope, input_line, "push");
1286 /* Create a new KIND scope and make it the top of the active scopes stack.
1287 ENTITY is the scope of the associated C++ entity (namespace, class,
1288 function); it is NULL otherwise. */
1291 begin_scope (scope_kind kind, tree entity)
1295 /* Reuse or create a struct for this binding level. */
1296 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1298 scope = free_binding_level;
1299 memset (scope, 0, sizeof (cxx_scope));
1300 free_binding_level = scope->level_chain;
1303 scope = GGC_CNEW (cxx_scope);
1305 scope->this_entity = entity;
1306 scope->more_cleanups_ok = true;
1313 case sk_template_spec:
1314 scope->explicit_spec_p = true;
1315 kind = sk_template_parms;
1317 case sk_template_parms:
1323 case sk_function_parms:
1325 scope->keep = keep_next_level_flag;
1329 NAMESPACE_LEVEL (entity) = scope;
1330 scope->static_decls =
1331 VEC_alloc (tree, gc,
1332 DECL_NAME (entity) == std_identifier
1333 || DECL_NAME (entity) == global_scope_name
1338 /* Should not happen. */
1344 push_binding_level (scope);
1349 /* We're about to leave current scope. Pop the top of the stack of
1350 currently active scopes. Return the enclosing scope, now active. */
1355 cxx_scope *scope = current_binding_level;
1357 if (scope->kind == sk_namespace && class_binding_level)
1358 current_binding_level = class_binding_level;
1360 /* We cannot leave a scope, if there are none left. */
1361 if (NAMESPACE_LEVEL (global_namespace))
1362 gcc_assert (!global_scope_p (scope));
1364 if (ENABLE_SCOPE_CHECKING)
1366 indent (--binding_depth);
1367 cxx_scope_debug (scope, input_line, "leave");
1368 if (is_class_level != (scope == class_binding_level))
1370 indent (binding_depth);
1371 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1376 /* Move one nesting level up. */
1377 current_binding_level = scope->level_chain;
1379 /* Namespace-scopes are left most probably temporarily, not
1380 completely; they can be reopened later, e.g. in namespace-extension
1381 or any name binding activity that requires us to resume a
1382 namespace. For classes, we cache some binding levels. For other
1383 scopes, we just make the structure available for reuse. */
1384 if (scope->kind != sk_namespace
1385 && scope->kind != sk_class)
1387 scope->level_chain = free_binding_level;
1388 gcc_assert (!ENABLE_SCOPE_CHECKING
1389 || scope->binding_depth == binding_depth);
1390 free_binding_level = scope;
1393 /* Find the innermost enclosing class scope, and reset
1394 CLASS_BINDING_LEVEL appropriately. */
1395 if (scope->kind == sk_class)
1397 class_binding_level = NULL;
1398 for (scope = current_binding_level; scope; scope = scope->level_chain)
1399 if (scope->kind == sk_class)
1401 class_binding_level = scope;
1406 return current_binding_level;
1410 resume_scope (struct cp_binding_level* b)
1412 /* Resuming binding levels is meant only for namespaces,
1413 and those cannot nest into classes. */
1414 gcc_assert (!class_binding_level);
1415 /* Also, resuming a non-directly nested namespace is a no-no. */
1416 gcc_assert (b->level_chain == current_binding_level);
1417 current_binding_level = b;
1418 if (ENABLE_SCOPE_CHECKING)
1420 b->binding_depth = binding_depth;
1421 indent (binding_depth);
1422 cxx_scope_debug (b, input_line, "resume");
1428 /* Return the innermost binding level that is not for a class scope. */
1431 innermost_nonclass_level (void)
1435 b = current_binding_level;
1436 while (b->kind == sk_class)
1442 /* We're defining an object of type TYPE. If it needs a cleanup, but
1443 we're not allowed to add any more objects with cleanups to the current
1444 scope, create a new binding level. */
1447 maybe_push_cleanup_level (tree type)
1449 if (type != error_mark_node
1450 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1451 && current_binding_level->more_cleanups_ok == 0)
1453 begin_scope (sk_cleanup, NULL);
1454 current_binding_level->statement_list = push_stmt_list ();
1458 /* Nonzero if we are currently in the global binding level. */
1461 global_bindings_p (void)
1463 return global_scope_p (current_binding_level);
1466 /* True if we are currently in a toplevel binding level. This
1467 means either the global binding level or a namespace in a toplevel
1468 binding level. Since there are no non-toplevel namespace levels,
1469 this really means any namespace or template parameter level. We
1470 also include a class whose context is toplevel. */
1473 toplevel_bindings_p (void)
1475 struct cp_binding_level *b = innermost_nonclass_level ();
1477 return b->kind == sk_namespace || b->kind == sk_template_parms;
1480 /* True if this is a namespace scope, or if we are defining a class
1481 which is itself at namespace scope, or whose enclosing class is
1482 such a class, etc. */
1485 namespace_bindings_p (void)
1487 struct cp_binding_level *b = innermost_nonclass_level ();
1489 return b->kind == sk_namespace;
1492 /* True if the current level needs to have a BLOCK made. */
1497 return (current_binding_level->blocks != NULL_TREE
1498 || current_binding_level->keep
1499 || current_binding_level->kind == sk_cleanup
1500 || current_binding_level->names != NULL_TREE);
1503 /* Returns the kind of the innermost scope. */
1506 innermost_scope_kind (void)
1508 return current_binding_level->kind;
1511 /* Returns true if this scope was created to store template parameters. */
1514 template_parm_scope_p (void)
1516 return innermost_scope_kind () == sk_template_parms;
1519 /* If KEEP is true, make a BLOCK node for the next binding level,
1520 unconditionally. Otherwise, use the normal logic to decide whether
1521 or not to create a BLOCK. */
1524 keep_next_level (bool keep)
1526 keep_next_level_flag = keep;
1529 /* Return the list of declarations of the current level.
1530 Note that this list is in reverse order unless/until
1531 you nreverse it; and when you do nreverse it, you must
1532 store the result back using `storedecls' or you will lose. */
1537 return current_binding_level->names;
1540 /* For debugging. */
1541 static int no_print_functions = 0;
1542 static int no_print_builtins = 0;
1545 print_binding_level (struct cp_binding_level* lvl)
1549 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1550 if (lvl->more_cleanups_ok)
1551 fprintf (stderr, " more-cleanups-ok");
1552 if (lvl->have_cleanups)
1553 fprintf (stderr, " have-cleanups");
1554 fprintf (stderr, "\n");
1557 fprintf (stderr, " names:\t");
1558 /* We can probably fit 3 names to a line? */
1559 for (t = lvl->names; t; t = TREE_CHAIN (t))
1561 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1563 if (no_print_builtins
1564 && (TREE_CODE (t) == TYPE_DECL)
1565 && DECL_IS_BUILTIN (t))
1568 /* Function decls tend to have longer names. */
1569 if (TREE_CODE (t) == FUNCTION_DECL)
1576 fprintf (stderr, "\n\t");
1579 print_node_brief (stderr, "", t, 0);
1580 if (t == error_mark_node)
1584 fprintf (stderr, "\n");
1586 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1589 cp_class_binding *b;
1590 fprintf (stderr, " class-shadowed:");
1592 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1594 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1595 fprintf (stderr, "\n");
1597 if (lvl->type_shadowed)
1599 fprintf (stderr, " type-shadowed:");
1600 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1602 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1604 fprintf (stderr, "\n");
1609 print_other_binding_stack (struct cp_binding_level *stack)
1611 struct cp_binding_level *level;
1612 for (level = stack; !global_scope_p (level); level = level->level_chain)
1614 fprintf (stderr, "binding level %p\n", (void *) level);
1615 print_binding_level (level);
1620 print_binding_stack (void)
1622 struct cp_binding_level *b;
1623 fprintf (stderr, "current_binding_level=%p\n"
1624 "class_binding_level=%p\n"
1625 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1626 (void *) current_binding_level, (void *) class_binding_level,
1627 (void *) NAMESPACE_LEVEL (global_namespace));
1628 if (class_binding_level)
1630 for (b = class_binding_level; b; b = b->level_chain)
1631 if (b == current_binding_level)
1634 b = class_binding_level;
1636 b = current_binding_level;
1639 b = current_binding_level;
1640 print_other_binding_stack (b);
1641 fprintf (stderr, "global:\n");
1642 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1645 /* Return the type associated with id. */
1648 identifier_type_value (tree id)
1650 timevar_push (TV_NAME_LOOKUP);
1651 /* There is no type with that name, anywhere. */
1652 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1653 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1654 /* This is not the type marker, but the real thing. */
1655 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1656 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1657 /* Have to search for it. It must be on the global level, now.
1658 Ask lookup_name not to return non-types. */
1659 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1661 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1662 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1665 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1666 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1669 identifier_global_value (tree t)
1671 return IDENTIFIER_GLOBAL_VALUE (t);
1674 /* Push a definition of struct, union or enum tag named ID. into
1675 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1676 the tag ID is not already defined. */
1679 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1683 if (b->kind != sk_namespace)
1685 /* Shadow the marker, not the real thing, so that the marker
1686 gets restored later. */
1687 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1689 = tree_cons (id, old_type_value, b->type_shadowed);
1690 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1691 TREE_TYPE (b->type_shadowed) = type;
1695 cxx_binding *binding =
1696 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1699 supplement_binding (binding, decl);
1701 binding->value = decl;
1703 /* Store marker instead of real type. */
1704 type = global_type_node;
1706 SET_IDENTIFIER_TYPE_VALUE (id, type);
1709 /* As set_identifier_type_value_with_scope, but using
1710 current_binding_level. */
1713 set_identifier_type_value (tree id, tree decl)
1715 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1718 /* Return the name for the constructor (or destructor) for the
1719 specified class TYPE. When given a template, this routine doesn't
1720 lose the specialization. */
1723 constructor_name_full (tree type)
1725 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1728 /* Return the name for the constructor (or destructor) for the
1729 specified class. When given a template, return the plain
1730 unspecialized name. */
1733 constructor_name (tree type)
1736 name = constructor_name_full (type);
1737 if (IDENTIFIER_TEMPLATE (name))
1738 name = IDENTIFIER_TEMPLATE (name);
1742 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1743 which must be a class type. */
1746 constructor_name_p (tree name, tree type)
1750 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1755 if (TREE_CODE (name) != IDENTIFIER_NODE)
1758 ctor_name = constructor_name_full (type);
1759 if (name == ctor_name)
1761 if (IDENTIFIER_TEMPLATE (ctor_name)
1762 && name == IDENTIFIER_TEMPLATE (ctor_name))
1767 /* Counter used to create anonymous type names. */
1769 static GTY(()) int anon_cnt;
1771 /* Return an IDENTIFIER which can be used as a name for
1772 anonymous structs and unions. */
1775 make_anon_name (void)
1779 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1780 return get_identifier (buf);
1783 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1785 static inline cxx_binding *
1786 find_binding (cxx_scope *scope, cxx_binding *binding)
1788 timevar_push (TV_NAME_LOOKUP);
1790 for (; binding != NULL; binding = binding->previous)
1791 if (binding->scope == scope)
1792 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1794 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1797 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1799 static inline cxx_binding *
1800 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1802 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1805 /* Fold-in case where NAME is used only once. */
1806 if (scope == b->scope && b->previous == NULL)
1808 return find_binding (scope, b);
1813 /* Always returns a binding for name in scope. If no binding is
1814 found, make a new one. */
1816 static cxx_binding *
1817 binding_for_name (cxx_scope *scope, tree name)
1819 cxx_binding *result;
1821 result = cxx_scope_find_binding_for_name (scope, name);
1824 /* Not found, make a new one. */
1825 result = cxx_binding_make (NULL, NULL);
1826 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1827 result->scope = scope;
1828 result->is_local = false;
1829 result->value_is_inherited = false;
1830 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1834 /* Insert another USING_DECL into the current binding level, returning
1835 this declaration. If this is a redeclaration, do nothing, and
1836 return NULL_TREE if this not in namespace scope (in namespace
1837 scope, a using decl might extend any previous bindings). */
1840 push_using_decl (tree scope, tree name)
1844 timevar_push (TV_NAME_LOOKUP);
1845 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1846 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1847 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1848 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1851 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1852 namespace_bindings_p () ? decl : NULL_TREE);
1853 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1854 USING_DECL_SCOPE (decl) = scope;
1855 TREE_CHAIN (decl) = current_binding_level->usings;
1856 current_binding_level->usings = decl;
1857 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1860 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1861 caller to set DECL_CONTEXT properly. */
1864 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1866 struct cp_binding_level *b;
1867 tree function_decl = current_function_decl;
1869 timevar_push (TV_NAME_LOOKUP);
1870 current_function_decl = NULL_TREE;
1871 if (level->kind == sk_class)
1873 b = class_binding_level;
1874 class_binding_level = level;
1875 pushdecl_class_level (x);
1876 class_binding_level = b;
1880 b = current_binding_level;
1881 current_binding_level = level;
1882 x = pushdecl_maybe_friend (x, is_friend);
1883 current_binding_level = b;
1885 current_function_decl = function_decl;
1886 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1889 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1890 other definitions already in place. We get around this by making
1891 the value of the identifier point to a list of all the things that
1892 want to be referenced by that name. It is then up to the users of
1893 that name to decide what to do with that list.
1895 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1896 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1898 FLAGS is a bitwise-or of the following values:
1899 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1901 PUSH_USING: DECL is being pushed as the result of a using
1904 IS_FRIEND is true if this is a friend declaration.
1906 The value returned may be a previous declaration if we guessed wrong
1907 about what language DECL should belong to (C or C++). Otherwise,
1908 it's always DECL (and never something that's not a _DECL). */
1911 push_overloaded_decl (tree decl, int flags, bool is_friend)
1913 tree name = DECL_NAME (decl);
1916 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1918 timevar_push (TV_NAME_LOOKUP);
1920 old = namespace_binding (name, DECL_CONTEXT (decl));
1922 old = lookup_name_innermost_nonclass_level (name);
1926 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1928 tree t = TREE_TYPE (old);
1929 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
1930 && (! DECL_IN_SYSTEM_HEADER (decl)
1931 || ! DECL_IN_SYSTEM_HEADER (old)))
1932 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
1935 else if (is_overloaded_fn (old))
1939 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1941 tree fn = OVL_CURRENT (tmp);
1944 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1945 && !(flags & PUSH_USING)
1946 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1947 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1948 && ! decls_match (fn, decl))
1949 error ("%q#D conflicts with previous using declaration %q#D",
1952 dup = duplicate_decls (decl, fn, is_friend);
1953 /* If DECL was a redeclaration of FN -- even an invalid
1954 one -- pass that information along to our caller. */
1955 if (dup == fn || dup == error_mark_node)
1956 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1959 /* We don't overload implicit built-ins. duplicate_decls()
1960 may fail to merge the decls if the new decl is e.g. a
1961 template function. */
1962 if (TREE_CODE (old) == FUNCTION_DECL
1963 && DECL_ANTICIPATED (old)
1964 && !DECL_HIDDEN_FRIEND_P (old))
1967 else if (old == error_mark_node)
1968 /* Ignore the undefined symbol marker. */
1972 error ("previous non-function declaration %q+#D", old);
1973 error ("conflicts with function declaration %q#D", decl);
1974 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1978 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1979 /* If it's a using declaration, we always need to build an OVERLOAD,
1980 because it's the only way to remember that the declaration comes
1981 from 'using', and have the lookup behave correctly. */
1982 || (flags & PUSH_USING))
1984 if (old && TREE_CODE (old) != OVERLOAD)
1985 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1987 new_binding = ovl_cons (decl, old);
1988 if (flags & PUSH_USING)
1989 OVL_USED (new_binding) = 1;
1992 /* NAME is not ambiguous. */
1996 set_namespace_binding (name, current_namespace, new_binding);
1999 /* We only create an OVERLOAD if there was a previous binding at
2000 this level, or if decl is a template. In the former case, we
2001 need to remove the old binding and replace it with the new
2002 binding. We must also run through the NAMES on the binding
2003 level where the name was bound to update the chain. */
2005 if (TREE_CODE (new_binding) == OVERLOAD && old)
2009 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2011 d = &TREE_CHAIN (*d))
2013 || (TREE_CODE (*d) == TREE_LIST
2014 && TREE_VALUE (*d) == old))
2016 if (TREE_CODE (*d) == TREE_LIST)
2017 /* Just replace the old binding with the new. */
2018 TREE_VALUE (*d) = new_binding;
2020 /* Build a TREE_LIST to wrap the OVERLOAD. */
2021 *d = tree_cons (NULL_TREE, new_binding,
2024 /* And update the cxx_binding node. */
2025 IDENTIFIER_BINDING (name)->value = new_binding;
2026 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2029 /* We should always find a previous binding in this case. */
2033 /* Install the new binding. */
2034 push_local_binding (name, new_binding, flags);
2037 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2040 /* Check a non-member using-declaration. Return the name and scope
2041 being used, and the USING_DECL, or NULL_TREE on failure. */
2044 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2046 /* [namespace.udecl]
2047 A using-declaration for a class member shall be a
2048 member-declaration. */
2051 error ("%qT is not a namespace", scope);
2054 else if (scope == error_mark_node)
2057 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2060 A using-declaration shall not name a template-id. */
2061 error ("a using-declaration cannot specify a template-id. "
2062 "Try %<using %D%>", name);
2066 if (TREE_CODE (decl) == NAMESPACE_DECL)
2068 error ("namespace %qD not allowed in using-declaration", decl);
2072 if (TREE_CODE (decl) == SCOPE_REF)
2074 /* It's a nested name with template parameter dependent scope.
2075 This can only be using-declaration for class member. */
2076 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2080 if (is_overloaded_fn (decl))
2081 decl = get_first_fn (decl);
2083 gcc_assert (DECL_P (decl));
2085 /* Make a USING_DECL. */
2086 return push_using_decl (scope, name);
2089 /* Process local and global using-declarations. */
2092 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2093 tree *newval, tree *newtype)
2095 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2097 *newval = *newtype = NULL_TREE;
2098 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2102 if (!decls.value && !decls.type)
2104 error ("%qD not declared", name);
2108 /* Shift the old and new bindings around so we're comparing class and
2109 enumeration names to each other. */
2110 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2116 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2118 decls.type = decls.value;
2119 decls.value = NULL_TREE;
2122 /* It is impossible to overload a built-in function; any explicit
2123 declaration eliminates the built-in declaration. So, if OLDVAL
2124 is a built-in, then we can just pretend it isn't there. */
2126 && TREE_CODE (oldval) == FUNCTION_DECL
2127 && DECL_ANTICIPATED (oldval)
2128 && !DECL_HIDDEN_FRIEND_P (oldval))
2133 /* Check for using functions. */
2134 if (is_overloaded_fn (decls.value))
2138 if (oldval && !is_overloaded_fn (oldval))
2140 error ("%qD is already declared in this scope", name);
2145 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2147 tree new_fn = OVL_CURRENT (tmp);
2149 /* [namespace.udecl]
2151 If a function declaration in namespace scope or block
2152 scope has the same name and the same parameter types as a
2153 function introduced by a using declaration the program is
2155 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2157 tree old_fn = OVL_CURRENT (tmp1);
2159 if (new_fn == old_fn)
2160 /* The function already exists in the current namespace. */
2162 else if (OVL_USED (tmp1))
2163 continue; /* this is a using decl */
2164 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2165 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2167 gcc_assert (!DECL_ANTICIPATED (old_fn)
2168 || DECL_HIDDEN_FRIEND_P (old_fn));
2170 /* There was already a non-using declaration in
2171 this scope with the same parameter types. If both
2172 are the same extern "C" functions, that's ok. */
2173 if (decls_match (new_fn, old_fn))
2177 error ("%qD is already declared in this scope", name);
2183 /* If we broke out of the loop, there's no reason to add
2184 this function to the using declarations for this
2189 /* If we are adding to an existing OVERLOAD, then we no
2190 longer know the type of the set of functions. */
2191 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2192 TREE_TYPE (*newval) = unknown_type_node;
2193 /* Add this new function to the set. */
2194 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2195 /* If there is only one function, then we use its type. (A
2196 using-declaration naming a single function can be used in
2197 contexts where overload resolution cannot be
2199 if (TREE_CODE (*newval) != OVERLOAD)
2201 *newval = ovl_cons (*newval, NULL_TREE);
2202 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2204 OVL_USED (*newval) = 1;
2209 *newval = decls.value;
2210 if (oldval && !decls_match (*newval, oldval))
2211 error ("%qD is already declared in this scope", name);
2217 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2219 error ("reference to %qD is ambiguous", name);
2220 print_candidates (decls.type);
2224 *newtype = decls.type;
2225 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2226 error ("%qD is already declared in this scope", name);
2229 /* If *newval is empty, shift any class or enumeration name down. */
2233 *newtype = NULL_TREE;
2237 /* Process a using-declaration at function scope. */
2240 do_local_using_decl (tree decl, tree scope, tree name)
2242 tree oldval, oldtype, newval, newtype;
2243 tree orig_decl = decl;
2245 decl = validate_nonmember_using_decl (decl, scope, name);
2246 if (decl == NULL_TREE)
2249 if (building_stmt_tree ()
2250 && at_function_scope_p ())
2251 add_decl_expr (decl);
2253 oldval = lookup_name_innermost_nonclass_level (name);
2254 oldtype = lookup_type_current_level (name);
2256 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2260 if (is_overloaded_fn (newval))
2264 /* We only need to push declarations for those functions
2265 that were not already bound in the current level.
2266 The old value might be NULL_TREE, it might be a single
2267 function, or an OVERLOAD. */
2268 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2269 term = OVL_FUNCTION (oldval);
2272 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2274 push_overloaded_decl (OVL_CURRENT (fn),
2275 PUSH_LOCAL | PUSH_USING,
2279 push_local_binding (name, newval, PUSH_USING);
2283 push_local_binding (name, newtype, PUSH_USING);
2284 set_identifier_type_value (name, newtype);
2287 /* Emit debug info. */
2288 if (!processing_template_decl)
2289 cp_emit_debug_info_for_using (orig_decl, current_scope());
2292 /* Returns true if ROOT (a namespace, class, or function) encloses
2293 CHILD. CHILD may be either a class type or a namespace. */
2296 is_ancestor (tree root, tree child)
2298 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2299 || TREE_CODE (root) == FUNCTION_DECL
2300 || CLASS_TYPE_P (root)));
2301 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2302 || CLASS_TYPE_P (child)));
2304 /* The global namespace encloses everything. */
2305 if (root == global_namespace)
2310 /* If we've run out of scopes, stop. */
2313 /* If we've reached the ROOT, it encloses CHILD. */
2316 /* Go out one level. */
2318 child = TYPE_NAME (child);
2319 child = DECL_CONTEXT (child);
2323 /* Enter the class or namespace scope indicated by T suitable for name
2324 lookup. T can be arbitrary scope, not necessary nested inside the
2325 current scope. Returns a non-null scope to pop iff pop_scope
2326 should be called later to exit this scope. */
2331 if (TREE_CODE (t) == NAMESPACE_DECL)
2332 push_decl_namespace (t);
2333 else if (CLASS_TYPE_P (t))
2335 if (!at_class_scope_p ()
2336 || !same_type_p (current_class_type, t))
2337 push_nested_class (t);
2339 /* T is the same as the current scope. There is therefore no
2340 need to re-enter the scope. Since we are not actually
2341 pushing a new scope, our caller should not call
2349 /* Leave scope pushed by push_scope. */
2354 if (TREE_CODE (t) == NAMESPACE_DECL)
2355 pop_decl_namespace ();
2356 else if CLASS_TYPE_P (t)
2357 pop_nested_class ();
2360 /* Subroutine of push_inner_scope. */
2363 push_inner_scope_r (tree outer, tree inner)
2368 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2371 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2373 push_inner_scope_r (outer, prev);
2374 if (TREE_CODE (inner) == NAMESPACE_DECL)
2376 struct cp_binding_level *save_template_parm = 0;
2377 /* Temporary take out template parameter scopes. They are saved
2378 in reversed order in save_template_parm. */
2379 while (current_binding_level->kind == sk_template_parms)
2381 struct cp_binding_level *b = current_binding_level;
2382 current_binding_level = b->level_chain;
2383 b->level_chain = save_template_parm;
2384 save_template_parm = b;
2387 resume_scope (NAMESPACE_LEVEL (inner));
2388 current_namespace = inner;
2390 /* Restore template parameter scopes. */
2391 while (save_template_parm)
2393 struct cp_binding_level *b = save_template_parm;
2394 save_template_parm = b->level_chain;
2395 b->level_chain = current_binding_level;
2396 current_binding_level = b;
2403 /* Enter the scope INNER from current scope. INNER must be a scope
2404 nested inside current scope. This works with both name lookup and
2405 pushing name into scope. In case a template parameter scope is present,
2406 namespace is pushed under the template parameter scope according to
2407 name lookup rule in 14.6.1/6.
2409 Return the former current scope suitable for pop_inner_scope. */
2412 push_inner_scope (tree inner)
2414 tree outer = current_scope ();
2416 outer = current_namespace;
2418 push_inner_scope_r (outer, inner);
2422 /* Exit the current scope INNER back to scope OUTER. */
2425 pop_inner_scope (tree outer, tree inner)
2428 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2431 while (outer != inner)
2433 if (TREE_CODE (inner) == NAMESPACE_DECL)
2435 struct cp_binding_level *save_template_parm = 0;
2436 /* Temporary take out template parameter scopes. They are saved
2437 in reversed order in save_template_parm. */
2438 while (current_binding_level->kind == sk_template_parms)
2440 struct cp_binding_level *b = current_binding_level;
2441 current_binding_level = b->level_chain;
2442 b->level_chain = save_template_parm;
2443 save_template_parm = b;
2448 /* Restore template parameter scopes. */
2449 while (save_template_parm)
2451 struct cp_binding_level *b = save_template_parm;
2452 save_template_parm = b->level_chain;
2453 b->level_chain = current_binding_level;
2454 current_binding_level = b;
2460 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2464 /* Do a pushlevel for class declarations. */
2467 pushlevel_class (void)
2469 if (ENABLE_SCOPE_CHECKING)
2472 class_binding_level = begin_scope (sk_class, current_class_type);
2475 /* ...and a poplevel for class declarations. */
2478 poplevel_class (void)
2480 struct cp_binding_level *level = class_binding_level;
2481 cp_class_binding *cb;
2485 timevar_push (TV_NAME_LOOKUP);
2486 gcc_assert (level != 0);
2488 /* If we're leaving a toplevel class, cache its binding level. */
2489 if (current_class_depth == 1)
2490 previous_class_level = level;
2491 for (shadowed = level->type_shadowed;
2493 shadowed = TREE_CHAIN (shadowed))
2494 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2496 /* Remove the bindings for all of the class-level declarations. */
2497 if (level->class_shadowed)
2500 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2502 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2503 ggc_free (level->class_shadowed);
2504 level->class_shadowed = NULL;
2507 /* Now, pop out of the binding level which we created up in the
2508 `pushlevel_class' routine. */
2509 if (ENABLE_SCOPE_CHECKING)
2513 timevar_pop (TV_NAME_LOOKUP);
2516 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2517 appropriate. DECL is the value to which a name has just been
2518 bound. CLASS_TYPE is the class in which the lookup occurred. */
2521 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2524 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2528 if (TREE_CODE (decl) == OVERLOAD)
2529 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2532 gcc_assert (DECL_P (decl));
2533 context = context_for_name_lookup (decl);
2536 if (is_properly_derived_from (class_type, context))
2537 INHERITED_VALUE_BINDING_P (binding) = 1;
2539 INHERITED_VALUE_BINDING_P (binding) = 0;
2541 else if (binding->value == decl)
2542 /* We only encounter a TREE_LIST when there is an ambiguity in the
2543 base classes. Such an ambiguity can be overridden by a
2544 definition in this class. */
2545 INHERITED_VALUE_BINDING_P (binding) = 1;
2547 INHERITED_VALUE_BINDING_P (binding) = 0;
2550 /* Make the declaration of X appear in CLASS scope. */
2553 pushdecl_class_level (tree x)
2556 bool is_valid = true;
2558 timevar_push (TV_NAME_LOOKUP);
2559 /* Get the name of X. */
2560 if (TREE_CODE (x) == OVERLOAD)
2561 name = DECL_NAME (get_first_fn (x));
2563 name = DECL_NAME (x);
2567 is_valid = push_class_level_binding (name, x);
2568 if (TREE_CODE (x) == TYPE_DECL)
2569 set_identifier_type_value (name, x);
2571 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2573 /* If X is an anonymous aggregate, all of its members are
2574 treated as if they were members of the class containing the
2575 aggregate, for naming purposes. */
2578 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2580 location_t save_location = input_location;
2581 input_location = DECL_SOURCE_LOCATION (f);
2582 if (!pushdecl_class_level (f))
2584 input_location = save_location;
2587 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2590 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2591 scope. If the value returned is non-NULL, and the PREVIOUS field
2592 is not set, callers must set the PREVIOUS field explicitly. */
2594 static cxx_binding *
2595 get_class_binding (tree name, cxx_scope *scope)
2600 cxx_binding *binding;
2602 class_type = scope->this_entity;
2604 /* Get the type binding. */
2605 type_binding = lookup_member (class_type, name,
2606 /*protect=*/2, /*want_type=*/true);
2607 /* Get the value binding. */
2608 value_binding = lookup_member (class_type, name,
2609 /*protect=*/2, /*want_type=*/false);
2612 && (TREE_CODE (value_binding) == TYPE_DECL
2613 || DECL_CLASS_TEMPLATE_P (value_binding)
2614 || (TREE_CODE (value_binding) == TREE_LIST
2615 && TREE_TYPE (value_binding) == error_mark_node
2616 && (TREE_CODE (TREE_VALUE (value_binding))
2618 /* We found a type binding, even when looking for a non-type
2619 binding. This means that we already processed this binding
2622 else if (value_binding)
2624 if (TREE_CODE (value_binding) == TREE_LIST
2625 && TREE_TYPE (value_binding) == error_mark_node)
2626 /* NAME is ambiguous. */
2628 else if (BASELINK_P (value_binding))
2629 /* NAME is some overloaded functions. */
2630 value_binding = BASELINK_FUNCTIONS (value_binding);
2633 /* If we found either a type binding or a value binding, create a
2634 new binding object. */
2635 if (type_binding || value_binding)
2637 binding = new_class_binding (name,
2641 /* This is a class-scope binding, not a block-scope binding. */
2642 LOCAL_BINDING_P (binding) = 0;
2643 set_inherited_value_binding_p (binding, value_binding, class_type);
2651 /* Make the declaration(s) of X appear in CLASS scope under the name
2652 NAME. Returns true if the binding is valid. */
2655 push_class_level_binding (tree name, tree x)
2657 cxx_binding *binding;
2661 timevar_push (TV_NAME_LOOKUP);
2662 /* The class_binding_level will be NULL if x is a template
2663 parameter name in a member template. */
2664 if (!class_binding_level)
2665 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2667 if (name == error_mark_node)
2668 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2670 /* Check for invalid member names. */
2671 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2672 /* We could have been passed a tree list if this is an ambiguous
2673 declaration. If so, pull the declaration out because
2674 check_template_shadow will not handle a TREE_LIST. */
2675 if (TREE_CODE (decl) == TREE_LIST
2676 && TREE_TYPE (decl) == error_mark_node)
2677 decl = TREE_VALUE (decl);
2679 check_template_shadow (decl);
2683 If T is the name of a class, then each of the following shall
2684 have a name different from T:
2686 -- every static data member of class T;
2688 -- every member of class T that is itself a type;
2690 -- every enumerator of every member of class T that is an
2693 -- every member of every anonymous union that is a member of
2696 (Non-static data members were also forbidden to have the same
2697 name as T until TC1.) */
2698 if ((TREE_CODE (x) == VAR_DECL
2699 || TREE_CODE (x) == CONST_DECL
2700 || (TREE_CODE (x) == TYPE_DECL
2701 && !DECL_SELF_REFERENCE_P (x))
2702 /* A data member of an anonymous union. */
2703 || (TREE_CODE (x) == FIELD_DECL
2704 && DECL_CONTEXT (x) != current_class_type))
2705 && DECL_NAME (x) == constructor_name (current_class_type))
2707 tree scope = context_for_name_lookup (x);
2708 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2710 error ("%qD has the same name as the class in which it is "
2713 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2717 /* Get the current binding for NAME in this class, if any. */
2718 binding = IDENTIFIER_BINDING (name);
2719 if (!binding || binding->scope != class_binding_level)
2721 binding = get_class_binding (name, class_binding_level);
2722 /* If a new binding was created, put it at the front of the
2723 IDENTIFIER_BINDING list. */
2726 binding->previous = IDENTIFIER_BINDING (name);
2727 IDENTIFIER_BINDING (name) = binding;
2731 /* If there is already a binding, then we may need to update the
2733 if (binding && binding->value)
2735 tree bval = binding->value;
2736 tree old_decl = NULL_TREE;
2738 if (INHERITED_VALUE_BINDING_P (binding))
2740 /* If the old binding was from a base class, and was for a
2741 tag name, slide it over to make room for the new binding.
2742 The old binding is still visible if explicitly qualified
2743 with a class-key. */
2744 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2745 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2747 old_decl = binding->type;
2748 binding->type = bval;
2749 binding->value = NULL_TREE;
2750 INHERITED_VALUE_BINDING_P (binding) = 0;
2755 /* Any inherited type declaration is hidden by the type
2756 declaration in the derived class. */
2757 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2758 binding->type = NULL_TREE;
2761 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2763 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2764 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2765 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2767 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2768 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2770 if (old_decl && binding->scope == class_binding_level)
2773 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2774 here. This function is only used to register bindings
2775 from with the class definition itself. */
2776 INHERITED_VALUE_BINDING_P (binding) = 0;
2777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2781 /* Note that we declared this value so that we can issue an error if
2782 this is an invalid redeclaration of a name already used for some
2784 note_name_declared_in_class (name, decl);
2786 /* If we didn't replace an existing binding, put the binding on the
2787 stack of bindings for the identifier, and update the shadowed
2789 if (binding && binding->scope == class_binding_level)
2790 /* Supplement the existing binding. */
2791 ok = supplement_binding (binding, decl);
2794 /* Create a new binding. */
2795 push_binding (name, decl, class_binding_level);
2799 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2802 /* Process "using SCOPE::NAME" in a class scope. Return the
2803 USING_DECL created. */
2806 do_class_using_decl (tree scope, tree name)
2808 /* The USING_DECL returned by this function. */
2810 /* The declaration (or declarations) name by this using
2811 declaration. NULL if we are in a template and cannot figure out
2812 what has been named. */
2814 /* True if SCOPE is a dependent type. */
2815 bool scope_dependent_p;
2816 /* True if SCOPE::NAME is dependent. */
2817 bool name_dependent_p;
2818 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2819 bool bases_dependent_p;
2824 if (name == error_mark_node)
2827 if (!scope || !TYPE_P (scope))
2829 error ("using-declaration for non-member at class scope");
2833 /* Make sure the name is not invalid */
2834 if (TREE_CODE (name) == BIT_NOT_EXPR)
2836 error ("%<%T::%D%> names destructor", scope, name);
2839 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2841 error ("%<%T::%D%> names constructor", scope, name);
2844 if (constructor_name_p (name, current_class_type))
2846 error ("%<%T::%D%> names constructor in %qT",
2847 scope, name, current_class_type);
2851 scope_dependent_p = dependent_type_p (scope);
2852 name_dependent_p = (scope_dependent_p
2853 || (IDENTIFIER_TYPENAME_P (name)
2854 && dependent_type_p (TREE_TYPE (name))));
2856 bases_dependent_p = false;
2857 if (processing_template_decl)
2858 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2859 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2861 if (dependent_type_p (TREE_TYPE (base_binfo)))
2863 bases_dependent_p = true;
2869 /* From [namespace.udecl]:
2871 A using-declaration used as a member-declaration shall refer to a
2872 member of a base class of the class being defined.
2874 In general, we cannot check this constraint in a template because
2875 we do not know the entire set of base classes of the current
2876 class type. However, if all of the base classes are
2877 non-dependent, then we can avoid delaying the check until
2879 if (!scope_dependent_p)
2882 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2883 if (b_kind < bk_proper_base)
2885 if (!bases_dependent_p)
2887 error_not_base_type (scope, current_class_type);
2891 else if (!name_dependent_p)
2893 decl = lookup_member (binfo, name, 0, false);
2896 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2900 /* The binfo from which the functions came does not matter. */
2901 if (BASELINK_P (decl))
2902 decl = BASELINK_FUNCTIONS (decl);
2906 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2907 USING_DECL_DECLS (value) = decl;
2908 USING_DECL_SCOPE (value) = scope;
2909 DECL_DEPENDENT_P (value) = !decl;
2915 /* Return the binding value for name in scope. */
2918 namespace_binding (tree name, tree scope)
2920 cxx_binding *binding;
2923 scope = global_namespace;
2925 /* Unnecessary for the global namespace because it can't be an alias. */
2926 scope = ORIGINAL_NAMESPACE (scope);
2928 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2930 return binding ? binding->value : NULL_TREE;
2933 /* Set the binding value for name in scope. */
2936 set_namespace_binding (tree name, tree scope, tree val)
2940 timevar_push (TV_NAME_LOOKUP);
2941 if (scope == NULL_TREE)
2942 scope = global_namespace;
2943 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2944 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2947 supplement_binding (b, val);
2948 timevar_pop (TV_NAME_LOOKUP);
2951 /* Set the context of a declaration to scope. Complain if we are not
2955 set_decl_namespace (tree decl, tree scope, bool friendp)
2959 /* Get rid of namespace aliases. */
2960 scope = ORIGINAL_NAMESPACE (scope);
2962 /* It is ok for friends to be qualified in parallel space. */
2963 if (!friendp && !is_ancestor (current_namespace, scope))
2964 error ("declaration of %qD not in a namespace surrounding %qD",
2966 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2968 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2969 if (scope == current_namespace)
2971 if (at_namespace_scope_p ())
2972 error ("explicit qualification in declaration of %qD",
2977 /* See whether this has been declared in the namespace. */
2978 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2979 if (old == error_mark_node)
2980 /* No old declaration at all. */
2982 if (!is_overloaded_fn (decl))
2983 /* Don't compare non-function decls with decls_match here, since
2984 it can't check for the correct constness at this
2985 point. pushdecl will find those errors later. */
2987 /* Since decl is a function, old should contain a function decl. */
2988 if (!is_overloaded_fn (old))
2990 fn = OVL_CURRENT (old);
2991 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2993 /* A template can be explicitly specialized in any namespace. */
2994 if (processing_explicit_instantiation)
2996 if (processing_template_decl || processing_specialization)
2997 /* We have not yet called push_template_decl to turn a
2998 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2999 match. But, we'll check later, when we construct the
3002 /* Instantiations or specializations of templates may be declared as
3003 friends in any namespace. */
3004 if (friendp && DECL_USE_TEMPLATE (decl))
3006 if (is_overloaded_fn (old))
3008 for (; old; old = OVL_NEXT (old))
3009 if (decls_match (decl, OVL_CURRENT (old)))
3012 else if (decls_match (decl, old))
3015 error ("%qD should have been declared inside %qD", decl, scope);
3018 /* Return the namespace where the current declaration is declared. */
3021 current_decl_namespace (void)
3024 /* If we have been pushed into a different namespace, use it. */
3025 if (decl_namespace_list)
3026 return TREE_PURPOSE (decl_namespace_list);
3028 if (current_class_type)
3029 result = decl_namespace_context (current_class_type);
3030 else if (current_function_decl)
3031 result = decl_namespace_context (current_function_decl);
3033 result = current_namespace;
3037 /* Process any ATTRIBUTES on a namespace definition. Currently only
3038 attribute visibility is meaningful, which is a property of the syntactic
3039 block rather than the namespace as a whole, so we don't touch the
3040 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3043 handle_namespace_attrs (tree ns, tree attributes)
3046 bool saw_vis = false;
3048 for (d = attributes; d; d = TREE_CHAIN (d))
3050 tree name = TREE_PURPOSE (d);
3051 tree args = TREE_VALUE (d);
3053 #ifdef HANDLE_PRAGMA_VISIBILITY
3054 if (is_attribute_p ("visibility", name))
3056 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3057 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3059 warning (OPT_Wattributes,
3060 "%qD attribute requires a single NTBS argument",
3065 if (!TREE_PUBLIC (ns))
3066 warning (OPT_Wattributes,
3067 "%qD attribute is meaningless since members of the "
3068 "anonymous namespace get local symbols", name);
3070 push_visibility (TREE_STRING_POINTER (x));
3076 warning (OPT_Wattributes, "%qD attribute directive ignored",
3085 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3086 select a name that is unique to this compilation unit. */
3089 push_namespace (tree name)
3093 int implicit_use = 0;
3096 timevar_push (TV_NAME_LOOKUP);
3098 /* We should not get here if the global_namespace is not yet constructed
3099 nor if NAME designates the global namespace: The global scope is
3100 constructed elsewhere. */
3101 gcc_assert (global_namespace != NULL && name != global_scope_name);
3105 name = get_anonymous_namespace_name();
3106 d = IDENTIFIER_NAMESPACE_VALUE (name);
3108 /* Reopening anonymous namespace. */
3114 /* Check whether this is an extended namespace definition. */
3115 d = IDENTIFIER_NAMESPACE_VALUE (name);
3116 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3119 if (DECL_NAMESPACE_ALIAS (d))
3121 error ("namespace alias %qD not allowed here, assuming %qD",
3122 d, DECL_NAMESPACE_ALIAS (d));
3123 d = DECL_NAMESPACE_ALIAS (d);
3130 /* Make a new namespace, binding the name to it. */
3131 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3132 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3133 /* The name of this namespace is not visible to other translation
3134 units if it is an anonymous namespace or member thereof. */
3135 if (anon || decl_anon_ns_mem_p (current_namespace))
3136 TREE_PUBLIC (d) = 0;
3138 TREE_PUBLIC (d) = 1;
3142 /* Clear DECL_NAME for the benefit of debugging back ends. */
3143 SET_DECL_ASSEMBLER_NAME (d, name);
3144 DECL_NAME (d) = NULL_TREE;
3146 begin_scope (sk_namespace, d);
3149 resume_scope (NAMESPACE_LEVEL (d));
3152 do_using_directive (d);
3153 /* Enter the name space. */
3154 current_namespace = d;
3156 timevar_pop (TV_NAME_LOOKUP);
3159 /* Pop from the scope of the current namespace. */
3162 pop_namespace (void)
3164 gcc_assert (current_namespace != global_namespace);
3165 current_namespace = CP_DECL_CONTEXT (current_namespace);
3166 /* The binding level is not popped, as it might be re-opened later. */
3170 /* Push into the scope of the namespace NS, even if it is deeply
3171 nested within another namespace. */
3174 push_nested_namespace (tree ns)
3176 if (ns == global_namespace)
3177 push_to_top_level ();
3180 push_nested_namespace (CP_DECL_CONTEXT (ns));
3181 push_namespace (DECL_NAME (ns));
3185 /* Pop back from the scope of the namespace NS, which was previously
3186 entered with push_nested_namespace. */
3189 pop_nested_namespace (tree ns)
3191 timevar_push (TV_NAME_LOOKUP);
3192 while (ns != global_namespace)
3195 ns = CP_DECL_CONTEXT (ns);
3198 pop_from_top_level ();
3199 timevar_pop (TV_NAME_LOOKUP);
3202 /* Temporarily set the namespace for the current declaration. */
3205 push_decl_namespace (tree decl)
3207 if (TREE_CODE (decl) != NAMESPACE_DECL)
3208 decl = decl_namespace_context (decl);
3209 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3210 NULL_TREE, decl_namespace_list);
3213 /* [namespace.memdef]/2 */
3216 pop_decl_namespace (void)
3218 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3221 /* Return the namespace that is the common ancestor
3222 of two given namespaces. */
3225 namespace_ancestor (tree ns1, tree ns2)
3227 timevar_push (TV_NAME_LOOKUP);
3228 if (is_ancestor (ns1, ns2))
3229 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3230 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3231 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3234 /* Process a namespace-alias declaration. */
3237 do_namespace_alias (tree alias, tree namespace)
3239 if (namespace == error_mark_node)
3242 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3244 namespace = ORIGINAL_NAMESPACE (namespace);
3246 /* Build the alias. */
3247 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3248 DECL_NAMESPACE_ALIAS (alias) = namespace;
3249 DECL_EXTERNAL (alias) = 1;
3250 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3253 /* Emit debug info for namespace alias. */
3254 (*debug_hooks->global_decl) (alias);
3257 /* Like pushdecl, only it places X in the current namespace,
3261 pushdecl_namespace_level (tree x, bool is_friend)
3263 struct cp_binding_level *b = current_binding_level;
3266 timevar_push (TV_NAME_LOOKUP);
3267 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3269 /* Now, the type_shadowed stack may screw us. Munge it so it does
3271 if (TREE_CODE (t) == TYPE_DECL)
3273 tree name = DECL_NAME (t);
3275 tree *ptr = (tree *)0;
3276 for (; !global_scope_p (b); b = b->level_chain)
3278 tree shadowed = b->type_shadowed;
3279 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3280 if (TREE_PURPOSE (shadowed) == name)
3282 ptr = &TREE_VALUE (shadowed);
3283 /* Can't break out of the loop here because sometimes
3284 a binding level will have duplicate bindings for
3285 PT names. It's gross, but I haven't time to fix it. */
3288 newval = TREE_TYPE (t);
3289 if (ptr == (tree *)0)
3291 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3292 up here if this is changed to an assertion. --KR */
3293 SET_IDENTIFIER_TYPE_VALUE (name, t);
3300 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3303 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3304 directive is not directly from the source. Also find the common
3305 ancestor and let our users know about the new namespace */
3307 add_using_namespace (tree user, tree used, bool indirect)
3310 timevar_push (TV_NAME_LOOKUP);
3311 /* Using oneself is a no-op. */
3314 timevar_pop (TV_NAME_LOOKUP);
3317 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3318 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3319 /* Check if we already have this. */
3320 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3324 /* Promote to direct usage. */
3325 TREE_INDIRECT_USING (t) = 0;
3326 timevar_pop (TV_NAME_LOOKUP);
3330 /* Add used to the user's using list. */
3331 DECL_NAMESPACE_USING (user)
3332 = tree_cons (used, namespace_ancestor (user, used),
3333 DECL_NAMESPACE_USING (user));
3335 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3337 /* Add user to the used's users list. */
3338 DECL_NAMESPACE_USERS (used)
3339 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3341 /* Recursively add all namespaces used. */
3342 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3343 /* indirect usage */
3344 add_using_namespace (user, TREE_PURPOSE (t), 1);
3346 /* Tell everyone using us about the new used namespaces. */
3347 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3348 add_using_namespace (TREE_PURPOSE (t), used, 1);
3349 timevar_pop (TV_NAME_LOOKUP);
3352 /* Process a using-declaration not appearing in class or local scope. */
3355 do_toplevel_using_decl (tree decl, tree scope, tree name)
3357 tree oldval, oldtype, newval, newtype;
3358 tree orig_decl = decl;
3359 cxx_binding *binding;
3361 decl = validate_nonmember_using_decl (decl, scope, name);
3362 if (decl == NULL_TREE)
3365 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3367 oldval = binding->value;
3368 oldtype = binding->type;
3370 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3372 /* Emit debug info. */
3373 if (!processing_template_decl)
3374 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3376 /* Copy declarations found. */
3378 binding->value = newval;
3380 binding->type = newtype;
3383 /* Process a using-directive. */
3386 do_using_directive (tree namespace)
3388 tree context = NULL_TREE;
3390 if (namespace == error_mark_node)
3393 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3395 if (building_stmt_tree ())
3396 add_stmt (build_stmt (USING_STMT, namespace));
3397 namespace = ORIGINAL_NAMESPACE (namespace);
3399 if (!toplevel_bindings_p ())
3401 push_using_directive (namespace);
3402 context = current_scope ();
3407 add_using_namespace (current_namespace, namespace, 0);
3408 if (current_namespace != global_namespace)
3409 context = current_namespace;
3412 /* Emit debugging info. */
3413 if (!processing_template_decl)
3414 (*debug_hooks->imported_module_or_decl) (namespace, context);
3417 /* Deal with a using-directive seen by the parser. Currently we only
3418 handle attributes here, since they cannot appear inside a template. */
3421 parse_using_directive (tree namespace, tree attribs)
3425 do_using_directive (namespace);
3427 for (a = attribs; a; a = TREE_CHAIN (a))
3429 tree name = TREE_PURPOSE (a);
3430 if (is_attribute_p ("strong", name))
3432 if (!toplevel_bindings_p ())
3433 error ("strong using only meaningful at namespace scope");
3434 else if (namespace != error_mark_node)
3436 if (!is_ancestor (current_namespace, namespace))
3437 error ("current namespace %qD does not enclose strongly used namespace %qD",
3438 current_namespace, namespace);
3439 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3440 = tree_cons (current_namespace, 0,
3441 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3445 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3449 /* Like pushdecl, only it places X in the global scope if appropriate.
3450 Calls cp_finish_decl to register the variable, initializing it with
3451 *INIT, if INIT is non-NULL. */
3454 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3456 timevar_push (TV_NAME_LOOKUP);
3457 push_to_top_level ();
3458 x = pushdecl_namespace_level (x, is_friend);
3460 finish_decl (x, *init, NULL_TREE);
3461 pop_from_top_level ();
3462 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3465 /* Like pushdecl, only it places X in the global scope if appropriate. */
3468 pushdecl_top_level (tree x)
3470 return pushdecl_top_level_1 (x, NULL, false);
3473 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3476 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3478 return pushdecl_top_level_1 (x, NULL, is_friend);
3481 /* Like pushdecl, only it places X in the global scope if
3482 appropriate. Calls cp_finish_decl to register the variable,
3483 initializing it with INIT. */
3486 pushdecl_top_level_and_finish (tree x, tree init)
3488 return pushdecl_top_level_1 (x, &init, false);
3491 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3492 duplicates. The first list becomes the tail of the result.
3494 The algorithm is O(n^2). We could get this down to O(n log n) by
3495 doing a sort on the addresses of the functions, if that becomes
3499 merge_functions (tree s1, tree s2)
3501 for (; s2; s2 = OVL_NEXT (s2))
3503 tree fn2 = OVL_CURRENT (s2);
3506 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3508 tree fn1 = OVL_CURRENT (fns1);
3510 /* If the function from S2 is already in S1, there is no
3511 need to add it again. For `extern "C"' functions, we
3512 might have two FUNCTION_DECLs for the same function, in
3513 different namespaces; again, we only need one of them. */
3515 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3516 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3520 /* If we exhausted all of the functions in S1, FN2 is new. */
3522 s1 = build_overload (fn2, s1);
3527 /* This should return an error not all definitions define functions.
3528 It is not an error if we find two functions with exactly the
3529 same signature, only if these are selected in overload resolution.
3530 old is the current set of bindings, new the freshly-found binding.
3531 XXX Do we want to give *all* candidates in case of ambiguity?
3532 XXX In what way should I treat extern declarations?
3533 XXX I don't want to repeat the entire duplicate_decls here */
3536 ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
3539 gcc_assert (old != NULL);
3541 /* Copy the type. */
3543 if (LOOKUP_NAMESPACES_ONLY (flags)
3544 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3547 /* Copy the value. */
3551 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3554 switch (TREE_CODE (val))
3557 /* If we expect types or namespaces, and not templates,
3558 or this is not a template class. */
3559 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3560 && !DECL_CLASS_TEMPLATE_P (val)))
3564 if (LOOKUP_NAMESPACES_ONLY (flags)
3565 || (type && (flags & LOOKUP_PREFER_TYPES)))
3568 case NAMESPACE_DECL:
3569 if (LOOKUP_TYPES_ONLY (flags))
3573 /* Ignore built-in functions that are still anticipated. */
3574 if (LOOKUP_QUALIFIERS_ONLY (flags))
3578 if (LOOKUP_QUALIFIERS_ONLY (flags))
3583 /* If val is hidden, shift down any class or enumeration name. */
3592 else if (val && val != old->value)
3594 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3595 old->value = merge_functions (old->value, val);
3598 old->value = tree_cons (NULL_TREE, old->value,
3599 build_tree_list (NULL_TREE, val));
3600 TREE_TYPE (old->value) = error_mark_node;
3606 else if (type && old->type != type)
3608 old->type = tree_cons (NULL_TREE, old->type,
3609 build_tree_list (NULL_TREE, type));
3610 TREE_TYPE (old->type) = error_mark_node;
3614 /* Return the declarations that are members of the namespace NS. */
3617 cp_namespace_decls (tree ns)
3619 return NAMESPACE_LEVEL (ns)->names;
3622 /* Combine prefer_type and namespaces_only into flags. */
3625 lookup_flags (int prefer_type, int namespaces_only)
3627 if (namespaces_only)
3628 return LOOKUP_PREFER_NAMESPACES;
3629 if (prefer_type > 1)
3630 return LOOKUP_PREFER_TYPES;
3631 if (prefer_type > 0)
3632 return LOOKUP_PREFER_BOTH;
3636 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3637 ignore it or not. Subroutine of lookup_name_real and
3638 lookup_type_scope. */
3641 qualify_lookup (tree val, int flags)
3643 if (val == NULL_TREE)
3645 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3647 if ((flags & LOOKUP_PREFER_TYPES)
3648 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3650 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3655 /* Given a lookup that returned VAL, decide if we want to ignore it or
3656 not based on DECL_ANTICIPATED. */
3659 hidden_name_p (tree val)
3662 && DECL_LANG_SPECIFIC (val)
3663 && DECL_ANTICIPATED (val))
3668 /* Remove any hidden friend functions from a possibly overloaded set
3672 remove_hidden_names (tree fns)
3677 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3679 else if (TREE_CODE (fns) == OVERLOAD)
3683 for (o = fns; o; o = OVL_NEXT (o))
3684 if (hidden_name_p (OVL_CURRENT (o)))
3690 for (o = fns; o; o = OVL_NEXT (o))
3691 if (!hidden_name_p (OVL_CURRENT (o)))
3692 n = build_overload (OVL_CURRENT (o), n);
3700 /* Unscoped lookup of a global: iterate over current namespaces,
3701 considering using-directives. */
3704 unqualified_namespace_lookup (tree name, int flags)
3706 tree initial = current_decl_namespace ();
3707 tree scope = initial;
3709 struct cp_binding_level *level;
3710 tree val = NULL_TREE;
3712 timevar_push (TV_NAME_LOOKUP);
3714 for (; !val; scope = CP_DECL_CONTEXT (scope))
3716 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3718 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3721 ambiguous_decl (&binding, b, flags);
3723 /* Add all _DECLs seen through local using-directives. */
3724 for (level = current_binding_level;
3725 level->kind != sk_namespace;
3726 level = level->level_chain)
3727 if (!lookup_using_namespace (name, &binding, level->using_directives,
3729 /* Give up because of error. */
3730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3732 /* Add all _DECLs seen through global using-directives. */
3733 /* XXX local and global using lists should work equally. */
3737 if (!lookup_using_namespace (name, &binding,
3738 DECL_NAMESPACE_USING (siter),
3740 /* Give up because of error. */
3741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3742 if (siter == scope) break;
3743 siter = CP_DECL_CONTEXT (siter);
3746 val = binding.value;
3747 if (scope == global_namespace)
3750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3753 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3754 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3757 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3758 declaration found. If no suitable declaration can be found,
3759 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3760 neither a class-type nor a namespace a diagnostic is issued. */
3763 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3768 if (TREE_CODE (scope) == NAMESPACE_DECL)
3770 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3772 flags |= LOOKUP_COMPLAIN;
3774 flags |= LOOKUP_PREFER_TYPES;
3775 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3778 else if (is_class_type (scope, complain))
3779 t = lookup_member (scope, name, 2, is_type_p);
3782 return error_mark_node;
3786 /* Subroutine of unqualified_namespace_lookup:
3787 Add the bindings of NAME in used namespaces to VAL.
3788 We are currently looking for names in namespace SCOPE, so we
3789 look through USINGS for using-directives of namespaces
3790 which have SCOPE as a common ancestor with the current scope.
3791 Returns false on errors. */
3794 lookup_using_namespace (tree name, struct scope_binding *val,
3795 tree usings, tree scope, int flags)
3798 timevar_push (TV_NAME_LOOKUP);
3799 /* Iterate over all used namespaces in current, searching for using
3800 directives of scope. */
3801 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3802 if (TREE_VALUE (iter) == scope)
3804 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3806 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3807 /* Resolve ambiguities. */
3809 ambiguous_decl (val, val1, flags);
3811 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3815 Accepts the NAME to lookup and its qualifying SCOPE.
3816 Returns the name/type pair found into the cxx_binding *RESULT,
3817 or false on error. */
3820 qualified_lookup_using_namespace (tree name, tree scope,
3821 struct scope_binding *result, int flags)
3823 /* Maintain a list of namespaces visited... */
3824 tree seen = NULL_TREE;
3825 /* ... and a list of namespace yet to see. */
3826 tree todo = NULL_TREE;
3827 tree todo_maybe = NULL_TREE;
3829 timevar_push (TV_NAME_LOOKUP);
3830 /* Look through namespace aliases. */
3831 scope = ORIGINAL_NAMESPACE (scope);
3832 while (scope && result->value != error_mark_node)
3834 cxx_binding *binding =
3835 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3836 seen = tree_cons (scope, NULL_TREE, seen);
3838 ambiguous_decl (result, binding, flags);
3840 /* Consider strong using directives always, and non-strong ones
3841 if we haven't found a binding yet. ??? Shouldn't we consider
3842 non-strong ones if the initial RESULT is non-NULL, but the
3843 binding in the given namespace is? */
3844 for (usings = DECL_NAMESPACE_USING (scope); usings;
3845 usings = TREE_CHAIN (usings))
3846 /* If this was a real directive, and we have not seen it. */
3847 if (!TREE_INDIRECT_USING (usings))
3849 /* Try to avoid queuing the same namespace more than once,
3850 the exception being when a namespace was already
3851 enqueued for todo_maybe and then a strong using is
3852 found for it. We could try to remove it from
3853 todo_maybe, but it's probably not worth the effort. */
3854 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3855 && !purpose_member (TREE_PURPOSE (usings), seen)
3856 && !purpose_member (TREE_PURPOSE (usings), todo))
3857 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3858 else if ((!result->value && !result->type)
3859 && !purpose_member (TREE_PURPOSE (usings), seen)
3860 && !purpose_member (TREE_PURPOSE (usings), todo)
3861 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3862 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3867 scope = TREE_PURPOSE (todo);
3868 todo = TREE_CHAIN (todo);
3871 && (!result->value && !result->type))
3873 scope = TREE_PURPOSE (todo_maybe);
3874 todo = TREE_CHAIN (todo_maybe);
3875 todo_maybe = NULL_TREE;
3878 scope = NULL_TREE; /* If there never was a todo list. */
3880 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3883 /* Return the innermost non-namespace binding for NAME from a scope
3884 containing BINDING, or, if BINDING is NULL, the current scope. If
3885 CLASS_P is false, then class bindings are ignored. */
3888 outer_binding (tree name,
3889 cxx_binding *binding,
3894 cxx_scope *outer_scope;
3898 scope = binding->scope->level_chain;
3899 outer = binding->previous;
3903 scope = current_binding_level;
3904 outer = IDENTIFIER_BINDING (name);
3906 outer_scope = outer ? outer->scope : NULL;
3908 /* Because we create class bindings lazily, we might be missing a
3909 class binding for NAME. If there are any class binding levels
3910 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3911 declared, we must lookup NAME in those class scopes. */
3913 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3915 if (scope->kind == sk_class)
3917 cxx_binding *class_binding;
3919 class_binding = get_class_binding (name, scope);
3922 /* Thread this new class-scope binding onto the
3923 IDENTIFIER_BINDING list so that future lookups
3925 class_binding->previous = outer;
3927 binding->previous = class_binding;
3929 IDENTIFIER_BINDING (name) = class_binding;
3930 return class_binding;
3933 scope = scope->level_chain;
3939 /* Return the innermost block-scope or class-scope value binding for
3940 NAME, or NULL_TREE if there is no such binding. */
3943 innermost_non_namespace_value (tree name)
3945 cxx_binding *binding;
3946 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3947 return binding ? binding->value : NULL_TREE;
3950 /* Look up NAME in the current binding level and its superiors in the
3951 namespace of variables, functions and typedefs. Return a ..._DECL
3952 node of some kind representing its definition if there is only one
3953 such declaration, or return a TREE_LIST with all the overloaded
3954 definitions if there are many, or return 0 if it is undefined.
3955 Hidden name, either friend declaration or built-in function, are
3958 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3959 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3960 Otherwise we prefer non-TYPE_DECLs.
3962 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3963 BLOCK_P is false, bindings in block scopes are ignored. */
3966 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3967 int namespaces_only, int flags)
3970 tree val = NULL_TREE;
3972 timevar_push (TV_NAME_LOOKUP);
3973 /* Conversion operators are handled specially because ordinary
3974 unqualified name lookup will not find template conversion
3976 if (IDENTIFIER_TYPENAME_P (name))
3978 struct cp_binding_level *level;
3980 for (level = current_binding_level;
3981 level && level->kind != sk_namespace;
3982 level = level->level_chain)
3987 /* A conversion operator can only be declared in a class
3989 if (level->kind != sk_class)
3992 /* Lookup the conversion operator in the class. */
3993 class_type = level->this_entity;
3994 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3996 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3999 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4002 flags |= lookup_flags (prefer_type, namespaces_only);
4004 /* First, look in non-namespace scopes. */
4006 if (current_class_type == NULL_TREE)
4009 if (block_p || !nonclass)
4010 for (iter = outer_binding (name, NULL, !nonclass);
4012 iter = outer_binding (name, iter, !nonclass))
4016 /* Skip entities we don't want. */
4017 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4020 /* If this is the kind of thing we're looking for, we're done. */
4021 if (qualify_lookup (iter->value, flags))
4022 binding = iter->value;
4023 else if ((flags & LOOKUP_PREFER_TYPES)
4024 && qualify_lookup (iter->type, flags))
4025 binding = iter->type;
4027 binding = NULL_TREE;
4031 if (hidden_name_p (binding))
4033 /* A non namespace-scope binding can only be hidden if
4034 we are in a local class, due to friend declarations.
4035 In particular, consider:
4040 void g() { B* b; } // error: B is hidden
4045 The standard says that "B" is a local class in "f"
4046 (but not nested within "A") -- but that name lookup
4047 for "B" does not find this declaration until it is
4048 declared directly with "f".
4054 If a friend declaration appears in a local class and
4055 the name specified is an unqualified name, a prior
4056 declaration is looked up without considering scopes
4057 that are outside the innermost enclosing non-class
4058 scope. For a friend class declaration, if there is no
4059 prior declaration, the class that is specified
4060 belongs to the innermost enclosing non-class scope,
4061 but if it is subsequently referenced, its name is not
4062 found by name lookup until a matching declaration is
4063 provided in the innermost enclosing nonclass scope.
4065 gcc_assert (current_class_type &&
4066 LOCAL_CLASS_P (current_class_type));
4068 /* This binding comes from a friend declaration in the local
4069 class. The standard (11.4.8) states that the lookup can
4070 only succeed if there is a non-hidden declaration in the
4071 current scope, which is not the case here. */
4072 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4079 /* Now lookup in namespace scopes. */
4081 val = unqualified_namespace_lookup (name, flags);
4083 /* If we have a single function from a using decl, pull it out. */
4084 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4085 val = OVL_FUNCTION (val);
4087 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4091 lookup_name_nonclass (tree name)
4093 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4097 lookup_function_nonclass (tree name, tree args, bool block_p)
4100 lookup_arg_dependent (name,
4101 lookup_name_real (name, 0, 1, block_p, 0,
4107 lookup_name (tree name)
4109 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4113 lookup_name_prefer_type (tree name, int prefer_type)
4115 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4116 0, LOOKUP_COMPLAIN);
4119 /* Look up NAME for type used in elaborated name specifier in
4120 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4121 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4122 name, more scopes are checked if cleanup or template parameter
4123 scope is encountered.
4125 Unlike lookup_name_real, we make sure that NAME is actually
4126 declared in the desired scope, not from inheritance, nor using
4127 directive. For using declaration, there is DR138 still waiting
4128 to be resolved. Hidden name coming from an earlier friend
4129 declaration is also returned.
4131 A TYPE_DECL best matching the NAME is returned. Catching error
4132 and issuing diagnostics are caller's responsibility. */
4135 lookup_type_scope (tree name, tag_scope scope)
4137 cxx_binding *iter = NULL;
4138 tree val = NULL_TREE;
4140 timevar_push (TV_NAME_LOOKUP);
4142 /* Look in non-namespace scope first. */
4143 if (current_binding_level->kind != sk_namespace)
4144 iter = outer_binding (name, NULL, /*class_p=*/ true);
4145 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4147 /* Check if this is the kind of thing we're looking for.
4148 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4149 base class. For ITER->VALUE, we can simply use
4150 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4153 We check ITER->TYPE before ITER->VALUE in order to handle
4154 typedef struct C {} C;
4157 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4158 && (scope != ts_current
4159 || LOCAL_BINDING_P (iter)
4160 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4162 else if ((scope != ts_current
4163 || !INHERITED_VALUE_BINDING_P (iter))
4164 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4171 /* Look in namespace scope. */
4174 iter = cxx_scope_find_binding_for_name
4175 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4179 /* If this is the kind of thing we're looking for, we're done. */
4180 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4182 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4188 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4189 and template parameter scopes. */
4192 struct cp_binding_level *b = current_binding_level;
4195 if (iter->scope == b)
4196 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4198 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4200 else if (b->kind == sk_class
4201 && scope == ts_within_enclosing_non_class)
4208 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4211 /* Similar to `lookup_name' but look only in the innermost non-class
4215 lookup_name_innermost_nonclass_level (tree name)
4217 struct cp_binding_level *b;
4220 timevar_push (TV_NAME_LOOKUP);
4221 b = innermost_nonclass_level ();
4223 if (b->kind == sk_namespace)
4225 t = IDENTIFIER_NAMESPACE_VALUE (name);
4227 /* extern "C" function() */
4228 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4231 else if (IDENTIFIER_BINDING (name)
4232 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4234 cxx_binding *binding;
4235 binding = IDENTIFIER_BINDING (name);
4238 if (binding->scope == b
4239 && !(TREE_CODE (binding->value) == VAR_DECL
4240 && DECL_DEAD_FOR_LOCAL (binding->value)))
4241 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4243 if (b->kind == sk_cleanup)
4250 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4253 /* Like lookup_name_innermost_nonclass_level, but for types. */
4256 lookup_type_current_level (tree name)
4260 timevar_push (TV_NAME_LOOKUP);
4261 gcc_assert (current_binding_level->kind != sk_namespace);
4263 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4264 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4266 struct cp_binding_level *b = current_binding_level;
4269 if (purpose_member (name, b->type_shadowed))
4270 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4271 REAL_IDENTIFIER_TYPE_VALUE (name));
4272 if (b->kind == sk_cleanup)
4279 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4282 /* [basic.lookup.koenig] */
4283 /* A nonzero return value in the functions below indicates an error. */
4294 static bool arg_assoc (struct arg_lookup*, tree);
4295 static bool arg_assoc_args (struct arg_lookup*, tree);
4296 static bool arg_assoc_type (struct arg_lookup*, tree);
4297 static bool add_function (struct arg_lookup *, tree);
4298 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4299 static bool arg_assoc_class (struct arg_lookup *, tree);
4300 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4302 /* Add a function to the lookup structure.
4303 Returns true on error. */
4306 add_function (struct arg_lookup *k, tree fn)
4308 /* We used to check here to see if the function was already in the list,
4309 but that's O(n^2), which is just too expensive for function lookup.
4310 Now we deal with the occasional duplicate in joust. In doing this, we
4311 assume that the number of duplicates will be small compared to the
4312 total number of functions being compared, which should usually be the
4315 /* We must find only functions, or exactly one non-function. */
4318 else if (fn == k->functions)
4320 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4321 k->functions = build_overload (fn, k->functions);
4324 tree f1 = OVL_CURRENT (k->functions);
4326 if (is_overloaded_fn (f1))
4328 fn = f1; f1 = f2; f2 = fn;
4330 error ("%q+D is not a function,", f1);
4331 error (" conflict with %q+D", f2);
4332 error (" in call to %qD", k->name);
4339 /* Returns true iff CURRENT has declared itself to be an associated
4340 namespace of SCOPE via a strong using-directive (or transitive chain
4341 thereof). Both are namespaces. */
4344 is_associated_namespace (tree current, tree scope)
4346 tree seen = NULL_TREE;
4347 tree todo = NULL_TREE;
4351 if (scope == current)
4353 seen = tree_cons (scope, NULL_TREE, seen);
4354 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4355 if (!purpose_member (TREE_PURPOSE (t), seen))
4356 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4359 scope = TREE_PURPOSE (todo);
4360 todo = TREE_CHAIN (todo);
4367 /* Return whether FN is a friend of an associated class of ARG. */
4370 friend_of_associated_class_p (tree arg, tree fn)
4376 else if (type_unknown_p (arg))
4379 type = TREE_TYPE (arg);
4381 /* If TYPE is a class, the class itself and all base classes are
4382 associated classes. */
4383 if (CLASS_TYPE_P (type))
4385 if (is_friend (type, fn))
4388 if (TYPE_BINFO (type))
4390 tree binfo, base_binfo;
4393 for (binfo = TYPE_BINFO (type), i = 0;
4394 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4396 if (is_friend (BINFO_TYPE (base_binfo), fn))
4401 /* If TYPE is a class member, the class of which it is a member is
4402 an associated class. */
4403 if ((CLASS_TYPE_P (type)
4404 || TREE_CODE (type) == UNION_TYPE
4405 || TREE_CODE (type) == ENUMERAL_TYPE)
4406 && TYPE_CONTEXT (type)
4407 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4408 && is_friend (TYPE_CONTEXT (type), fn))
4414 /* Add functions of a namespace to the lookup structure.
4415 Returns true on error. */
4418 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4422 if (purpose_member (scope, k->namespaces))
4424 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4426 /* Check out our super-users. */
4427 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4428 value = TREE_CHAIN (value))
4429 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4432 /* Also look down into inline namespaces. */
4433 for (value = DECL_NAMESPACE_USING (scope); value;
4434 value = TREE_CHAIN (value))
4435 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4436 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4439 value = namespace_binding (k->name, scope);
4443 for (; value; value = OVL_NEXT (value))
4445 /* We don't want to find arbitrary hidden functions via argument
4446 dependent lookup. We only want to find friends of associated
4448 if (hidden_name_p (OVL_CURRENT (value)))
4452 for (args = k->args; args; args = TREE_CHAIN (args))
4453 if (friend_of_associated_class_p (TREE_VALUE (args),
4454 OVL_CURRENT (value)))
4460 if (add_function (k, OVL_CURRENT (value)))
4467 /* Adds everything associated with a template argument to the lookup
4468 structure. Returns true on error. */
4471 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4473 /* [basic.lookup.koenig]
4475 If T is a template-id, its associated namespaces and classes are
4476 ... the namespaces and classes associated with the types of the
4477 template arguments provided for template type parameters
4478 (excluding template template parameters); the namespaces in which
4479 any template template arguments are defined; and the classes in
4480 which any member templates used as template template arguments
4481 are defined. [Note: non-type template arguments do not
4482 contribute to the set of associated namespaces. ] */
4484 /* Consider first template template arguments. */
4485 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4486 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4488 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4490 tree ctx = CP_DECL_CONTEXT (arg);
4492 /* It's not a member template. */
4493 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4494 return arg_assoc_namespace (k, ctx);
4495 /* Otherwise, it must be member template. */
4497 return arg_assoc_class (k, ctx);
4499 /* It's an argument pack; handle it recursively. */
4500 else if (ARGUMENT_PACK_P (arg))
4502 tree args = ARGUMENT_PACK_ARGS (arg);
4503 int i, len = TREE_VEC_LENGTH (args);
4504 for (i = 0; i < len; ++i)
4505 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4510 /* It's not a template template argument, but it is a type template
4512 else if (TYPE_P (arg))
4513 return arg_assoc_type (k, arg);
4514 /* It's a non-type template argument. */
4519 /* Adds everything associated with class to the lookup structure.
4520 Returns true on error. */
4523 arg_assoc_class (struct arg_lookup *k, tree type)
4525 tree list, friends, context;
4528 /* Backend build structures, such as __builtin_va_list, aren't
4529 affected by all this. */
4530 if (!CLASS_TYPE_P (type))
4533 if (purpose_member (type, k->classes))
4535 k->classes = tree_cons (type, NULL_TREE, k->classes);
4537 context = decl_namespace_context (type);
4538 if (arg_assoc_namespace (k, context))
4541 if (TYPE_BINFO (type))
4543 /* Process baseclasses. */
4544 tree binfo, base_binfo;
4546 for (binfo = TYPE_BINFO (type), i = 0;
4547 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4548 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4552 /* Process friends. */
4553 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4554 list = TREE_CHAIN (list))
4555 if (k->name == FRIEND_NAME (list))
4556 for (friends = FRIEND_DECLS (list); friends;
4557 friends = TREE_CHAIN (friends))
4559 tree fn = TREE_VALUE (friends);
4561 /* Only interested in global functions with potentially hidden
4562 (i.e. unqualified) declarations. */
4563 if (CP_DECL_CONTEXT (fn) != context)
4565 /* Template specializations are never found by name lookup.
4566 (Templates themselves can be found, but not template
4567 specializations.) */
4568 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4570 if (add_function (k, fn))
4574 /* Process template arguments. */
4575 if (CLASSTYPE_TEMPLATE_INFO (type)
4576 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4578 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4579 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4580 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4586 /* Adds everything associated with a given type.
4587 Returns 1 on error. */
4590 arg_assoc_type (struct arg_lookup *k, tree type)
4592 /* As we do not get the type of non-type dependent expressions
4593 right, we can end up with such things without a type. */
4597 if (TYPE_PTRMEM_P (type))
4599 /* Pointer to member: associate class type and value type. */
4600 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4602 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4604 else switch (TREE_CODE (type))
4614 case FIXED_POINT_TYPE:
4617 if (TYPE_PTRMEMFUNC_P (type))
4618 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4619 return arg_assoc_class (k, type);
4621 case REFERENCE_TYPE:
4623 return arg_assoc_type (k, TREE_TYPE (type));
4626 return arg_assoc_namespace (k, decl_namespace_context (type));
4628 /* The basetype is referenced in the first arg type, so just
4631 /* Associate the parameter types. */
4632 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4634 /* Associate the return type. */
4635 return arg_assoc_type (k, TREE_TYPE (type));
4636 case TEMPLATE_TYPE_PARM:
4637 case BOUND_TEMPLATE_TEMPLATE_PARM:
4642 gcc_assert (type == unknown_type_node
4643 || type == init_list_type_node);
4645 case TYPE_PACK_EXPANSION:
4646 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4654 /* Adds everything associated with arguments. Returns true on error. */
4657 arg_assoc_args (struct arg_lookup *k, tree args)
4659 for (; args; args = TREE_CHAIN (args))
4660 if (arg_assoc (k, TREE_VALUE (args)))
4665 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4668 arg_assoc (struct arg_lookup *k, tree n)
4670 if (n == error_mark_node)
4674 return arg_assoc_type (k, n);
4676 if (! type_unknown_p (n))
4677 return arg_assoc_type (k, TREE_TYPE (n));
4679 if (TREE_CODE (n) == ADDR_EXPR)
4680 n = TREE_OPERAND (n, 0);
4681 if (TREE_CODE (n) == COMPONENT_REF)
4682 n = TREE_OPERAND (n, 1);
4683 if (TREE_CODE (n) == OFFSET_REF)
4684 n = TREE_OPERAND (n, 1);
4685 while (TREE_CODE (n) == TREE_LIST)
4687 if (TREE_CODE (n) == BASELINK)
4688 n = BASELINK_FUNCTIONS (n);
4690 if (TREE_CODE (n) == FUNCTION_DECL)
4691 return arg_assoc_type (k, TREE_TYPE (n));
4692 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4694 /* [basic.lookup.koenig]
4696 If T is a template-id, its associated namespaces and classes
4697 are the namespace in which the template is defined; for
4698 member templates, the member template's class... */
4699 tree template = TREE_OPERAND (n, 0);
4700 tree args = TREE_OPERAND (n, 1);
4704 if (TREE_CODE (template) == COMPONENT_REF)
4705 template = TREE_OPERAND (template, 1);
4707 /* First, the template. There may actually be more than one if
4708 this is an overloaded function template. But, in that case,
4709 we only need the first; all the functions will be in the same
4711 template = OVL_CURRENT (template);
4713 ctx = CP_DECL_CONTEXT (template);
4715 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4717 if (arg_assoc_namespace (k, ctx) == 1)
4720 /* It must be a member template. */
4721 else if (arg_assoc_class (k, ctx) == 1)
4724 /* Now the arguments. */
4726 for (ix = TREE_VEC_LENGTH (args); ix--;)
4727 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4730 else if (TREE_CODE (n) == OVERLOAD)
4732 for (; n; n = OVL_CHAIN (n))
4733 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4740 /* Performs Koenig lookup depending on arguments, where fns
4741 are the functions found in normal lookup. */
4744 lookup_arg_dependent (tree name, tree fns, tree args)
4746 struct arg_lookup k;
4748 timevar_push (TV_NAME_LOOKUP);
4750 /* Remove any hidden friend functions from the list of functions
4751 found so far. They will be added back by arg_assoc_class as
4753 fns = remove_hidden_names (fns);
4758 k.classes = NULL_TREE;
4760 /* We previously performed an optimization here by setting
4761 NAMESPACES to the current namespace when it was safe. However, DR
4762 164 says that namespaces that were already searched in the first
4763 stage of template processing are searched again (potentially
4764 picking up later definitions) in the second stage. */
4765 k.namespaces = NULL_TREE;
4767 arg_assoc_args (&k, args);
4772 && TREE_CODE (fns) != VAR_DECL
4773 && !is_overloaded_fn (fns))
4775 error ("argument dependent lookup finds %q+D", fns);
4776 error (" in call to %qD", name);
4777 fns = error_mark_node;
4780 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4783 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4784 changed (i.e. there was already a directive), or the fresh
4785 TREE_LIST otherwise. */
4788 push_using_directive (tree used)
4790 tree ud = current_binding_level->using_directives;
4791 tree iter, ancestor;
4793 timevar_push (TV_NAME_LOOKUP);
4794 /* Check if we already have this. */
4795 if (purpose_member (used, ud) != NULL_TREE)
4796 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4798 ancestor = namespace_ancestor (current_decl_namespace (), used);
4799 ud = current_binding_level->using_directives;
4800 ud = tree_cons (used, ancestor, ud);
4801 current_binding_level->using_directives = ud;
4803 /* Recursively add all namespaces used. */
4804 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4805 push_using_directive (TREE_PURPOSE (iter));
4807 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4810 /* The type TYPE is being declared. If it is a class template, or a
4811 specialization of a class template, do any processing required and
4812 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4813 being declared a friend. B is the binding level at which this TYPE
4816 Returns the TYPE_DECL for TYPE, which may have been altered by this
4820 maybe_process_template_type_declaration (tree type, int is_friend,
4823 tree decl = TYPE_NAME (type);
4825 if (processing_template_parmlist)
4826 /* You can't declare a new template type in a template parameter
4827 list. But, you can declare a non-template type:
4829 template <class A*> struct S;
4831 is a forward-declaration of `A'. */
4833 else if (b->kind == sk_namespace
4834 && current_binding_level->kind != sk_namespace)
4835 /* If this new type is being injected into a containing scope,
4836 then it's not a template type. */
4840 gcc_assert (MAYBE_CLASS_TYPE_P (type)
4841 || TREE_CODE (type) == ENUMERAL_TYPE);
4843 if (processing_template_decl)
4845 /* This may change after the call to
4846 push_template_decl_real, but we want the original value. */
4847 tree name = DECL_NAME (decl);
4849 decl = push_template_decl_real (decl, is_friend);
4850 /* If the current binding level is the binding level for the
4851 template parameters (see the comment in
4852 begin_template_parm_list) and the enclosing level is a class
4853 scope, and we're not looking at a friend, push the
4854 declaration of the member class into the class scope. In the
4855 friend case, push_template_decl will already have put the
4856 friend into global scope, if appropriate. */
4857 if (TREE_CODE (type) != ENUMERAL_TYPE
4858 && !is_friend && b->kind == sk_template_parms
4859 && b->level_chain->kind == sk_class)
4861 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4863 if (!COMPLETE_TYPE_P (current_class_type))
4865 maybe_add_class_template_decl_list (current_class_type,
4866 type, /*friend_p=*/0);
4867 /* Put this UTD in the table of UTDs for the class. */
4868 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4869 CLASSTYPE_NESTED_UTDS (current_class_type) =
4870 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4872 binding_table_insert
4873 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4882 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4883 that the NAME is a class template, the tag is processed but not pushed.
4885 The pushed scope depend on the SCOPE parameter:
4886 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4888 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4889 non-template-parameter scope. This case is needed for forward
4891 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4892 TS_GLOBAL case except that names within template-parameter scopes
4893 are not pushed at all.
4895 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4898 pushtag (tree name, tree type, tag_scope scope)
4900 struct cp_binding_level *b;
4903 timevar_push (TV_NAME_LOOKUP);
4904 b = current_binding_level;
4905 while (/* Cleanup scopes are not scopes from the point of view of
4907 b->kind == sk_cleanup
4908 /* Neither are the scopes used to hold template parameters
4909 for an explicit specialization. For an ordinary template
4910 declaration, these scopes are not scopes from the point of
4911 view of the language. */
4912 || (b->kind == sk_template_parms
4913 && (b->explicit_spec_p || scope == ts_global))
4914 || (b->kind == sk_class
4915 && (scope != ts_current
4916 /* We may be defining a new type in the initializer
4917 of a static member variable. We allow this when
4918 not pedantic, and it is particularly useful for
4919 type punning via an anonymous union. */
4920 || COMPLETE_TYPE_P (b->this_entity))))
4923 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4925 /* Do C++ gratuitous typedefing. */
4926 if (IDENTIFIER_TYPE_VALUE (name) != type)
4930 tree context = TYPE_CONTEXT (type);
4934 tree cs = current_scope ();
4936 if (scope == ts_current)
4938 else if (cs != NULL_TREE && TYPE_P (cs))
4939 /* When declaring a friend class of a local class, we want
4940 to inject the newly named class into the scope
4941 containing the local class, not the namespace
4943 context = decl_function_context (get_type_decl (cs));
4946 context = current_namespace;
4948 if (b->kind == sk_class
4949 || (b->kind == sk_template_parms
4950 && b->level_chain->kind == sk_class))
4953 if (current_lang_name == lang_name_java)
4954 TYPE_FOR_JAVA (type) = 1;
4956 tdef = create_implicit_typedef (name, type);
4957 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4958 if (scope == ts_within_enclosing_non_class)
4960 /* This is a friend. Make this TYPE_DECL node hidden from
4961 ordinary name lookup. Its corresponding TEMPLATE_DECL
4962 will be marked in push_template_decl_real. */
4963 retrofit_lang_decl (tdef);
4964 DECL_ANTICIPATED (tdef) = 1;
4965 DECL_FRIEND_P (tdef) = 1;
4968 decl = maybe_process_template_type_declaration
4969 (type, scope == ts_within_enclosing_non_class, b);
4970 if (decl == error_mark_node)
4971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4973 if (b->kind == sk_class)
4975 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4976 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4977 class. But if it's a member template class, we want
4978 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4980 finish_member_declaration (decl);
4982 pushdecl_class_level (decl);
4984 else if (b->kind != sk_template_parms)
4986 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4987 if (decl == error_mark_node)
4988 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4992 set_identifier_type_value_with_scope (name, tdef, b);
4994 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4996 /* If this is a local class, keep track of it. We need this
4997 information for name-mangling, and so that it is possible to
4998 find all function definitions in a translation unit in a
4999 convenient way. (It's otherwise tricky to find a member
5000 function definition it's only pointed to from within a local
5002 if (TYPE_CONTEXT (type)
5003 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5004 VEC_safe_push (tree, gc, local_classes, type);
5006 if (b->kind == sk_class
5007 && !COMPLETE_TYPE_P (current_class_type))
5009 maybe_add_class_template_decl_list (current_class_type,
5010 type, /*friend_p=*/0);
5012 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5013 CLASSTYPE_NESTED_UTDS (current_class_type)
5014 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5016 binding_table_insert
5017 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5020 decl = TYPE_NAME (type);
5021 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5022 TYPE_STUB_DECL (type) = decl;
5024 /* Set type visibility now if this is a forward declaration. */
5025 TREE_PUBLIC (decl) = 1;
5026 determine_visibility (decl);
5028 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5031 /* Subroutines for reverting temporarily to top-level for instantiation
5032 of templates and such. We actually need to clear out the class- and
5033 local-value slots of all identifiers, so that only the global values
5034 are at all visible. Simply setting current_binding_level to the global
5035 scope isn't enough, because more binding levels may be pushed. */
5036 struct saved_scope *scope_chain;
5038 /* If ID has not already been marked, add an appropriate binding to
5042 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5044 cxx_saved_binding *saved;
5046 if (!id || !IDENTIFIER_BINDING (id))
5049 if (IDENTIFIER_MARKED (id))
5052 IDENTIFIER_MARKED (id) = 1;
5054 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5055 saved->identifier = id;
5056 saved->binding = IDENTIFIER_BINDING (id);
5057 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5058 IDENTIFIER_BINDING (id) = NULL;
5062 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5066 timevar_push (TV_NAME_LOOKUP);
5067 for (t = names; t; t = TREE_CHAIN (t))
5071 if (TREE_CODE (t) == TREE_LIST)
5072 id = TREE_PURPOSE (t);
5076 store_binding (id, old_bindings);
5078 timevar_pop (TV_NAME_LOOKUP);
5081 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5082 objects, rather than a TREE_LIST. */
5085 store_class_bindings (VEC(cp_class_binding,gc) *names,
5086 VEC(cxx_saved_binding,gc) **old_bindings)
5089 cp_class_binding *cb;
5091 timevar_push (TV_NAME_LOOKUP);
5092 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5093 store_binding (cb->identifier, old_bindings);
5094 timevar_pop (TV_NAME_LOOKUP);
5098 push_to_top_level (void)
5100 struct saved_scope *s;
5101 struct cp_binding_level *b;
5102 cxx_saved_binding *sb;
5106 timevar_push (TV_NAME_LOOKUP);
5107 s = GGC_CNEW (struct saved_scope);
5109 b = scope_chain ? current_binding_level : 0;
5111 /* If we're in the middle of some function, save our state. */
5115 push_function_context ();
5120 if (scope_chain && previous_class_level)
5121 store_class_bindings (previous_class_level->class_shadowed,
5124 /* Have to include the global scope, because class-scope decls
5125 aren't listed anywhere useful. */
5126 for (; b; b = b->level_chain)
5130 /* Template IDs are inserted into the global level. If they were
5131 inserted into namespace level, finish_file wouldn't find them
5132 when doing pending instantiations. Therefore, don't stop at
5133 namespace level, but continue until :: . */
5134 if (global_scope_p (b))
5137 store_bindings (b->names, &s->old_bindings);
5138 /* We also need to check class_shadowed to save class-level type
5139 bindings, since pushclass doesn't fill in b->names. */
5140 if (b->kind == sk_class)
5141 store_class_bindings (b->class_shadowed, &s->old_bindings);
5143 /* Unwind type-value slots back to top level. */
5144 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5145 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5148 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5149 IDENTIFIER_MARKED (sb->identifier) = 0;
5151 s->prev = scope_chain;
5153 s->need_pop_function_context = need_pop;
5154 s->function_decl = current_function_decl;
5155 s->skip_evaluation = skip_evaluation;
5158 current_function_decl = NULL_TREE;
5159 current_lang_base = VEC_alloc (tree, gc, 10);
5160 current_lang_name = lang_name_cplusplus;
5161 current_namespace = global_namespace;
5162 push_class_stack ();
5163 skip_evaluation = 0;
5164 timevar_pop (TV_NAME_LOOKUP);
5168 pop_from_top_level (void)
5170 struct saved_scope *s = scope_chain;
5171 cxx_saved_binding *saved;
5174 timevar_push (TV_NAME_LOOKUP);
5175 /* Clear out class-level bindings cache. */
5176 if (previous_class_level)
5177 invalidate_class_lookup_cache ();
5180 current_lang_base = 0;
5182 scope_chain = s->prev;
5183 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5185 tree id = saved->identifier;
5187 IDENTIFIER_BINDING (id) = saved->binding;
5188 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5191 /* If we were in the middle of compiling a function, restore our
5193 if (s->need_pop_function_context)
5194 pop_function_context ();
5195 current_function_decl = s->function_decl;
5196 skip_evaluation = s->skip_evaluation;
5197 timevar_pop (TV_NAME_LOOKUP);
5200 /* Pop off extraneous binding levels left over due to syntax errors.
5202 We don't pop past namespaces, as they might be valid. */
5205 pop_everything (void)
5207 if (ENABLE_SCOPE_CHECKING)
5208 verbatim ("XXX entering pop_everything ()\n");
5209 while (!toplevel_bindings_p ())
5211 if (current_binding_level->kind == sk_class)
5212 pop_nested_class ();
5216 if (ENABLE_SCOPE_CHECKING)
5217 verbatim ("XXX leaving pop_everything ()\n");
5220 /* Emit debugging information for using declarations and directives.
5221 If input tree is overloaded fn then emit debug info for all
5225 cp_emit_debug_info_for_using (tree t, tree context)
5227 /* Don't try to emit any debug information if we have errors. */
5228 if (sorrycount || errorcount)
5231 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5232 of a builtin function. */
5233 if (TREE_CODE (t) == FUNCTION_DECL
5234 && DECL_EXTERNAL (t)
5235 && DECL_BUILT_IN (t))
5238 /* Do not supply context to imported_module_or_decl, if
5239 it is a global namespace. */
5240 if (context == global_namespace)
5241 context = NULL_TREE;
5244 t = BASELINK_FUNCTIONS (t);
5246 /* FIXME: Handle TEMPLATE_DECLs. */
5247 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5248 if (TREE_CODE (t) != TEMPLATE_DECL)
5249 (*debug_hooks->imported_module_or_decl) (t, context);
5252 #include "gt-cp-name-lookup.h"