1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
34 static cxx_scope *innermost_nonclass_level (void);
35 static tree select_decl (cxx_binding *, int);
36 static cxx_binding *binding_for_name (cxx_scope *, tree);
37 static tree lookup_name_current_level (tree);
38 static void push_local_binding (tree, tree, int);
39 static tree push_overloaded_decl (tree, int);
40 static bool lookup_using_namespace (tree, cxx_binding *, tree,
42 static bool qualified_lookup_using_namespace (tree, tree, cxx_binding *, int);
43 static tree lookup_type_current_level (tree);
44 static tree push_using_directive (tree);
47 /* The :: namespace. */
49 tree global_namespace;
51 /* The name of the anonymous namespace, throughout this translation
53 GTY(()) tree anonymous_namespace_name;
56 /* Compute the chain index of a binding_entry given the HASH value of its
57 name and the total COUNT of chains. COUNT is assumed to be a power
60 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
62 /* A free list of "binding_entry"s awaiting for re-use. */
64 static GTY((deletable(""))) binding_entry free_binding_entry = NULL;
66 /* Create a binding_entry object for (NAME, TYPE). */
68 static inline binding_entry
69 binding_entry_make (tree name, tree type)
73 if (free_binding_entry)
75 entry = free_binding_entry;
76 free_binding_entry = entry->chain;
79 entry = ggc_alloc (sizeof (struct binding_entry_s));
88 /* Put ENTRY back on the free list. */
91 binding_entry_free (binding_entry entry)
95 entry->chain = free_binding_entry;
96 free_binding_entry = entry;
99 /* The datatype used to implement the mapping from names to types at
101 struct binding_table_s GTY(())
103 /* Array of chains of "binding_entry"s */
104 binding_entry * GTY((length ("%h.chain_count"))) chain;
106 /* The number of chains in this table. This is the length of the
107 the member "chain" considered as an array. */
110 /* Number of "binding_entry"s in this table. */
114 /* Construct TABLE with an initial CHAIN_COUNT. */
117 binding_table_construct (binding_table table, size_t chain_count)
119 table->chain_count = chain_count;
120 table->entry_count = 0;
121 table->chain = ggc_alloc_cleared
122 (table->chain_count * sizeof (binding_entry));
125 /* Make TABLE's entries ready for reuse. */
128 binding_table_free (binding_table table)
136 for (i = 0, count = table->chain_count; i < count; ++i)
138 binding_entry temp = table->chain[i];
141 binding_entry entry = temp;
143 binding_entry_free (entry);
145 table->chain[i] = NULL;
147 table->entry_count = 0;
150 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
152 static inline binding_table
153 binding_table_new (size_t chain_count)
155 binding_table table = ggc_alloc (sizeof (struct binding_table_s));
157 binding_table_construct (table, chain_count);
161 /* Expand TABLE to twice its current chain_count. */
164 binding_table_expand (binding_table table)
166 const size_t old_chain_count = table->chain_count;
167 const size_t old_entry_count = table->entry_count;
168 const size_t new_chain_count = 2 * old_chain_count;
169 binding_entry *old_chains = table->chain;
172 binding_table_construct (table, new_chain_count);
173 for (i = 0; i < old_chain_count; ++i)
175 binding_entry entry = old_chains[i];
176 for (; entry != NULL; entry = old_chains[i])
178 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
179 const size_t j = ENTRY_INDEX (hash, new_chain_count);
181 old_chains[i] = entry->chain;
182 entry->chain = table->chain[j];
183 table->chain[j] = entry;
186 table->entry_count = old_entry_count;
189 /* Insert a binding for NAME to TYPE into TABLE. */
192 binding_table_insert (binding_table table, tree name, tree type)
194 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
195 const size_t i = ENTRY_INDEX (hash, table->chain_count);
196 binding_entry entry = binding_entry_make (name, type);
198 entry->chain = table->chain[i];
199 table->chain[i] = entry;
200 ++table->entry_count;
202 if (3 * table->chain_count < 5 * table->entry_count)
203 binding_table_expand (table);
206 /* Return the binding_entry, if any, that maps NAME. */
209 binding_table_find (binding_table table, tree name)
211 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
212 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
214 while (entry != NULL && entry->name != name)
215 entry = entry->chain;
220 /* Return the binding_entry, if any, that maps NAME to an anonymous type. */
223 binding_table_find_anon_type (binding_table table, tree name)
225 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
226 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
228 while (entry != NULL && TYPE_IDENTIFIER (entry->type) != name)
229 entry = entry->chain;
231 return entry ? entry->type : NULL;
234 /* Return the binding_entry, if any, that has TYPE as target. If NAME
235 is non-null, then set the domain and rehash that entry. */
238 binding_table_reverse_maybe_remap (binding_table table, tree type, tree name)
240 const size_t chain_count = table->chain_count;
241 binding_entry entry = NULL;
242 binding_entry *p = NULL;
245 for (i = 0; i < chain_count && entry == NULL; ++i)
247 p = &table->chain[i];
248 while (*p != NULL && entry == NULL)
249 if ((*p)->type == type)
255 if (entry != NULL && name != NULL && entry->name != name)
257 /* Remove the bucket from the previous chain. */
260 /* Remap the name type to type. */
261 i = ENTRY_INDEX (IDENTIFIER_HASH_VALUE (name), chain_count);
262 entry->chain = table->chain[i];
264 table->chain[i] = entry;
270 /* Remove from TABLE all entries that map to anonymous enums or
274 binding_table_remove_anonymous_types (binding_table table)
276 const size_t chain_count = table->chain_count;
279 for (i = 0; i < chain_count; ++i)
281 binding_entry *p = &table->chain[i];
284 if (ANON_AGGRNAME_P ((*p)->name))
286 binding_entry e = *p;
288 --table->entry_count;
289 binding_entry_free (e);
296 /* Apply PROC -- with DATA -- to all entries in TABLE. */
299 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
301 const size_t chain_count = table->chain_count;
304 for (i = 0; i < chain_count; ++i)
306 binding_entry entry = table->chain[i];
307 for (; entry != NULL; entry = entry->chain)
312 #ifndef ENABLE_SCOPE_CHECKING
313 # define ENABLE_SCOPE_CHECKING 0
315 # define ENABLE_SCOPE_CHECKING 1
318 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
320 static GTY((deletable (""))) cxx_binding *free_bindings;
322 /* Zero out a cxx_binding pointed to by B. */
323 #define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))
325 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
328 cxx_binding_make (tree value, tree type)
330 cxx_binding *binding;
333 binding = free_bindings;
334 free_bindings = binding->previous;
337 binding = ggc_alloc (sizeof (cxx_binding));
339 binding->value = value;
340 binding->type = type;
341 binding->previous = NULL;
346 /* Put BINDING back on the free list. */
349 cxx_binding_free (cxx_binding *binding)
351 binding->scope = NULL;
352 binding->previous = free_bindings;
353 free_bindings = binding;
356 /* Make DECL the innermost binding for ID. The LEVEL is the binding
357 level at which this declaration is being bound. */
360 push_binding (tree id, tree decl, cxx_scope* level)
362 cxx_binding *binding = cxx_binding_make (decl, NULL);
364 /* Now, fill in the binding information. */
365 binding->previous = IDENTIFIER_BINDING (id);
366 binding->scope = level;
367 INHERITED_VALUE_BINDING_P (binding) = 0;
368 LOCAL_BINDING_P (binding) = (level != class_binding_level);
370 /* And put it on the front of the list of bindings for ID. */
371 IDENTIFIER_BINDING (id) = binding;
374 /* Remove the binding for DECL which should be the innermost binding
378 pop_binding (tree id, tree decl)
380 cxx_binding *binding;
383 /* It's easiest to write the loops that call this function without
384 checking whether or not the entities involved have names. We
385 get here for such an entity. */
388 /* Get the innermost binding for ID. */
389 binding = IDENTIFIER_BINDING (id);
391 /* The name should be bound. */
392 my_friendly_assert (binding != NULL, 0);
394 /* The DECL will be either the ordinary binding or the type
395 binding for this identifier. Remove that binding. */
396 if (binding->value == decl)
397 binding->value = NULL_TREE;
398 else if (binding->type == decl)
399 binding->type = NULL_TREE;
403 if (!binding->value && !binding->type)
405 /* We're completely done with the innermost binding for this
406 identifier. Unhook it from the list of bindings. */
407 IDENTIFIER_BINDING (id) = binding->previous;
409 /* Add it to the free list. */
410 cxx_binding_free (binding);
414 /* BINDING records an existing declaration for a namein the current scope.
415 But, DECL is another declaration for that same identifier in the
416 same scope. This is the `struct stat' hack whereby a non-typedef
417 class name or enum-name can be bound at the same level as some other
421 A class name (9.1) or enumeration name (7.2) can be hidden by the
422 name of an object, function, or enumerator declared in the same scope.
423 If a class or enumeration name and an object, function, or enumerator
424 are declared in the same scope (in any order) with the same name, the
425 class or enumeration name is hidden wherever the object, function, or
426 enumerator name is visible.
428 It's the responsibility of the caller to check that
429 inserting this name is valid here. Returns nonzero if the new binding
433 supplement_binding (cxx_binding *binding, tree decl)
435 tree bval = binding->value;
438 timevar_push (TV_NAME_LOOKUP);
439 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
440 /* The new name is the type name. */
441 binding->type = decl;
442 else if (/* BVAL is null when push_class_level_binding moves an
443 inherited type-binding out of the way to make room for a
444 new value binding. */
446 /* BVAL is error_mark_node when DECL's name has been used
447 in a non-class scope prior declaration. In that case,
448 we should have already issued a diagnostic; for graceful
449 error recovery purpose, pretend this was the intended
450 declaration for that name. */
451 || bval == error_mark_node
452 /* If BVAL is a built-in that has not yet been declared,
453 pretend it is not there at all. */
454 || (TREE_CODE (bval) == FUNCTION_DECL
455 && DECL_ANTICIPATED (bval)))
456 binding->value = decl;
457 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
459 /* The old binding was a type name. It was placed in
460 VALUE field because it was thought, at the point it was
461 declared, to be the only entity with such a name. Move the
462 type name into the type slot; it is now hidden by the new
464 binding->type = bval;
465 binding->value = decl;
466 binding->value_is_inherited = false;
468 else if (TREE_CODE (bval) == TYPE_DECL
469 && TREE_CODE (decl) == TYPE_DECL
470 && DECL_NAME (decl) == DECL_NAME (bval)
471 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
472 /* If either type involves template parameters, we must
473 wait until instantiation. */
474 || uses_template_parms (TREE_TYPE (decl))
475 || uses_template_parms (TREE_TYPE (bval))))
476 /* We have two typedef-names, both naming the same type to have
477 the same name. This is OK because of:
481 In a given scope, a typedef specifier can be used to redefine
482 the name of any type declared in that scope to refer to the
483 type to which it already refers. */
485 /* There can be two block-scope declarations of the same variable,
486 so long as they are `extern' declarations. However, there cannot
487 be two declarations of the same static data member:
491 A member shall not be declared twice in the
492 member-specification. */
493 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
494 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
495 && !DECL_CLASS_SCOPE_P (decl))
497 duplicate_decls (decl, binding->value);
500 else if (TREE_CODE (decl) == NAMESPACE_DECL
501 && TREE_CODE (bval) == NAMESPACE_DECL
502 && DECL_NAMESPACE_ALIAS (decl)
503 && DECL_NAMESPACE_ALIAS (bval)
504 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
507 In a declarative region, a namespace-alias-definition can be
508 used to redefine a namespace-alias declared in that declarative
509 region to refer only to the namespace to which it already
514 error ("declaration of `%#D'", decl);
515 cp_error_at ("conflicts with previous declaration `%#D'", bval);
519 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
522 /* Add DECL to the list of things declared in B. */
525 add_decl_to_level (tree decl, cxx_scope *b)
527 if (TREE_CODE (decl) == NAMESPACE_DECL
528 && !DECL_NAMESPACE_ALIAS (decl))
530 TREE_CHAIN (decl) = b->namespaces;
531 b->namespaces = decl;
533 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
535 TREE_CHAIN (decl) = b->vtables;
540 /* We build up the list in reverse order, and reverse it later if
542 TREE_CHAIN (decl) = b->names;
546 /* If appropriate, add decl to separate list of statics. We
547 include extern variables because they might turn out to be
548 static later. It's OK for this list to contain a few false
550 if (b->kind == sk_namespace)
551 if ((TREE_CODE (decl) == VAR_DECL
552 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
553 || (TREE_CODE (decl) == FUNCTION_DECL
554 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
555 VARRAY_PUSH_TREE (b->static_decls, decl);
559 /* Record a decl-node X as belonging to the current lexical scope.
560 Check for errors (such as an incompatible declaration for the same
561 name already seen in the same scope).
563 Returns either X or an old decl for the same name.
564 If an old decl is returned, it may have been smashed
565 to agree with what X says. */
572 int need_new_binding;
574 timevar_push (TV_NAME_LOOKUP);
576 need_new_binding = 1;
578 if (DECL_TEMPLATE_PARM_P (x))
579 /* Template parameters have no context; they are not X::T even
580 when declared within a class or namespace. */
584 if (current_function_decl && x != current_function_decl
585 /* A local declaration for a function doesn't constitute
587 && TREE_CODE (x) != FUNCTION_DECL
588 /* A local declaration for an `extern' variable is in the
589 scope of the current namespace, not the current
591 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
592 && !DECL_CONTEXT (x))
593 DECL_CONTEXT (x) = current_function_decl;
595 /* If this is the declaration for a namespace-scope function,
596 but the declaration itself is in a local scope, mark the
598 if (TREE_CODE (x) == FUNCTION_DECL
599 && DECL_NAMESPACE_SCOPE_P (x)
600 && current_function_decl
601 && x != current_function_decl)
602 DECL_LOCAL_FUNCTION_P (x) = 1;
605 name = DECL_NAME (x);
608 int different_binding_level = 0;
610 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
611 name = TREE_OPERAND (name, 0);
613 /* In case this decl was explicitly namespace-qualified, look it
614 up in its namespace context. */
615 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
616 t = namespace_binding (name, DECL_CONTEXT (x));
618 t = lookup_name_current_level (name);
620 /* [basic.link] If there is a visible declaration of an entity
621 with linkage having the same name and type, ignoring entities
622 declared outside the innermost enclosing namespace scope, the
623 block scope declaration declares that same entity and
624 receives the linkage of the previous declaration. */
625 if (! t && current_function_decl && x != current_function_decl
626 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
627 && DECL_EXTERNAL (x))
629 /* Look in block scope. */
630 t = IDENTIFIER_VALUE (name);
631 /* Or in the innermost namespace. */
633 t = namespace_binding (name, DECL_CONTEXT (x));
634 /* Does it have linkage? Note that if this isn't a DECL, it's an
635 OVERLOAD, which is OK. */
636 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
639 different_binding_level = 1;
642 /* If we are declaring a function, and the result of name-lookup
643 was an OVERLOAD, look for an overloaded instance that is
644 actually the same as the function we are declaring. (If
645 there is one, we have to merge our declaration with the
646 previous declaration.) */
647 if (t && TREE_CODE (t) == OVERLOAD)
651 if (TREE_CODE (x) == FUNCTION_DECL)
652 for (match = t; match; match = OVL_NEXT (match))
654 if (decls_match (OVL_CURRENT (match), x))
658 /* Just choose one. */
662 t = OVL_CURRENT (match);
667 if (t == error_mark_node)
669 /* error_mark_node is 0 for a while during initialization! */
671 cp_error_at ("`%#D' used prior to declaration", x);
673 else if (t != NULL_TREE)
675 if (different_binding_level)
677 if (decls_match (x, t))
678 /* The standard only says that the local extern
679 inherits linkage from the previous decl; in
680 particular, default args are not shared. It would
681 be nice to propagate inlining info, though. FIXME. */
682 TREE_PUBLIC (x) = TREE_PUBLIC (t);
684 else if (TREE_CODE (t) == PARM_DECL)
686 if (DECL_CONTEXT (t) == NULL_TREE)
687 /* This is probably caused by too many errors, but calling
688 abort will say that if errors have occurred. */
691 /* Check for duplicate params. */
692 if (duplicate_decls (x, t))
693 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
695 else if ((DECL_EXTERN_C_FUNCTION_P (x)
696 || DECL_FUNCTION_TEMPLATE_P (x))
697 && is_overloaded_fn (t))
698 /* Don't do anything just yet. */;
699 else if (t == wchar_decl_node)
701 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
702 pedwarn ("redeclaration of `wchar_t' as `%T'",
705 /* Throw away the redeclaration. */
706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
710 tree olddecl = duplicate_decls (x, t);
712 /* If the redeclaration failed, we can stop at this
714 if (olddecl == error_mark_node)
715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
719 if (TREE_CODE (t) == TYPE_DECL)
720 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
721 else if (TREE_CODE (t) == FUNCTION_DECL)
722 check_default_args (t);
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
726 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
728 /* A redeclaration of main, but not a duplicate of the
733 This function shall not be overloaded. */
734 cp_error_at ("invalid redeclaration of `%D'", t);
735 error ("as `%D'", x);
736 /* We don't try to push this declaration since that
738 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
743 check_template_shadow (x);
745 /* If this is a function conjured up by the backend, massage it
746 so it looks friendly. */
747 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
749 retrofit_lang_decl (x);
750 SET_DECL_LANGUAGE (x, lang_c);
753 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
755 t = push_overloaded_decl (x, PUSH_LOCAL);
757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
758 if (!namespace_bindings_p ())
759 /* We do not need to create a binding for this name;
760 push_overloaded_decl will have already done so if
762 need_new_binding = 0;
764 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
766 t = push_overloaded_decl (x, PUSH_GLOBAL);
768 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
769 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
772 /* If declaring a type as a typedef, copy the type (unless we're
773 at line 0), and install this TYPE_DECL as the new type's typedef
774 name. See the extensive comment in ../c-decl.c (pushdecl). */
775 if (TREE_CODE (x) == TYPE_DECL)
777 tree type = TREE_TYPE (x);
778 if (DECL_SOURCE_LINE (x) == 0)
780 if (TYPE_NAME (type) == 0)
781 TYPE_NAME (type) = x;
783 else if (type != error_mark_node && TYPE_NAME (type) != x
784 /* We don't want to copy the type when all we're
785 doing is making a TYPE_DECL for the purposes of
787 && (!TYPE_NAME (type)
788 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
790 DECL_ORIGINAL_TYPE (x) = type;
791 type = build_type_copy (type);
792 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
793 TYPE_NAME (type) = x;
794 TREE_TYPE (x) = type;
797 if (type != error_mark_node
799 && TYPE_IDENTIFIER (type))
800 set_identifier_type_value (DECL_NAME (x), x);
803 /* Multiple external decls of the same identifier ought to match.
805 We get warnings about inline functions where they are defined.
806 We get warnings about other functions from push_overloaded_decl.
808 Avoid duplicate warnings where they are used. */
809 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
813 decl = IDENTIFIER_NAMESPACE_VALUE (name);
814 if (decl && TREE_CODE (decl) == OVERLOAD)
815 decl = OVL_FUNCTION (decl);
817 if (decl && decl != error_mark_node
818 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
819 /* If different sort of thing, we already gave an error. */
820 && TREE_CODE (decl) == TREE_CODE (x)
821 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
823 pedwarn ("type mismatch with previous external decl of `%#D'", x);
824 cp_pedwarn_at ("previous external decl of `%#D'", decl);
828 /* This name is new in its binding level.
829 Install the new declaration and return it. */
830 if (namespace_bindings_p ())
832 /* Install a global value. */
834 /* If the first global decl has external linkage,
835 warn if we later see static one. */
836 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
837 TREE_PUBLIC (name) = 1;
839 /* Bind the name for the entity. */
840 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
842 && (TREE_CODE (x) == TYPE_DECL
843 || TREE_CODE (x) == VAR_DECL
844 || TREE_CODE (x) == ALIAS_DECL
845 || TREE_CODE (x) == NAMESPACE_DECL
846 || TREE_CODE (x) == CONST_DECL
847 || TREE_CODE (x) == TEMPLATE_DECL))
848 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
850 /* Don't forget if the function was used via an implicit decl. */
851 if (IDENTIFIER_IMPLICIT_DECL (name)
852 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
855 /* Don't forget if its address was taken in that way. */
856 if (IDENTIFIER_IMPLICIT_DECL (name)
857 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
858 TREE_ADDRESSABLE (x) = 1;
860 /* Warn about mismatches against previous implicit decl. */
861 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
862 /* If this real decl matches the implicit, don't complain. */
863 && ! (TREE_CODE (x) == FUNCTION_DECL
864 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
866 ("`%D' was previously implicitly declared to return `int'", x);
868 /* If new decl is `static' and an `extern' was seen previously,
870 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
871 warn_extern_redeclared_static (x, t);
875 /* Here to install a non-global value. */
876 tree oldlocal = IDENTIFIER_VALUE (name);
877 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
879 if (need_new_binding)
881 push_local_binding (name, x, 0);
882 /* Because push_local_binding will hook X on to the
883 current_binding_level's name list, we don't want to
884 do that again below. */
885 need_new_binding = 0;
888 /* If this is a TYPE_DECL, push it into the type value slot. */
889 if (TREE_CODE (x) == TYPE_DECL)
890 set_identifier_type_value (name, x);
892 /* Clear out any TYPE_DECL shadowed by a namespace so that
893 we won't think this is a type. The C struct hack doesn't
894 go through namespaces. */
895 if (TREE_CODE (x) == NAMESPACE_DECL)
896 set_identifier_type_value (name, NULL_TREE);
903 && TREE_CODE (oldlocal) == VAR_DECL
904 && DECL_DEAD_FOR_LOCAL (oldlocal))
905 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
907 if (oldlocal == NULL_TREE)
908 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
911 /* If this is an extern function declaration, see if we
912 have a global definition or declaration for the function. */
913 if (oldlocal == NULL_TREE
915 && oldglobal != NULL_TREE
916 && TREE_CODE (x) == FUNCTION_DECL
917 && TREE_CODE (oldglobal) == FUNCTION_DECL)
919 /* We have one. Their types must agree. */
920 if (decls_match (x, oldglobal))
924 warning ("extern declaration of `%#D' doesn't match", x);
925 cp_warning_at ("global declaration `%#D'", oldglobal);
928 /* If we have a local external declaration,
929 and no file-scope declaration has yet been seen,
930 then if we later have a file-scope decl it must not be static. */
931 if (oldlocal == NULL_TREE
932 && oldglobal == NULL_TREE
935 TREE_PUBLIC (name) = 1;
937 /* Warn if shadowing an argument at the top level of the body. */
938 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
939 /* Inline decls shadow nothing. */
940 && !DECL_FROM_INLINE (x)
941 && TREE_CODE (oldlocal) == PARM_DECL
942 /* Don't check the `this' parameter. */
943 && !DECL_ARTIFICIAL (oldlocal))
947 /* Don't complain if it's from an enclosing function. */
948 if (DECL_CONTEXT (oldlocal) == current_function_decl
949 && TREE_CODE (x) != PARM_DECL)
951 /* Go to where the parms should be and see if we find
953 struct cp_binding_level *b = current_binding_level->level_chain;
955 /* Skip the ctor/dtor cleanup level. */
959 if (b->kind == sk_function_parms)
961 error ("declaration of '%#D' shadows a parameter", x);
966 if (warn_shadow && !err)
968 warning ("declaration of '%#D' shadows a parameter", x);
969 warning ("%Jshadowed declaration is here", oldlocal);
973 /* Maybe warn if shadowing something else. */
974 else if (warn_shadow && !DECL_EXTERNAL (x)
975 /* No shadow warnings for internally generated vars. */
976 && ! DECL_ARTIFICIAL (x)
977 /* No shadow warnings for vars made for inlining. */
978 && ! DECL_FROM_INLINE (x))
980 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
982 && !TREE_STATIC (name))
984 /* Location of previous decl is not useful in this case. */
985 warning ("declaration of '%D' shadows a member of 'this'",
988 else if (oldlocal != NULL_TREE
989 && TREE_CODE (oldlocal) == VAR_DECL)
991 warning ("declaration of '%D' shadows a previous local", x);
992 warning ("%Jshadowed declaration is here", oldlocal);
994 else if (oldglobal != NULL_TREE
995 && TREE_CODE (oldglobal) == VAR_DECL)
996 /* XXX shadow warnings in outer-more namespaces */
998 warning ("declaration of '%D' shadows a global declaration",
1000 warning ("%Jshadowed declaration is here", oldglobal);
1005 if (TREE_CODE (x) == FUNCTION_DECL)
1006 check_default_args (x);
1008 if (TREE_CODE (x) == VAR_DECL)
1009 maybe_register_incomplete_var (x);
1012 if (need_new_binding)
1013 add_decl_to_level (x,
1014 DECL_NAMESPACE_SCOPE_P (x)
1015 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1016 : current_binding_level);
1018 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1021 /* Enter DECL into the symbol table, if that's appropriate. Returns
1022 DECL, or a modified version thereof. */
1025 maybe_push_decl (tree decl)
1027 tree type = TREE_TYPE (decl);
1029 /* Add this decl to the current binding level, but not if it comes
1030 from another scope, e.g. a static member variable. TEM may equal
1031 DECL or it may be a previous decl of the same name. */
1032 if (decl == error_mark_node
1033 || (TREE_CODE (decl) != PARM_DECL
1034 && DECL_CONTEXT (decl) != NULL_TREE
1035 /* Definitions of namespace members outside their namespace are
1037 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1038 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1039 || TREE_CODE (type) == UNKNOWN_TYPE
1040 /* The declaration of a template specialization does not affect
1041 the functions available for overload resolution, so we do not
1043 || (TREE_CODE (decl) == FUNCTION_DECL
1044 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1047 return pushdecl (decl);
1050 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1051 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1052 doesn't really belong to this binding level, that it got here
1053 through a using-declaration. */
1056 push_local_binding (tree id, tree decl, int flags)
1058 struct cp_binding_level *b;
1060 /* Skip over any local classes. This makes sense if we call
1061 push_local_binding with a friend decl of a local class. */
1062 b = innermost_nonclass_level ();
1064 if (lookup_name_current_level (id))
1066 /* Supplement the existing binding. */
1067 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1068 /* It didn't work. Something else must be bound at this
1069 level. Do not add DECL to the list of things to pop
1074 /* Create a new binding. */
1075 push_binding (id, decl, b);
1077 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1078 /* We must put the OVERLOAD into a TREE_LIST since the
1079 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1080 decls that got here through a using-declaration. */
1081 decl = build_tree_list (NULL_TREE, decl);
1083 /* And put DECL on the list of things declared by the current
1085 add_decl_to_level (decl, b);
1088 /* The old ARM scoping rules injected variables declared in the
1089 initialization statement of a for-statement into the surrounding
1090 scope. We support this usage, in order to be backward-compatible.
1091 DECL is a just-declared VAR_DECL; if necessary inject its
1092 declaration into the surrounding scope. */
1095 maybe_inject_for_scope_var (tree decl)
1097 timevar_push (TV_NAME_LOOKUP);
1098 if (!DECL_NAME (decl))
1100 timevar_pop (TV_NAME_LOOKUP);
1104 /* Declarations of __FUNCTION__ and its ilk appear magically when
1105 the variable is first used. If that happens to be inside a
1106 for-loop, we don't want to do anything special. */
1107 if (DECL_PRETTY_FUNCTION_P (decl))
1109 timevar_pop (TV_NAME_LOOKUP);
1113 if (current_binding_level->kind == sk_for)
1115 struct cp_binding_level *outer
1116 = current_binding_level->level_chain;
1118 /* Check to see if the same name is already bound at the outer
1119 level, either because it was directly declared, or because a
1120 dead for-decl got preserved. In either case, the code would
1121 not have been valid under the ARM scope rules, so clear
1122 is_for_scope for the current_binding_level.
1124 Otherwise, we need to preserve the temp slot for decl to last
1125 into the outer binding level. */
1127 cxx_binding *outer_binding
1128 = IDENTIFIER_BINDING (DECL_NAME (decl))->previous;
1130 if (outer_binding && outer_binding->scope == outer
1131 && (TREE_CODE (outer_binding->value) == VAR_DECL)
1132 && DECL_DEAD_FOR_LOCAL (outer_binding->value))
1134 outer_binding->value = DECL_SHADOWED_FOR_VAR (outer_binding->value);
1135 current_binding_level->kind = sk_block;
1138 timevar_pop (TV_NAME_LOOKUP);
1141 /* Check to see whether or not DECL is a variable that would have been
1142 in scope under the ARM, but is not in scope under the ANSI/ISO
1143 standard. If so, issue an error message. If name lookup would
1144 work in both cases, but return a different result, this function
1145 returns the result of ANSI/ISO lookup. Otherwise, it returns
1149 check_for_out_of_scope_variable (tree decl)
1153 /* We only care about out of scope variables. */
1154 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1157 shadowed = DECL_SHADOWED_FOR_VAR (decl);
1158 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1159 && DECL_DEAD_FOR_LOCAL (shadowed))
1160 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1162 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1165 if (!DECL_ERROR_REPORTED (decl))
1167 warning ("name lookup of `%D' changed",
1169 cp_warning_at (" matches this `%D' under ISO standard rules",
1171 cp_warning_at (" matches this `%D' under old rules", decl);
1172 DECL_ERROR_REPORTED (decl) = 1;
1177 /* If we have already complained about this declaration, there's no
1178 need to do it again. */
1179 if (DECL_ERROR_REPORTED (decl))
1182 DECL_ERROR_REPORTED (decl) = 1;
1183 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1185 error ("name lookup of `%D' changed for new ISO `for' scoping",
1187 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
1188 return error_mark_node;
1192 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
1194 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
1200 /* true means unconditionally make a BLOCK for the next level pushed. */
1202 static bool keep_next_level_flag;
1204 static int binding_depth = 0;
1205 static int is_class_level = 0;
1212 for (i = 0; i < depth * 2; i++)
1216 /* Return a string describing the kind of SCOPE we have. */
1218 cxx_scope_descriptor (cxx_scope *scope)
1220 /* The order of this table must match the "scope_kind"
1222 static const char* scope_kind_names[] = {
1228 "function-parameter-scope",
1231 "template-parameter-scope",
1232 "template-explicit-spec-scope"
1234 const scope_kind kind = scope->explicit_spec_p
1235 ? sk_template_spec : scope->kind;
1237 return scope_kind_names[kind];
1240 /* Output a debugging information about SCOPE when performing
1243 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1245 const char *desc = cxx_scope_descriptor (scope);
1246 if (scope->this_entity)
1247 verbatim ("%s %s(%E) %p %d\n", action, desc,
1248 scope->this_entity, (void *) scope, line);
1250 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1253 /* Return the estimated initial size of the hashtable of a NAMESPACE
1256 static inline size_t
1257 namespace_scope_ht_size (tree ns)
1259 tree name = DECL_NAME (ns);
1261 return name == std_identifier
1262 ? NAMESPACE_STD_HT_SIZE
1263 : (name == global_scope_name
1264 ? GLOBAL_SCOPE_HT_SIZE
1265 : NAMESPACE_ORDINARY_HT_SIZE);
1268 /* A chain of binding_level structures awaiting reuse. */
1270 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
1272 /* Create a new KIND scope and make it the top of the active scopes stack.
1273 ENTITY is the scope of the associated C++ entity (namespace, class,
1274 function); it is NULL otherwise. */
1277 begin_scope (scope_kind kind, tree entity)
1281 /* Reuse or create a struct for this binding level. */
1282 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1284 scope = free_binding_level;
1285 free_binding_level = scope->level_chain;
1288 scope = ggc_alloc (sizeof (cxx_scope));
1289 memset (scope, 0, sizeof (cxx_scope));
1291 scope->this_entity = entity;
1292 scope->more_cleanups_ok = true;
1299 case sk_template_spec:
1300 scope->explicit_spec_p = true;
1301 kind = sk_template_parms;
1303 case sk_template_parms:
1309 case sk_function_parms:
1310 scope->keep = keep_next_level_flag;
1314 scope->type_decls = binding_table_new (namespace_scope_ht_size (entity));
1315 NAMESPACE_LEVEL (entity) = scope;
1316 VARRAY_TREE_INIT (scope->static_decls,
1317 DECL_NAME (entity) == std_identifier
1318 || DECL_NAME (entity) == global_scope_name
1320 "Static declarations");
1324 /* Should not happen. */
1325 my_friendly_assert (false, 20030922);
1330 /* Add it to the front of currently active scopes stack. */
1331 scope->level_chain = current_binding_level;
1332 current_binding_level = scope;
1333 keep_next_level_flag = false;
1335 if (ENABLE_SCOPE_CHECKING)
1337 scope->binding_depth = binding_depth;
1338 indent (binding_depth);
1339 cxx_scope_debug (scope, input_location.line, "push");
1347 /* We're about to leave current scope. Pop the top of the stack of
1348 currently active scopes. Return the enclosing scope, now active. */
1353 cxx_scope *scope = current_binding_level;
1355 if (scope->kind == sk_namespace && class_binding_level)
1356 current_binding_level = class_binding_level;
1358 /* We cannot leave a scope, if there are none left. */
1359 if (NAMESPACE_LEVEL (global_namespace))
1360 my_friendly_assert (!global_scope_p (scope), 20030527);
1362 if (ENABLE_SCOPE_CHECKING)
1364 indent (--binding_depth);
1365 cxx_scope_debug (scope, input_location.line, "leave");
1366 if (is_class_level != (scope == class_binding_level))
1368 indent (binding_depth);
1369 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1374 /* Move one nesting level up. */
1375 current_binding_level = scope->level_chain;
1377 /* Namespace-scopes are left most probably temporarily, not completely;
1378 they can be reopen later, e.g. in namespace-extension or any name
1379 binding activity that requires us to resume a namespace. For other
1380 scopes, we just make the structure available for reuse. */
1381 if (scope->kind != sk_namespace)
1383 scope->level_chain = free_binding_level;
1384 if (scope->kind == sk_class)
1385 scope->type_decls = NULL;
1387 binding_table_free (scope->type_decls);
1388 my_friendly_assert (!ENABLE_SCOPE_CHECKING
1389 || scope->binding_depth == binding_depth,
1391 free_binding_level = scope;
1394 /* Find the innermost enclosing class scope, and reset
1395 CLASS_BINDING_LEVEL appropriately. */
1396 for (scope = current_binding_level;
1397 scope && scope->kind != sk_class;
1398 scope = scope->level_chain)
1400 class_binding_level = scope && scope->kind == sk_class ? scope : NULL;
1402 return current_binding_level;
1406 resume_scope (struct cp_binding_level* b)
1408 /* Resuming binding levels is meant only for namespaces,
1409 and those cannot nest into classes. */
1410 my_friendly_assert(!class_binding_level, 386);
1411 /* Also, resuming a non-directly nested namespace is a no-no. */
1412 my_friendly_assert(b->level_chain == current_binding_level, 386);
1413 current_binding_level = b;
1414 if (ENABLE_SCOPE_CHECKING)
1416 b->binding_depth = binding_depth;
1417 indent (binding_depth);
1418 cxx_scope_debug (b, input_location.line, "resume");
1424 /* Return the innermost binding level that is not for a class scope. */
1427 innermost_nonclass_level (void)
1431 b = current_binding_level;
1432 while (b->kind == sk_class)
1438 /* We're defining an object of type TYPE. If it needs a cleanup, but
1439 we're not allowed to add any more objects with cleanups to the current
1440 scope, create a new binding level. */
1443 maybe_push_cleanup_level (tree type)
1445 if (type != error_mark_node
1446 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1447 && current_binding_level->more_cleanups_ok == 0)
1449 begin_scope (sk_cleanup, NULL);
1451 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
1455 /* Nonzero if we are currently in the global binding level. */
1458 global_bindings_p (void)
1460 return global_scope_p (current_binding_level);
1463 /* True if we are currently in a toplevel binding level. This
1464 means either the global binding level or a namespace in a toplevel
1465 binding level. Since there are no non-toplevel namespace levels,
1466 this really means any namespace or template parameter level. We
1467 also include a class whose context is toplevel. */
1470 toplevel_bindings_p (void)
1472 struct cp_binding_level *b = innermost_nonclass_level ();
1474 return b->kind == sk_namespace || b->kind == sk_template_parms;
1477 /* True if this is a namespace scope, or if we are defining a class
1478 which is itself at namespace scope, or whose enclosing class is
1479 such a class, etc. */
1482 namespace_bindings_p (void)
1484 struct cp_binding_level *b = innermost_nonclass_level ();
1486 return b->kind == sk_namespace;
1489 /* True if the current level needs to have a BLOCK made. */
1494 return (current_binding_level->blocks != NULL_TREE
1495 || current_binding_level->keep
1496 || current_binding_level->kind == sk_cleanup
1497 || current_binding_level->names != NULL_TREE
1498 || current_binding_level->type_decls != NULL);
1501 /* Returns the kind of the innermost scope. */
1504 innermost_scope_kind (void)
1506 return current_binding_level->kind;
1509 /* Returns true if this scope was created to store template parameters. */
1512 template_parm_scope_p (void)
1514 return innermost_scope_kind () == sk_template_parms;
1517 /* If KEEP is true, make a BLOCK node for the next binding level,
1518 unconditionally. Otherwise, use the normal logic to decide whether
1519 or not to create a BLOCK. */
1522 keep_next_level (bool keep)
1524 keep_next_level_flag = keep;
1527 /* Return the list of declarations of the current level.
1528 Note that this list is in reverse order unless/until
1529 you nreverse it; and when you do nreverse it, you must
1530 store the result back using `storedecls' or you will lose. */
1535 return current_binding_level->names;
1538 /* Set the current binding TABLE for type declarations.. This is a
1539 temporary workaround of the fact that the data structure classtypes
1540 does not currently carry its allocated cxx_scope structure. */
1542 cxx_remember_type_decls (binding_table table)
1544 current_binding_level->type_decls = table;
1547 /* For debugging. */
1548 static int no_print_functions = 0;
1549 static int no_print_builtins = 0;
1551 /* Called from print_binding_level through binding_table_foreach to
1552 print the content of binding ENTRY. DATA is a pointer to line offset
1555 bt_print_entry (binding_entry entry, void *data)
1557 int *p = (int *) data;
1560 if (entry->name == NULL)
1562 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1572 fprintf (stderr, "\n\t");
1575 if (entry->name == NULL)
1577 print_node_brief (stderr, "<unnamed-typedef", entry->type, 0);
1578 fprintf (stderr, ">");
1580 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1581 print_node_brief (stderr, "", entry->type, 0);
1584 print_node_brief (stderr, "<typedef", entry->name, 0);
1585 print_node_brief (stderr, "", entry->type, 0);
1586 fprintf (stderr, ">");
1591 print_binding_level (struct cp_binding_level* lvl)
1595 fprintf (stderr, " blocks=" HOST_PTR_PRINTF, (void *) lvl->blocks);
1596 if (lvl->more_cleanups_ok)
1597 fprintf (stderr, " more-cleanups-ok");
1598 if (lvl->have_cleanups)
1599 fprintf (stderr, " have-cleanups");
1600 fprintf (stderr, "\n");
1603 fprintf (stderr, " names:\t");
1604 /* We can probably fit 3 names to a line? */
1605 for (t = lvl->names; t; t = TREE_CHAIN (t))
1607 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1609 if (no_print_builtins
1610 && (TREE_CODE (t) == TYPE_DECL)
1611 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1614 /* Function decls tend to have longer names. */
1615 if (TREE_CODE (t) == FUNCTION_DECL)
1622 fprintf (stderr, "\n\t");
1625 print_node_brief (stderr, "", t, 0);
1626 if (t == error_mark_node)
1630 fprintf (stderr, "\n");
1632 if (lvl->type_decls)
1634 fprintf (stderr, " tags:\t");
1636 binding_table_foreach (lvl->type_decls, bt_print_entry, &i);
1638 fprintf (stderr, "\n");
1640 if (lvl->class_shadowed)
1642 fprintf (stderr, " class-shadowed:");
1643 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1645 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1647 fprintf (stderr, "\n");
1649 if (lvl->type_shadowed)
1651 fprintf (stderr, " type-shadowed:");
1652 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1654 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1656 fprintf (stderr, "\n");
1661 print_other_binding_stack (struct cp_binding_level *stack)
1663 struct cp_binding_level *level;
1664 for (level = stack; !global_scope_p (level); level = level->level_chain)
1666 fprintf (stderr, "binding level " HOST_PTR_PRINTF "\n", (void *) level);
1667 print_binding_level (level);
1672 print_binding_stack (void)
1674 struct cp_binding_level *b;
1675 fprintf (stderr, "current_binding_level=" HOST_PTR_PRINTF
1676 "\nclass_binding_level=" HOST_PTR_PRINTF
1677 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF "\n",
1678 (void *) current_binding_level, (void *) class_binding_level,
1679 (void *) NAMESPACE_LEVEL (global_namespace));
1680 if (class_binding_level)
1682 for (b = class_binding_level; b; b = b->level_chain)
1683 if (b == current_binding_level)
1686 b = class_binding_level;
1688 b = current_binding_level;
1691 b = current_binding_level;
1692 print_other_binding_stack (b);
1693 fprintf (stderr, "global:\n");
1694 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1697 /* Return the type associated with id. */
1700 identifier_type_value (tree id)
1702 timevar_push (TV_NAME_LOOKUP);
1703 /* There is no type with that name, anywhere. */
1704 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1706 /* This is not the type marker, but the real thing. */
1707 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1708 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1709 /* Have to search for it. It must be on the global level, now.
1710 Ask lookup_name not to return non-types. */
1711 id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
1713 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1717 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1718 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1721 identifier_global_value (tree t)
1723 return IDENTIFIER_GLOBAL_VALUE (t);
1726 /* Push a definition of struct, union or enum tag named ID. into
1727 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1728 the tag ID is not already defined. */
1731 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1735 if (b->kind != sk_namespace)
1737 /* Shadow the marker, not the real thing, so that the marker
1738 gets restored later. */
1739 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1741 = tree_cons (id, old_type_value, b->type_shadowed);
1742 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1746 cxx_binding *binding =
1747 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1751 supplement_binding (binding, decl);
1753 binding->value = decl;
1757 /* Store marker instead of real type. */
1758 type = global_type_node;
1760 SET_IDENTIFIER_TYPE_VALUE (id, type);
1763 /* As set_identifier_type_value_with_scope, but using
1764 current_binding_level. */
1767 set_identifier_type_value (tree id, tree decl)
1769 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1772 /* Return the name for the constructor (or destructor) for the
1773 specified class TYPE. When given a template, this routine doesn't
1774 lose the specialization. */
1777 constructor_name_full (tree type)
1779 type = TYPE_MAIN_VARIANT (type);
1780 if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type)
1781 && TYPE_HAS_CONSTRUCTOR (type))
1782 return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1784 return TYPE_IDENTIFIER (type);
1787 /* Return the name for the constructor (or destructor) for the
1788 specified class. When given a template, return the plain
1789 unspecialized name. */
1792 constructor_name (tree type)
1795 name = constructor_name_full (type);
1796 if (IDENTIFIER_TEMPLATE (name))
1797 name = IDENTIFIER_TEMPLATE (name);
1801 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1804 constructor_name_p (tree name, tree type)
1811 if (TREE_CODE (name) != IDENTIFIER_NODE)
1814 ctor_name = constructor_name_full (type);
1815 if (name == ctor_name)
1817 if (IDENTIFIER_TEMPLATE (ctor_name)
1818 && name == IDENTIFIER_TEMPLATE (ctor_name))
1823 /* Counter used to create anonymous type names. */
1825 static GTY(()) int anon_cnt;
1827 /* Return an IDENTIFIER which can be used as a name for
1828 anonymous structs and unions. */
1831 make_anon_name (void)
1835 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1836 return get_identifier (buf);
1839 /* Clear the TREE_PURPOSE slot of UTDs which have anonymous typenames.
1840 This keeps dbxout from getting confused. */
1843 clear_anon_tags (void)
1845 struct cp_binding_level *b;
1846 static int last_cnt = 0;
1848 /* Fast out if no new anon names were declared. */
1849 if (last_cnt == anon_cnt)
1852 b = current_binding_level;
1853 while (b->kind == sk_cleanup)
1855 if (b->type_decls != NULL)
1856 binding_table_remove_anonymous_types (b->type_decls);
1857 last_cnt = anon_cnt;
1860 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1862 static inline cxx_binding *
1863 find_binding (cxx_scope *scope, cxx_binding *binding)
1865 timevar_push (TV_NAME_LOOKUP);
1867 for (; binding != NULL; binding = binding->previous)
1868 if (binding->scope == scope)
1869 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1871 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1874 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1876 static inline cxx_binding *
1877 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1879 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1882 /* Fold-in case where NAME is used only once. */
1883 if (scope == b->scope && b->previous == NULL)
1885 return find_binding (scope, b);
1890 /* Always returns a binding for name in scope. If no binding is
1891 found, make a new one. */
1893 static cxx_binding *
1894 binding_for_name (cxx_scope *scope, tree name)
1896 cxx_binding *result;
1898 result = cxx_scope_find_binding_for_name (scope, name);
1901 /* Not found, make a new one. */
1902 result = cxx_binding_make (NULL, NULL);
1903 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1904 result->scope = scope;
1905 result->is_local = false;
1906 result->value_is_inherited = false;
1907 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1911 /* Insert another USING_DECL into the current binding level, returning
1912 this declaration. If this is a redeclaration, do nothing, and
1913 return NULL_TREE if this not in namespace scope (in namespace
1914 scope, a using decl might extend any previous bindings). */
1917 push_using_decl (tree scope, tree name)
1921 timevar_push (TV_NAME_LOOKUP);
1922 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
1923 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
1924 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1925 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
1928 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1929 namespace_bindings_p () ? decl : NULL_TREE);
1930 decl = build_lang_decl (USING_DECL, name, void_type_node);
1931 DECL_INITIAL (decl) = scope;
1932 TREE_CHAIN (decl) = current_binding_level->usings;
1933 current_binding_level->usings = decl;
1934 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1937 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1938 caller to set DECL_CONTEXT properly. */
1941 pushdecl_with_scope (tree x, cxx_scope *level)
1943 struct cp_binding_level *b;
1944 tree function_decl = current_function_decl;
1946 timevar_push (TV_NAME_LOOKUP);
1947 current_function_decl = NULL_TREE;
1948 if (level->kind == sk_class)
1950 b = class_binding_level;
1951 class_binding_level = level;
1952 pushdecl_class_level (x);
1953 class_binding_level = b;
1957 b = current_binding_level;
1958 current_binding_level = level;
1960 current_binding_level = b;
1962 current_function_decl = function_decl;
1963 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1966 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1967 other definitions already in place. We get around this by making
1968 the value of the identifier point to a list of all the things that
1969 want to be referenced by that name. It is then up to the users of
1970 that name to decide what to do with that list.
1972 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1973 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1975 FLAGS is a bitwise-or of the following values:
1976 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1978 PUSH_USING: DECL is being pushed as the result of a using
1981 The value returned may be a previous declaration if we guessed wrong
1982 about what language DECL should belong to (C or C++). Otherwise,
1983 it's always DECL (and never something that's not a _DECL). */
1986 push_overloaded_decl (tree decl, int flags)
1988 tree name = DECL_NAME (decl);
1991 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1993 timevar_push (TV_NAME_LOOKUP);
1995 old = namespace_binding (name, DECL_CONTEXT (decl));
1997 old = lookup_name_current_level (name);
2001 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2003 tree t = TREE_TYPE (old);
2004 if (IS_AGGR_TYPE (t) && warn_shadow
2005 && (! DECL_IN_SYSTEM_HEADER (decl)
2006 || ! DECL_IN_SYSTEM_HEADER (old)))
2007 warning ("`%#D' hides constructor for `%#T'", decl, t);
2010 else if (is_overloaded_fn (old))
2014 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2016 tree fn = OVL_CURRENT (tmp);
2018 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2019 && !(flags & PUSH_USING)
2020 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2021 TYPE_ARG_TYPES (TREE_TYPE (decl))))
2022 error ("`%#D' conflicts with previous using declaration `%#D'",
2025 if (duplicate_decls (decl, fn) == fn)
2026 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
2029 else if (old == error_mark_node)
2030 /* Ignore the undefined symbol marker. */
2034 cp_error_at ("previous non-function declaration `%#D'", old);
2035 error ("conflicts with function declaration `%#D'", decl);
2036 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2040 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2041 /* If it's a using declaration, we always need to build an OVERLOAD,
2042 because it's the only way to remember that the declaration comes
2043 from 'using', and have the lookup behave correctly. */
2044 || (flags & PUSH_USING))
2046 if (old && TREE_CODE (old) != OVERLOAD)
2047 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2049 new_binding = ovl_cons (decl, old);
2050 if (flags & PUSH_USING)
2051 OVL_USED (new_binding) = 1;
2054 /* NAME is not ambiguous. */
2058 set_namespace_binding (name, current_namespace, new_binding);
2061 /* We only create an OVERLOAD if there was a previous binding at
2062 this level, or if decl is a template. In the former case, we
2063 need to remove the old binding and replace it with the new
2064 binding. We must also run through the NAMES on the binding
2065 level where the name was bound to update the chain. */
2067 if (TREE_CODE (new_binding) == OVERLOAD && old)
2071 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2073 d = &TREE_CHAIN (*d))
2075 || (TREE_CODE (*d) == TREE_LIST
2076 && TREE_VALUE (*d) == old))
2078 if (TREE_CODE (*d) == TREE_LIST)
2079 /* Just replace the old binding with the new. */
2080 TREE_VALUE (*d) = new_binding;
2082 /* Build a TREE_LIST to wrap the OVERLOAD. */
2083 *d = tree_cons (NULL_TREE, new_binding,
2086 /* And update the cxx_binding node. */
2087 IDENTIFIER_BINDING (name)->value = new_binding;
2088 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2091 /* We should always find a previous binding in this case. */
2095 /* Install the new binding. */
2096 push_local_binding (name, new_binding, flags);
2099 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2102 /* Check a non-member using-declaration. Return the name and scope
2103 being used, and the USING_DECL, or NULL_TREE on failure. */
2106 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2108 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2111 A using-declaration shall not name a template-id. */
2112 error ("a using-declaration cannot specify a template-id. Try `using %D'", name);
2116 if (TREE_CODE (decl) == NAMESPACE_DECL)
2118 error ("namespace `%D' not allowed in using-declaration", decl);
2122 if (TREE_CODE (decl) == SCOPE_REF)
2124 /* It's a nested name with template parameter dependent scope.
2125 This can only be using-declaration for class member. */
2126 error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
2130 if (is_overloaded_fn (decl))
2131 decl = get_first_fn (decl);
2133 my_friendly_assert (DECL_P (decl), 20020908);
2135 /* [namespace.udecl]
2136 A using-declaration for a class member shall be a
2137 member-declaration. */
2140 error ("`%T' is not a namespace", scope);
2144 /* Make a USING_DECL. */
2145 return push_using_decl (scope, name);
2148 /* Process local and global using-declarations. */
2151 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2152 tree *newval, tree *newtype)
2156 *newval = *newtype = NULL_TREE;
2157 cxx_binding_clear (&decls);
2158 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2162 if (!decls.value && !decls.type)
2164 error ("`%D' not declared", name);
2168 /* Check for using functions. */
2169 if (decls.value && is_overloaded_fn (decls.value))
2173 if (oldval && !is_overloaded_fn (oldval))
2175 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2176 error ("`%D' is already declared in this scope", name);
2181 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2183 tree new_fn = OVL_CURRENT (tmp);
2185 /* [namespace.udecl]
2187 If a function declaration in namespace scope or block
2188 scope has the same name and the same parameter types as a
2189 function introduced by a using declaration the program is
2191 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2193 tree old_fn = OVL_CURRENT (tmp1);
2195 if (new_fn == old_fn)
2196 /* The function already exists in the current namespace. */
2198 else if (OVL_USED (tmp1))
2199 continue; /* this is a using decl */
2200 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2201 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2203 /* There was already a non-using declaration in
2204 this scope with the same parameter types. If both
2205 are the same extern "C" functions, that's ok. */
2206 if (decls_match (new_fn, old_fn))
2208 /* If the OLD_FN was a builtin, there is now a
2209 real declaration. */
2210 if (DECL_ANTICIPATED (old_fn))
2211 DECL_ANTICIPATED (old_fn) = 0;
2214 else if (!DECL_ANTICIPATED (old_fn))
2216 /* If the OLD_FN was really declared, the
2217 declarations don't match. */
2218 error ("`%D' is already declared in this scope", name);
2222 /* If the OLD_FN was not really there, just ignore
2223 it and keep going. */
2227 /* If we broke out of the loop, there's no reason to add
2228 this function to the using declarations for this
2233 /* If we are adding to an existing OVERLOAD, then we no
2234 longer know the type of the set of functions. */
2235 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2236 TREE_TYPE (*newval) = unknown_type_node;
2237 /* Add this new function to the set. */
2238 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2239 /* If there is only one function, then we use its type. (A
2240 using-declaration naming a single function can be used in
2241 contexts where overload resolution cannot be
2243 if (TREE_CODE (*newval) != OVERLOAD)
2245 *newval = ovl_cons (*newval, NULL_TREE);
2246 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2248 OVL_USED (*newval) = 1;
2253 *newval = decls.value;
2254 if (oldval && !decls_match (*newval, oldval))
2255 error ("`%D' is already declared in this scope", name);
2258 *newtype = decls.type;
2259 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2261 error ("using declaration `%D' introduced ambiguous type `%T'",
2267 /* Process a using-declaration at function scope. */
2270 do_local_using_decl (tree decl, tree scope, tree name)
2272 tree oldval, oldtype, newval, newtype;
2274 decl = validate_nonmember_using_decl (decl, scope, name);
2275 if (decl == NULL_TREE)
2278 if (building_stmt_tree ()
2279 && at_function_scope_p ())
2280 add_decl_stmt (decl);
2282 oldval = lookup_name_current_level (name);
2283 oldtype = lookup_type_current_level (name);
2285 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2289 if (is_overloaded_fn (newval))
2293 /* We only need to push declarations for those functions
2294 that were not already bound in the current level.
2295 The old value might be NULL_TREE, it might be a single
2296 function, or an OVERLOAD. */
2297 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2298 term = OVL_FUNCTION (oldval);
2301 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2303 push_overloaded_decl (OVL_CURRENT (fn),
2304 PUSH_LOCAL | PUSH_USING);
2307 push_local_binding (name, newval, PUSH_USING);
2311 push_local_binding (name, newtype, PUSH_USING);
2312 set_identifier_type_value (name, newtype);
2316 /* Return the type that should be used when TYPE's name is preceded
2317 by a tag such as 'struct' or 'union', or null if the name cannot
2318 be used in this way.
2320 For example, when processing the third line of:
2326 lookup of A will find the typedef. Given A's typedef, this function
2327 will return the type associated with "struct A". For the tag to be
2328 anything other than TYPE, TYPE must be a typedef whose original type
2329 has the same name and context as TYPE itself.
2331 It is not valid for a typedef of an anonymous type to be used with
2334 typedef struct { ... } B;
2337 Return null for this case. */
2340 follow_tag_typedef (tree type)
2344 original = original_type (type);
2345 if (! TYPE_NAME (original))
2347 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
2348 && (CP_DECL_CONTEXT (TYPE_NAME (original))
2349 == CP_DECL_CONTEXT (TYPE_NAME (type)))
2350 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
2356 /* Given NAME, an IDENTIFIER_NODE,
2357 return the structure (or union or enum) definition for that name.
2358 Searches binding levels from its SCOPE up to the global level.
2359 If THISLEVEL_ONLY is nonzero, searches only the specified context
2360 (but skips any sk_cleanup contexts to find one that is
2361 meaningful for tags).
2362 FORM says which kind of type the caller wants;
2363 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2364 If the wrong kind of type is found, and it's not a template, an error is
2368 lookup_tag (enum tree_code form, tree name,
2369 cxx_scope *binding_level, int thislevel_only)
2371 struct cp_binding_level *level;
2372 /* Nonzero if, we should look past a template parameter level, even
2373 if THISLEVEL_ONLY. */
2374 int allow_template_parms_p = 1;
2375 bool type_is_anonymous = ANON_AGGRNAME_P (name);
2377 timevar_push (TV_NAME_LOOKUP);
2378 for (level = binding_level; level; level = level->level_chain)
2381 if (type_is_anonymous && level->type_decls != NULL)
2383 tree type = binding_table_find_anon_type (level->type_decls, name);
2384 /* There is no need for error checking here, because
2385 anon names are unique throughout the compilation. */
2387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
2389 else if (level->kind == sk_namespace)
2390 /* Do namespace lookup. */
2391 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
2393 cxx_binding *binding =
2394 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (tail), name);
2397 /* If we just skipped past a template parameter level,
2398 even though THISLEVEL_ONLY, and we find a template
2399 class declaration, then we use the _TYPE node for the
2400 template. See the example below. */
2401 if (thislevel_only && !allow_template_parms_p
2402 && binding && binding->value
2403 && DECL_CLASS_TEMPLATE_P (binding->value))
2404 old = binding->value;
2406 old = select_decl (binding, LOOKUP_PREFER_TYPES);
2412 /* We've found something at this binding level. If it is
2413 a typedef, extract the tag it refers to. Lookup fails
2414 if the typedef doesn't refer to a taggable type. */
2415 old = TREE_TYPE (old);
2416 old = follow_tag_typedef (old);
2418 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2419 if (TREE_CODE (old) != form
2420 && (form == ENUMERAL_TYPE
2421 || TREE_CODE (old) == ENUMERAL_TYPE))
2423 error ("`%#D' redeclared as %C", old, form);
2424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2426 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
2428 if (thislevel_only || tail == global_namespace)
2429 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2431 else if (level->type_decls != NULL)
2433 binding_entry entry = binding_table_find (level->type_decls, name);
2436 enum tree_code code = TREE_CODE (entry->type);
2439 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
2441 /* Definition isn't the kind we were looking for. */
2442 error ("`%#D' redeclared as %C", entry->type, form);
2443 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2445 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->type);
2448 if (thislevel_only && level->kind != sk_cleanup)
2450 if (level->kind == sk_template_parms && allow_template_parms_p)
2452 /* We must deal with cases like this:
2454 template <class T> struct S;
2455 template <class T> struct S {};
2457 When looking up `S', for the second declaration, we
2458 would like to find the first declaration. But, we
2459 are in the pseudo-global level created for the
2460 template parameters, rather than the (surrounding)
2461 namespace level. Thus, we keep going one more level,
2462 even though THISLEVEL_ONLY is nonzero. */
2463 allow_template_parms_p = 0;
2467 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2470 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2473 /* Given a type, find the tag that was defined for it and return the tag name.
2474 Otherwise return 0. However, the value can never be 0
2475 in the cases in which this is used.
2477 C++: If NAME is nonzero, this is the new name to install. This is
2478 done when replacing anonymous tags with real tag names. */
2481 lookup_tag_reverse (tree type, tree name)
2483 struct cp_binding_level *level;
2485 timevar_push (TV_NAME_LOOKUP);
2486 for (level = current_binding_level; level; level = level->level_chain)
2488 binding_entry entry = level->type_decls == NULL
2490 : binding_table_reverse_maybe_remap (level->type_decls, type, name);
2492 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->name);
2494 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2497 /* Returns true if ROOT (a namespace, class, or function) encloses
2498 CHILD. CHILD may be either a class type or a namespace. */
2501 is_ancestor (tree root, tree child)
2503 my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
2504 || TREE_CODE (root) == FUNCTION_DECL
2505 || CLASS_TYPE_P (root)), 20030307);
2506 my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
2507 || CLASS_TYPE_P (child)),
2510 /* The global namespace encloses everything. */
2511 if (root == global_namespace)
2516 /* If we've run out of scopes, stop. */
2519 /* If we've reached the ROOT, it encloses CHILD. */
2522 /* Go out one level. */
2524 child = TYPE_NAME (child);
2525 child = DECL_CONTEXT (child);
2529 /* Enter the class or namespace scope indicated by T. Returns TRUE iff
2530 pop_scope should be called later to exit this scope. */
2537 if (TREE_CODE (t) == NAMESPACE_DECL)
2538 push_decl_namespace (t);
2539 else if (CLASS_TYPE_P (t))
2541 if (!at_class_scope_p ()
2542 || !same_type_p (current_class_type, t))
2543 push_nested_class (t);
2545 /* T is the same as the current scope. There is therefore no
2546 need to re-enter the scope. Since we are not actually
2547 pushing a new scope, our caller should not call
2555 /* Leave scope pushed by push_scope. */
2560 if (TREE_CODE (t) == NAMESPACE_DECL)
2561 pop_decl_namespace ();
2562 else if CLASS_TYPE_P (t)
2563 pop_nested_class ();
2566 /* Do a pushlevel for class declarations. */
2569 pushlevel_class (void)
2571 if (ENABLE_SCOPE_CHECKING)
2574 class_binding_level = begin_scope (sk_class, current_class_type);
2577 /* ...and a poplevel for class declarations. */
2580 poplevel_class (void)
2582 struct cp_binding_level *level = class_binding_level;
2585 timevar_push (TV_NAME_LOOKUP);
2586 my_friendly_assert (level != 0, 354);
2588 /* If we're leaving a toplevel class, don't bother to do the setting
2589 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
2590 shouldn't even be used when current_class_type isn't set, and second,
2591 if we don't touch it here, we're able to use the cache effect if the
2592 next time we're entering a class scope, it is the same class. */
2593 if (current_class_depth != 1)
2595 struct cp_binding_level* b;
2597 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
2598 for (shadowed = level->class_shadowed;
2600 shadowed = TREE_CHAIN (shadowed))
2601 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
2603 /* Find the next enclosing class, and recreate
2604 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
2605 b = level->level_chain;
2606 while (b && b->kind != sk_class)
2610 for (shadowed = b->class_shadowed;
2612 shadowed = TREE_CHAIN (shadowed))
2614 cxx_binding *binding;
2616 binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
2617 while (binding && binding->scope != b)
2618 binding = binding->previous;
2621 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
2626 /* Remember to save what IDENTIFIER's were bound in this scope so we
2627 can recover from cache misses. */
2629 previous_class_type = current_class_type;
2630 previous_class_values = class_binding_level->class_shadowed;
2632 for (shadowed = level->type_shadowed;
2634 shadowed = TREE_CHAIN (shadowed))
2635 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2637 /* Remove the bindings for all of the class-level declarations. */
2638 for (shadowed = level->class_shadowed;
2640 shadowed = TREE_CHAIN (shadowed))
2641 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
2643 /* Now, pop out of the binding level which we created up in the
2644 `pushlevel_class' routine. */
2645 if (ENABLE_SCOPE_CHECKING)
2649 timevar_pop (TV_NAME_LOOKUP);
2652 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
2653 binding was successful. */
2656 push_class_binding (tree id, tree decl)
2659 cxx_binding *binding = IDENTIFIER_BINDING (id);
2662 timevar_push (TV_NAME_LOOKUP);
2663 /* Note that we declared this value so that we can issue an error if
2664 this is an invalid redeclaration of a name already used for some
2666 note_name_declared_in_class (id, decl);
2668 if (binding && binding->scope == class_binding_level)
2669 /* Supplement the existing binding. */
2670 result = supplement_binding (IDENTIFIER_BINDING (id), decl);
2672 /* Create a new binding. */
2673 push_binding (id, decl, class_binding_level);
2675 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2676 class-level declaration. Note that we do not use DECL here
2677 because of the possibility of the `struct stat' hack; if DECL is
2678 a class-name or enum-name we might prefer a field-name, or some
2680 IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
2682 /* If this is a binding from a base class, mark it as such. */
2683 binding = IDENTIFIER_BINDING (id);
2684 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2686 if (TREE_CODE (decl) == OVERLOAD)
2687 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2690 my_friendly_assert (DECL_P (decl), 0);
2691 context = context_for_name_lookup (decl);
2694 if (is_properly_derived_from (current_class_type, context))
2695 INHERITED_VALUE_BINDING_P (binding) = 1;
2697 INHERITED_VALUE_BINDING_P (binding) = 0;
2699 else if (binding->value == decl)
2700 /* We only encounter a TREE_LIST when push_class_decls detects an
2701 ambiguity. Such an ambiguity can be overridden by a definition
2703 INHERITED_VALUE_BINDING_P (binding) = 1;
2705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
2708 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
2709 for any names in enclosing classes. */
2712 clear_identifier_class_values (void)
2716 if (!class_binding_level)
2719 for (t = class_binding_level->class_shadowed;
2722 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
2725 /* Make the declaration of X appear in CLASS scope. */
2728 pushdecl_class_level (tree x)
2731 bool is_valid = true;
2733 timevar_push (TV_NAME_LOOKUP);
2734 /* Get the name of X. */
2735 if (TREE_CODE (x) == OVERLOAD)
2736 name = DECL_NAME (get_first_fn (x));
2738 name = DECL_NAME (x);
2742 is_valid = push_class_level_binding (name, x);
2743 if (TREE_CODE (x) == TYPE_DECL)
2744 set_identifier_type_value (name, x);
2746 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2748 /* If X is an anonymous aggregate, all of its members are
2749 treated as if they were members of the class containing the
2750 aggregate, for naming purposes. */
2753 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2755 location_t save_location = input_location;
2756 input_location = DECL_SOURCE_LOCATION (f);
2757 if (!pushdecl_class_level (f))
2759 input_location = save_location;
2762 timevar_pop (TV_NAME_LOOKUP);
2767 /* Make the declaration(s) of X appear in CLASS scope under the name
2768 NAME. Returns true if the binding is valid. */
2771 push_class_level_binding (tree name, tree x)
2773 cxx_binding *binding;
2775 timevar_push (TV_NAME_LOOKUP);
2776 /* The class_binding_level will be NULL if x is a template
2777 parameter name in a member template. */
2778 if (!class_binding_level)
2779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2781 /* Make sure that this new member does not have the same name
2782 as a template parameter. */
2783 if (TYPE_BEING_DEFINED (current_class_type))
2784 check_template_shadow (x);
2788 If T is the name of a class, then each of the following shall
2789 have a name different from T:
2791 -- every static data member of class T;
2793 -- every member of class T that is itself a type;
2795 -- every enumerator of every member of class T that is an
2798 -- every member of every anonymous union that is a member of
2801 (Non-static data members were also forbidden to have the same
2802 name as T until TC1.) */
2803 if ((TREE_CODE (x) == VAR_DECL
2804 || TREE_CODE (x) == CONST_DECL
2805 || (TREE_CODE (x) == TYPE_DECL
2806 && !DECL_SELF_REFERENCE_P (x))
2807 /* A data member of an anonymous union. */
2808 || (TREE_CODE (x) == FIELD_DECL
2809 && DECL_CONTEXT (x) != current_class_type))
2810 && DECL_NAME (x) == constructor_name (current_class_type))
2812 tree scope = context_for_name_lookup (x);
2813 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2815 error ("`%D' has the same name as the class in which it is declared",
2817 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2821 /* If this declaration shadows a declaration from an enclosing
2822 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2823 we leave this class. Record the shadowed declaration here. */
2824 binding = IDENTIFIER_BINDING (name);
2825 if (binding && binding->value)
2827 tree bval = binding->value;
2828 tree old_decl = NULL_TREE;
2830 if (INHERITED_VALUE_BINDING_P (binding))
2832 /* If the old binding was from a base class, and was for a
2833 tag name, slide it over to make room for the new binding.
2834 The old binding is still visible if explicitly qualified
2835 with a class-key. */
2836 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2837 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2839 old_decl = binding->type;
2840 binding->type = bval;
2841 binding->value = NULL_TREE;
2842 INHERITED_VALUE_BINDING_P (binding) = 0;
2847 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2849 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2850 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2851 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2853 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2854 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2860 /* Find the previous binding of name on the class-shadowed
2861 list, and update it. */
2862 for (shadow = class_binding_level->class_shadowed;
2864 shadow = TREE_CHAIN (shadow))
2865 if (TREE_PURPOSE (shadow) == name
2866 && TREE_TYPE (shadow) == old_decl)
2869 INHERITED_VALUE_BINDING_P (binding) = 0;
2870 TREE_TYPE (shadow) = x;
2871 IDENTIFIER_CLASS_VALUE (name) = x;
2872 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2877 /* If we didn't replace an existing binding, put the binding on the
2878 stack of bindings for the identifier, and update the shadowed list. */
2879 if (push_class_binding (name, x))
2881 class_binding_level->class_shadowed
2882 = tree_cons (name, NULL,
2883 class_binding_level->class_shadowed);
2884 /* Record the value we are binding NAME to so that we can know
2885 what to pop later. */
2886 TREE_TYPE (class_binding_level->class_shadowed) = x;
2887 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2890 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2894 do_class_using_decl (tree decl)
2896 tree name, value, scope, type;
2898 if (TREE_CODE (decl) != SCOPE_REF
2899 || !TREE_OPERAND (decl, 0)
2900 || !TYPE_P (TREE_OPERAND (decl, 0)))
2902 error ("using-declaration for non-member at class scope");
2905 scope = TREE_OPERAND (decl, 0);
2906 name = TREE_OPERAND (decl, 1);
2907 if (TREE_CODE (name) == BIT_NOT_EXPR)
2909 error ("using-declaration cannot name destructor");
2912 if (TREE_CODE (name) == TYPE_DECL)
2913 name = DECL_NAME (name);
2914 else if (TREE_CODE (name) == TEMPLATE_DECL)
2915 name = DECL_NAME (name);
2916 else if (BASELINK_P (name))
2918 tree fns = BASELINK_FUNCTIONS (name);
2919 name = DECL_NAME (get_first_fn (fns));
2922 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
2924 /* Dependent using decls have a NULL type, non-dependent ones have a
2926 type = dependent_type_p (scope) ? NULL_TREE : void_type_node;
2927 value = build_lang_decl (USING_DECL, name, type);
2928 DECL_INITIAL (value) = scope;
2933 set_class_shadows (tree shadows)
2935 class_binding_level->class_shadowed = shadows;
2938 /* Return the binding value for name in scope. */
2941 namespace_binding (tree name, tree scope)
2943 cxx_binding *binding;
2946 scope = global_namespace;
2947 scope = ORIGINAL_NAMESPACE (scope);
2948 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2950 return binding ? binding->value : NULL_TREE;
2953 /* Set the binding value for name in scope. */
2956 set_namespace_binding (tree name, tree scope, tree val)
2960 timevar_push (TV_NAME_LOOKUP);
2961 if (scope == NULL_TREE)
2962 scope = global_namespace;
2963 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2964 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2967 supplement_binding (b, val);
2968 timevar_pop (TV_NAME_LOOKUP);
2971 /* Set the context of a declaration to scope. Complain if we are not
2975 set_decl_namespace (tree decl, tree scope, bool friendp)
2979 /* Get rid of namespace aliases. */
2980 scope = ORIGINAL_NAMESPACE (scope);
2982 /* It is ok for friends to be qualified in parallel space. */
2983 if (!friendp && !is_ancestor (current_namespace, scope))
2984 error ("declaration of `%D' not in a namespace surrounding `%D'",
2986 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2987 if (scope != current_namespace)
2989 /* See whether this has been declared in the namespace. */
2990 old = namespace_binding (DECL_NAME (decl), scope);
2992 /* No old declaration at all. */
2994 /* A template can be explicitly specialized in any namespace. */
2995 if (processing_explicit_instantiation)
2997 if (!is_overloaded_fn (decl))
2998 /* Don't compare non-function decls with decls_match here,
2999 since it can't check for the correct constness at this
3000 point. pushdecl will find those errors later. */
3002 /* Since decl is a function, old should contain a function decl. */
3003 if (!is_overloaded_fn (old))
3005 if (processing_template_decl || processing_specialization)
3006 /* We have not yet called push_template_decl to turn a
3007 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
3008 won't match. But, we'll check later, when we construct the
3011 if (is_overloaded_fn (old))
3013 for (; old; old = OVL_NEXT (old))
3014 if (decls_match (decl, OVL_CURRENT (old)))
3018 if (decls_match (decl, old))
3024 error ("`%D' should have been declared inside `%D'",
3028 /* Return the namespace where the current declaration is declared. */
3031 current_decl_namespace (void)
3034 /* If we have been pushed into a different namespace, use it. */
3035 if (decl_namespace_list)
3036 return TREE_PURPOSE (decl_namespace_list);
3038 if (current_class_type)
3039 result = decl_namespace_context (current_class_type);
3040 else if (current_function_decl)
3041 result = decl_namespace_context (current_function_decl);
3043 result = current_namespace;
3047 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3048 select a name that is unique to this compilation unit. */
3051 push_namespace (tree name)
3055 int implicit_use = 0;
3058 timevar_push (TV_NAME_LOOKUP);
3060 /* We should not get here if the global_namespace is not yet constructed
3061 nor if NAME designates the global namespace: The global scope is
3062 constructed elsewhere. */
3063 my_friendly_assert (global_namespace != NULL && name != global_scope_name,
3068 /* The name of anonymous namespace is unique for the translation
3070 if (!anonymous_namespace_name)
3071 anonymous_namespace_name = get_file_function_name ('N');
3072 name = anonymous_namespace_name;
3073 d = IDENTIFIER_NAMESPACE_VALUE (name);
3075 /* Reopening anonymous namespace. */
3081 /* Check whether this is an extended namespace definition. */
3082 d = IDENTIFIER_NAMESPACE_VALUE (name);
3083 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3086 if (DECL_NAMESPACE_ALIAS (d))
3088 error ("namespace alias `%D' not allowed here, assuming `%D'",
3089 d, DECL_NAMESPACE_ALIAS (d));
3090 d = DECL_NAMESPACE_ALIAS (d);
3097 /* Make a new namespace, binding the name to it. */
3098 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3099 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3103 /* Clear DECL_NAME for the benefit of debugging back ends. */
3104 SET_DECL_ASSEMBLER_NAME (d, name);
3105 DECL_NAME (d) = NULL_TREE;
3107 begin_scope (sk_namespace, d);
3110 resume_scope (NAMESPACE_LEVEL (d));
3113 do_using_directive (d);
3114 /* Enter the name space. */
3115 current_namespace = d;
3117 timevar_pop (TV_NAME_LOOKUP);
3120 /* Pop from the scope of the current namespace. */
3123 pop_namespace (void)
3125 my_friendly_assert (current_namespace != global_namespace, 20010801);
3126 current_namespace = CP_DECL_CONTEXT (current_namespace);
3127 /* The binding level is not popped, as it might be re-opened later. */
3131 /* Push into the scope of the namespace NS, even if it is deeply
3132 nested within another namespace. */
3135 push_nested_namespace (tree ns)
3137 if (ns == global_namespace)
3138 push_to_top_level ();
3141 push_nested_namespace (CP_DECL_CONTEXT (ns));
3142 push_namespace (DECL_NAME (ns));
3146 /* Pop back from the scope of the namespace NS, which was previously
3147 entered with push_nested_namespace. */
3150 pop_nested_namespace (tree ns)
3152 timevar_push (TV_NAME_LOOKUP);
3153 while (ns != global_namespace)
3156 ns = CP_DECL_CONTEXT (ns);
3159 pop_from_top_level ();
3160 timevar_pop (TV_NAME_LOOKUP);
3163 /* Temporarily set the namespace for the current declaration. */
3166 push_decl_namespace (tree decl)
3168 if (TREE_CODE (decl) != NAMESPACE_DECL)
3169 decl = decl_namespace_context (decl);
3170 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3171 NULL_TREE, decl_namespace_list);
3174 /* [namespace.memdef]/2 */
3177 pop_decl_namespace (void)
3179 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3182 /* Return the namespace that is the common ancestor
3183 of two given namespaces. */
3186 namespace_ancestor (tree ns1, tree ns2)
3188 timevar_push (TV_NAME_LOOKUP);
3189 if (is_ancestor (ns1, ns2))
3190 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3191 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3192 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3195 /* Process a namespace-alias declaration. */
3198 do_namespace_alias (tree alias, tree namespace)
3200 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3202 /* The parser did not find it, so it's not there. */
3203 error ("unknown namespace `%D'", namespace);
3207 namespace = ORIGINAL_NAMESPACE (namespace);
3209 /* Build the alias. */
3210 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3211 DECL_NAMESPACE_ALIAS (alias) = namespace;
3212 DECL_EXTERNAL (alias) = 1;
3213 DECL_CONTEXT (alias) = current_scope ();
3214 if (!DECL_CONTEXT (alias))
3215 DECL_CONTEXT (alias) = FROB_CONTEXT (current_namespace);
3219 /* Like pushdecl, only it places X in the current namespace,
3223 pushdecl_namespace_level (tree x)
3225 struct cp_binding_level *b = current_binding_level;
3228 timevar_push (TV_NAME_LOOKUP);
3229 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3231 /* Now, the type_shadowed stack may screw us. Munge it so it does
3233 if (TREE_CODE (x) == TYPE_DECL)
3235 tree name = DECL_NAME (x);
3237 tree *ptr = (tree *)0;
3238 for (; !global_scope_p (b); b = b->level_chain)
3240 tree shadowed = b->type_shadowed;
3241 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3242 if (TREE_PURPOSE (shadowed) == name)
3244 ptr = &TREE_VALUE (shadowed);
3245 /* Can't break out of the loop here because sometimes
3246 a binding level will have duplicate bindings for
3247 PT names. It's gross, but I haven't time to fix it. */
3250 newval = TREE_TYPE (x);
3251 if (ptr == (tree *)0)
3253 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3254 up here if this is changed to an assertion. --KR */
3255 SET_IDENTIFIER_TYPE_VALUE (name, x);
3262 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3265 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3266 directive is not directly from the source. Also find the common
3267 ancestor and let our users know about the new namespace */
3269 add_using_namespace (tree user, tree used, bool indirect)
3272 timevar_push (TV_NAME_LOOKUP);
3273 /* Using oneself is a no-op. */
3276 timevar_pop (TV_NAME_LOOKUP);
3279 my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3280 my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3281 /* Check if we already have this. */
3282 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3286 /* Promote to direct usage. */
3287 TREE_INDIRECT_USING (t) = 0;
3288 timevar_pop (TV_NAME_LOOKUP);
3292 /* Add used to the user's using list. */
3293 DECL_NAMESPACE_USING (user)
3294 = tree_cons (used, namespace_ancestor (user, used),
3295 DECL_NAMESPACE_USING (user));
3297 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3299 /* Add user to the used's users list. */
3300 DECL_NAMESPACE_USERS (used)
3301 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3303 /* Recursively add all namespaces used. */
3304 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3305 /* indirect usage */
3306 add_using_namespace (user, TREE_PURPOSE (t), 1);
3308 /* Tell everyone using us about the new used namespaces. */
3309 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3310 add_using_namespace (TREE_PURPOSE (t), used, 1);
3311 timevar_pop (TV_NAME_LOOKUP);
3314 /* Process a using-declaration not appearing in class or local scope. */
3317 do_toplevel_using_decl (tree decl, tree scope, tree name)
3319 tree oldval, oldtype, newval, newtype;
3320 cxx_binding *binding;
3322 decl = validate_nonmember_using_decl (decl, scope, name);
3323 if (decl == NULL_TREE)
3326 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3328 oldval = binding->value;
3329 oldtype = binding->type;
3331 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3333 /* Copy declarations found. */
3335 binding->value = newval;
3337 binding->type = newtype;
3341 /* Process a using-directive. */
3344 do_using_directive (tree namespace)
3346 if (building_stmt_tree ())
3347 add_stmt (build_stmt (USING_STMT, namespace));
3349 /* using namespace A::B::C; */
3350 if (TREE_CODE (namespace) == SCOPE_REF)
3351 namespace = TREE_OPERAND (namespace, 1);
3352 if (TREE_CODE (namespace) == IDENTIFIER_NODE)
3354 /* Lookup in lexer did not find a namespace. */
3355 if (!processing_template_decl)
3356 error ("namespace `%T' undeclared", namespace);
3359 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3361 if (!processing_template_decl)
3362 error ("`%T' is not a namespace", namespace);
3365 namespace = ORIGINAL_NAMESPACE (namespace);
3366 if (!toplevel_bindings_p ())
3367 push_using_directive (namespace);
3370 add_using_namespace (current_namespace, namespace, 0);
3373 /* Deal with a using-directive seen by the parser. Currently we only
3374 handle attributes here, since they cannot appear inside a template. */
3377 parse_using_directive (tree namespace, tree attribs)
3381 do_using_directive (namespace);
3383 for (a = attribs; a; a = TREE_CHAIN (a))
3385 tree name = TREE_PURPOSE (a);
3386 if (is_attribute_p ("strong", name))
3388 if (!toplevel_bindings_p ())
3389 error ("strong using only meaningful at namespace scope");
3390 else if (namespace != error_mark_node)
3391 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3392 = tree_cons (current_namespace, 0,
3393 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3396 warning ("`%D' attribute directive ignored", name);
3400 /* Like pushdecl, only it places X in the global scope if appropriate.
3401 Calls cp_finish_decl to register the variable, initializing it with
3402 *INIT, if INIT is non-NULL. */
3405 pushdecl_top_level_1 (tree x, tree *init)
3407 timevar_push (TV_NAME_LOOKUP);
3408 push_to_top_level ();
3409 x = pushdecl_namespace_level (x);
3411 cp_finish_decl (x, *init, NULL_TREE, 0);
3412 pop_from_top_level ();
3413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3416 /* Like pushdecl, only it places X in the global scope if appropriate. */
3419 pushdecl_top_level (tree x)
3421 return pushdecl_top_level_1 (x, NULL);
3424 /* Like pushdecl, only it places X in the global scope if
3425 appropriate. Calls cp_finish_decl to register the variable,
3426 initializing it with INIT. */
3429 pushdecl_top_level_and_finish (tree x, tree init)
3431 return pushdecl_top_level_1 (x, &init);
3434 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3435 duplicates. The first list becomes the tail of the result.
3437 The algorithm is O(n^2). We could get this down to O(n log n) by
3438 doing a sort on the addresses of the functions, if that becomes
3442 merge_functions (tree s1, tree s2)
3444 for (; s2; s2 = OVL_NEXT (s2))
3446 tree fn2 = OVL_CURRENT (s2);
3449 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3451 tree fn1 = OVL_CURRENT (fns1);
3453 /* If the function from S2 is already in S1, there is no
3454 need to add it again. For `extern "C"' functions, we
3455 might have two FUNCTION_DECLs for the same function, in
3456 different namespaces; again, we only need one of them. */
3458 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3459 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3463 /* If we exhausted all of the functions in S1, FN2 is new. */
3465 s1 = build_overload (fn2, s1);
3470 /* This should return an error not all definitions define functions.
3471 It is not an error if we find two functions with exactly the
3472 same signature, only if these are selected in overload resolution.
3473 old is the current set of bindings, new the freshly-found binding.
3474 XXX Do we want to give *all* candidates in case of ambiguity?
3475 XXX In what way should I treat extern declarations?
3476 XXX I don't want to repeat the entire duplicate_decls here */
3478 static cxx_binding *
3479 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3482 my_friendly_assert (old != NULL, 393);
3483 /* Copy the value. */
3486 switch (TREE_CODE (val))
3489 /* If we expect types or namespaces, and not templates,
3490 or this is not a template class. */
3491 if (LOOKUP_QUALIFIERS_ONLY (flags)
3492 && !DECL_CLASS_TEMPLATE_P (val))
3496 if (LOOKUP_NAMESPACES_ONLY (flags))
3499 case NAMESPACE_DECL:
3500 if (LOOKUP_TYPES_ONLY (flags))
3504 /* Ignore built-in functions that are still anticipated. */
3505 if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3509 if (LOOKUP_QUALIFIERS_ONLY (flags))
3515 else if (val && val != old->value)
3517 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3518 old->value = merge_functions (old->value, val);
3521 /* Some declarations are functions, some are not. */
3522 if (flags & LOOKUP_COMPLAIN)
3524 /* If we've already given this error for this lookup,
3525 old->value is error_mark_node, so let's not
3526 repeat ourselves. */
3527 if (old->value != error_mark_node)
3529 error ("use of `%D' is ambiguous", name);
3530 cp_error_at (" first declared as `%#D' here",
3533 cp_error_at (" also declared as `%#D' here", val);
3535 old->value = error_mark_node;
3538 /* ... and copy the type. */
3540 if (LOOKUP_NAMESPACES_ONLY (flags))
3544 else if (type && old->type != type)
3546 if (flags & LOOKUP_COMPLAIN)
3548 error ("`%D' denotes an ambiguous type",name);
3549 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3550 error ("%J other type here", TYPE_MAIN_DECL (type));
3556 /* Return the declarations that are members of the namespace NS. */
3559 cp_namespace_decls (tree ns)
3561 return NAMESPACE_LEVEL (ns)->names;
3564 /* Combine prefer_type and namespaces_only into flags. */
3567 lookup_flags (int prefer_type, int namespaces_only)
3569 if (namespaces_only)
3570 return LOOKUP_PREFER_NAMESPACES;
3571 if (prefer_type > 1)
3572 return LOOKUP_PREFER_TYPES;
3573 if (prefer_type > 0)
3574 return LOOKUP_PREFER_BOTH;
3578 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3579 ignore it or not. Subroutine of lookup_name_real. */
3582 qualify_lookup (tree val, int flags)
3584 if (val == NULL_TREE)
3586 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3588 if ((flags & LOOKUP_PREFER_TYPES)
3589 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3591 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3596 /* Look up NAME in the NAMESPACE. */
3599 lookup_namespace_name (tree namespace, tree name)
3602 tree template_id = NULL_TREE;
3603 cxx_binding binding;
3605 timevar_push (TV_NAME_LOOKUP);
3606 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
3608 if (TREE_CODE (name) == NAMESPACE_DECL)
3609 /* This happens for A::B<int> when B is a namespace. */
3610 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3611 else if (TREE_CODE (name) == TEMPLATE_DECL)
3613 /* This happens for A::B where B is a template, and there are no
3614 template arguments. */
3615 error ("invalid use of `%D'", name);
3616 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3619 namespace = ORIGINAL_NAMESPACE (namespace);
3621 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3624 name = TREE_OPERAND (name, 0);
3625 if (TREE_CODE (name) == OVERLOAD)
3626 name = DECL_NAME (OVL_CURRENT (name));
3627 else if (DECL_P (name))
3628 name = DECL_NAME (name);
3631 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
3633 cxx_binding_clear (&binding);
3634 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3635 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3639 val = binding.value;
3643 if (DECL_CLASS_TEMPLATE_P (val))
3644 val = lookup_template_class (val,
3645 TREE_OPERAND (template_id, 1),
3646 /*in_decl=*/NULL_TREE,
3647 /*context=*/NULL_TREE,
3648 /*entering_scope=*/0,
3649 tf_error | tf_warning);
3650 else if (DECL_FUNCTION_TEMPLATE_P (val)
3651 || TREE_CODE (val) == OVERLOAD)
3652 val = lookup_template_function (val,
3653 TREE_OPERAND (template_id, 1));
3656 error ("`%D::%D' is not a template",
3658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3662 /* If we have a single function from a using decl, pull it out. */
3663 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3664 val = OVL_FUNCTION (val);
3666 /* Ignore built-in functions that haven't been prototyped yet. */
3667 if (!val || !DECL_P(val)
3668 || !DECL_LANG_SPECIFIC(val)
3669 || !DECL_ANTICIPATED (val))
3670 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3673 error ("`%D' undeclared in namespace `%D'", name, namespace);
3674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3677 /* Select the right _DECL from multiple choices. */
3680 select_decl (cxx_binding *binding, int flags)
3683 val = binding->value;
3685 timevar_push (TV_NAME_LOOKUP);
3686 if (LOOKUP_NAMESPACES_ONLY (flags))
3688 /* We are not interested in types. */
3689 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3690 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3691 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3694 /* If looking for a type, or if there is no non-type binding, select
3695 the value binding. */
3696 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3697 val = binding->type;
3698 /* Don't return non-types if we really prefer types. */
3699 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
3700 && (TREE_CODE (val) != TEMPLATE_DECL
3701 || !DECL_CLASS_TEMPLATE_P (val)))
3704 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3707 /* Unscoped lookup of a global: iterate over current namespaces,
3708 considering using-directives. */
3711 unqualified_namespace_lookup (tree name, int flags)
3713 tree initial = current_decl_namespace ();
3714 tree scope = initial;
3716 struct cp_binding_level *level;
3717 tree val = NULL_TREE;
3718 cxx_binding binding;
3720 timevar_push (TV_NAME_LOOKUP);
3721 cxx_binding_clear (&binding);
3723 for (; !val; scope = CP_DECL_CONTEXT (scope))
3726 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3730 if (b->value && DECL_P (b->value)
3731 && DECL_LANG_SPECIFIC (b->value)
3732 && DECL_ANTICIPATED (b->value))
3733 /* Ignore anticipated built-in functions. */
3736 binding.value = b->value;
3737 binding.type = b->type;
3740 /* Add all _DECLs seen through local using-directives. */
3741 for (level = current_binding_level;
3742 level->kind != sk_namespace;
3743 level = level->level_chain)
3744 if (!lookup_using_namespace (name, &binding, level->using_directives,
3746 /* Give up because of error. */
3747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3749 /* Add all _DECLs seen through global using-directives. */
3750 /* XXX local and global using lists should work equally. */
3754 if (!lookup_using_namespace (name, &binding,
3755 DECL_NAMESPACE_USING (siter),
3757 /* Give up because of error. */
3758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3759 if (siter == scope) break;
3760 siter = CP_DECL_CONTEXT (siter);
3763 val = select_decl (&binding, flags);
3764 if (scope == global_namespace)
3767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3770 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3771 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3774 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3775 declaration found. If no suitable declaration can be found,
3776 ERROR_MARK_NODE is returned. Iif COMPLAIN is true and SCOPE is
3777 neither a class-type nor a namespace a diagnostic is issued. */
3780 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3784 if (TREE_CODE (scope) == NAMESPACE_DECL)
3786 cxx_binding binding;
3788 cxx_binding_clear (&binding);
3789 flags |= LOOKUP_COMPLAIN;
3791 flags |= LOOKUP_PREFER_TYPES;
3792 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3793 return select_decl (&binding, flags);
3795 else if (is_aggr_type (scope, complain))
3798 t = lookup_member (scope, name, 0, is_type_p);
3803 return error_mark_node;
3806 /* Subroutine of unqualified_namespace_lookup:
3807 Add the bindings of NAME in used namespaces to VAL.
3808 We are currently looking for names in namespace SCOPE, so we
3809 look through USINGS for using-directives of namespaces
3810 which have SCOPE as a common ancestor with the current scope.
3811 Returns false on errors. */
3814 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3818 timevar_push (TV_NAME_LOOKUP);
3819 /* Iterate over all used namespaces in current, searching for using
3820 directives of scope. */
3821 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3822 if (TREE_VALUE (iter) == scope)
3824 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3826 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3827 /* Resolve ambiguities. */
3829 val = ambiguous_decl (name, val, val1, flags);
3831 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3835 Accepts the NAME to lookup and its qualifying SCOPE.
3836 Returns the name/type pair found into the cxx_binding *RESULT,
3837 or false on error. */
3840 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3843 /* Maintain a list of namespaces visited... */
3844 tree seen = NULL_TREE;
3845 /* ... and a list of namespace yet to see. */
3846 tree todo = NULL_TREE;
3847 tree todo_maybe = NULL_TREE;
3849 timevar_push (TV_NAME_LOOKUP);
3850 /* Look through namespace aliases. */
3851 scope = ORIGINAL_NAMESPACE (scope);
3852 while (scope && result->value != error_mark_node)
3854 cxx_binding *binding =
3855 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3856 seen = tree_cons (scope, NULL_TREE, seen);
3858 result = ambiguous_decl (name, result, binding, flags);
3860 /* Consider strong using directives always, and non-strong ones
3861 if we haven't found a binding yet. ??? Shouldn't we consider
3862 non-strong ones if the initial RESULT is non-NULL, but the
3863 binding in the given namespace is? */
3864 for (usings = DECL_NAMESPACE_USING (scope); usings;
3865 usings = TREE_CHAIN (usings))
3866 /* If this was a real directive, and we have not seen it. */
3867 if (!TREE_INDIRECT_USING (usings))
3869 /* Try to avoid queuing the same namespace more than once,
3870 the exception being when a namespace was already
3871 enqueued for todo_maybe and then a strong using is
3872 found for it. We could try to remove it from
3873 todo_maybe, but it's probably not worth the effort. */
3874 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3875 && !purpose_member (TREE_PURPOSE (usings), seen)
3876 && !purpose_member (TREE_PURPOSE (usings), todo))
3877 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3878 else if ((!result->value && !result->type)
3879 && !purpose_member (TREE_PURPOSE (usings), seen)
3880 && !purpose_member (TREE_PURPOSE (usings), todo)
3881 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3882 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3887 scope = TREE_PURPOSE (todo);
3888 todo = TREE_CHAIN (todo);
3891 && (!result->value && !result->type))
3893 scope = TREE_PURPOSE (todo_maybe);
3894 todo = TREE_CHAIN (todo_maybe);
3895 todo_maybe = NULL_TREE;
3898 scope = NULL_TREE; /* If there never was a todo list. */
3900 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3903 /* Look up NAME in the current binding level and its superiors in the
3904 namespace of variables, functions and typedefs. Return a ..._DECL
3905 node of some kind representing its definition if there is only one
3906 such declaration, or return a TREE_LIST with all the overloaded
3907 definitions if there are many, or return 0 if it is undefined.
3909 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3910 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3911 Otherwise we prefer non-TYPE_DECLs.
3913 If NONCLASS is nonzero, we don't look for the NAME in class scope,
3914 using IDENTIFIER_CLASS_VALUE. */
3917 lookup_name_real (tree name, int prefer_type, int nonclass,
3918 int namespaces_only, int flags)
3921 tree val = NULL_TREE;
3923 timevar_push (TV_NAME_LOOKUP);
3924 /* Conversion operators are handled specially because ordinary
3925 unqualified name lookup will not find template conversion
3927 if (IDENTIFIER_TYPENAME_P (name))
3929 struct cp_binding_level *level;
3931 for (level = current_binding_level;
3932 level && level->kind != sk_namespace;
3933 level = level->level_chain)
3938 /* A conversion operator can only be declared in a class
3940 if (level->kind != sk_class)
3943 /* Lookup the conversion operator in the class. */
3944 class_type = level->this_entity;
3945 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3947 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3950 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3953 flags |= lookup_flags (prefer_type, namespaces_only);
3955 /* First, look in non-namespace scopes. */
3957 if (current_class_type == NULL_TREE)
3960 for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
3964 if (!LOCAL_BINDING_P (iter) && nonclass)
3965 /* We're not looking for class-scoped bindings, so keep going. */
3968 /* If this is the kind of thing we're looking for, we're done. */
3969 if (qualify_lookup (iter->value, flags))
3970 binding = iter->value;
3971 else if ((flags & LOOKUP_PREFER_TYPES)
3972 && qualify_lookup (iter->type, flags))
3973 binding = iter->type;
3975 binding = NULL_TREE;
3984 /* Now lookup in namespace scopes. */
3987 tree t = unqualified_namespace_lookup (name, flags);
3994 /* If we have a single function from a using decl, pull it out. */
3995 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3996 val = OVL_FUNCTION (val);
3999 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4003 lookup_name_nonclass (tree name)
4005 return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
4009 lookup_function_nonclass (tree name, tree args)
4011 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
4015 lookup_name (tree name, int prefer_type)
4017 return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
4020 /* Similar to `lookup_name' but look only in the innermost non-class
4024 lookup_name_current_level (tree name)
4026 struct cp_binding_level *b;
4029 timevar_push (TV_NAME_LOOKUP);
4030 b = innermost_nonclass_level ();
4032 if (b->kind == sk_namespace)
4034 t = IDENTIFIER_NAMESPACE_VALUE (name);
4036 /* extern "C" function() */
4037 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4040 else if (IDENTIFIER_BINDING (name)
4041 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4045 if (IDENTIFIER_BINDING (name)->scope == b)
4046 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
4048 if (b->kind == sk_cleanup)
4055 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4058 /* Like lookup_name_current_level, but for types. */
4061 lookup_type_current_level (tree name)
4065 timevar_push (TV_NAME_LOOKUP);
4066 my_friendly_assert (current_binding_level->kind != sk_namespace,
4069 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4070 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4072 struct cp_binding_level *b = current_binding_level;
4075 if (purpose_member (name, b->type_shadowed))
4076 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4077 REAL_IDENTIFIER_TYPE_VALUE (name));
4078 if (b->kind == sk_cleanup)
4085 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4088 /* [basic.lookup.koenig] */
4089 /* A nonzero return value in the functions below indicates an error. */
4099 static bool arg_assoc (struct arg_lookup*, tree);
4100 static bool arg_assoc_args (struct arg_lookup*, tree);
4101 static bool arg_assoc_type (struct arg_lookup*, tree);
4102 static bool add_function (struct arg_lookup *, tree);
4103 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4104 static bool arg_assoc_class (struct arg_lookup *, tree);
4105 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4107 /* Add a function to the lookup structure.
4108 Returns true on error. */
4111 add_function (struct arg_lookup *k, tree fn)
4113 /* We used to check here to see if the function was already in the list,
4114 but that's O(n^2), which is just too expensive for function lookup.
4115 Now we deal with the occasional duplicate in joust. In doing this, we
4116 assume that the number of duplicates will be small compared to the
4117 total number of functions being compared, which should usually be the
4120 /* We must find only functions, or exactly one non-function. */
4123 else if (fn == k->functions)
4125 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4126 k->functions = build_overload (fn, k->functions);
4129 tree f1 = OVL_CURRENT (k->functions);
4131 if (is_overloaded_fn (f1))
4133 fn = f1; f1 = f2; f2 = fn;
4135 cp_error_at ("`%D' is not a function,", f1);
4136 cp_error_at (" conflict with `%D'", f2);
4137 error (" in call to `%D'", k->name);
4144 /* Returns true iff CURRENT has declared itself to be an associated
4145 namespace of SCOPE via a strong using-directive (or transitive chain
4146 thereof). Both are namespaces. */
4149 is_associated_namespace (tree current, tree scope)
4151 tree seen = NULL_TREE;
4152 tree todo = NULL_TREE;
4156 if (scope == current)
4158 seen = tree_cons (scope, NULL_TREE, seen);
4159 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4160 if (!purpose_member (TREE_PURPOSE (t), seen))
4161 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4164 scope = TREE_PURPOSE (todo);
4165 todo = TREE_CHAIN (todo);
4172 /* Add functions of a namespace to the lookup structure.
4173 Returns true on error. */
4176 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4180 if (purpose_member (scope, k->namespaces))
4182 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4184 /* Check out our super-users. */
4185 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4186 value = TREE_CHAIN (value))
4187 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4190 value = namespace_binding (k->name, scope);
4194 for (; value; value = OVL_NEXT (value))
4195 if (add_function (k, OVL_CURRENT (value)))
4201 /* Adds everything associated with a template argument to the lookup
4202 structure. Returns true on error. */
4205 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4207 /* [basic.lookup.koenig]
4209 If T is a template-id, its associated namespaces and classes are
4210 ... the namespaces and classes associated with the types of the
4211 template arguments provided for template type parameters
4212 (excluding template template parameters); the namespaces in which
4213 any template template arguments are defined; and the classes in
4214 which any member templates used as template template arguments
4215 are defined. [Note: non-type template arguments do not
4216 contribute to the set of associated namespaces. ] */
4218 /* Consider first template template arguments. */
4219 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4220 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4222 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4224 tree ctx = CP_DECL_CONTEXT (arg);
4226 /* It's not a member template. */
4227 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4228 return arg_assoc_namespace (k, ctx);
4229 /* Otherwise, it must be member template. */
4231 return arg_assoc_class (k, ctx);
4233 /* It's not a template template argument, but it is a type template
4235 else if (TYPE_P (arg))
4236 return arg_assoc_type (k, arg);
4237 /* It's a non-type template argument. */
4242 /* Adds everything associated with class to the lookup structure.
4243 Returns true on error. */
4246 arg_assoc_class (struct arg_lookup *k, tree type)
4248 tree list, friends, context;
4251 /* Backend build structures, such as __builtin_va_list, aren't
4252 affected by all this. */
4253 if (!CLASS_TYPE_P (type))
4256 if (purpose_member (type, k->classes))
4258 k->classes = tree_cons (type, NULL_TREE, k->classes);
4260 context = decl_namespace_context (type);
4261 if (arg_assoc_namespace (k, context))
4264 /* Process baseclasses. */
4265 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4266 if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4269 /* Process friends. */
4270 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4271 list = TREE_CHAIN (list))
4272 if (k->name == FRIEND_NAME (list))
4273 for (friends = FRIEND_DECLS (list); friends;
4274 friends = TREE_CHAIN (friends))
4276 tree fn = TREE_VALUE (friends);
4278 /* Only interested in global functions with potentially hidden
4279 (i.e. unqualified) declarations. */
4280 if (CP_DECL_CONTEXT (fn) != context)
4282 /* Template specializations are never found by name lookup.
4283 (Templates themselves can be found, but not template
4284 specializations.) */
4285 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4287 if (add_function (k, fn))
4291 /* Process template arguments. */
4292 if (CLASSTYPE_TEMPLATE_INFO (type))
4294 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4295 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4296 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4302 /* Adds everything associated with a given type.
4303 Returns 1 on error. */
4306 arg_assoc_type (struct arg_lookup *k, tree type)
4308 /* As we do not get the type of non-type dependent expressions
4309 right, we can end up with such things without a type. */
4313 if (TYPE_PTRMEM_P (type))
4315 /* Pointer to member: associate class type and value type. */
4316 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4318 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4320 else switch (TREE_CODE (type))
4333 if (TYPE_PTRMEMFUNC_P (type))
4334 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4335 return arg_assoc_class (k, type);
4337 case REFERENCE_TYPE:
4339 return arg_assoc_type (k, TREE_TYPE (type));
4342 return arg_assoc_namespace (k, decl_namespace_context (type));
4344 /* The basetype is referenced in the first arg type, so just
4347 /* Associate the parameter types. */
4348 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4350 /* Associate the return type. */
4351 return arg_assoc_type (k, TREE_TYPE (type));
4352 case TEMPLATE_TYPE_PARM:
4353 case BOUND_TEMPLATE_TEMPLATE_PARM:
4358 if (type == unknown_type_node)
4360 /* else fall through */
4367 /* Adds everything associated with arguments. Returns true on error. */
4370 arg_assoc_args (struct arg_lookup *k, tree args)
4372 for (; args; args = TREE_CHAIN (args))
4373 if (arg_assoc (k, TREE_VALUE (args)))
4378 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4381 arg_assoc (struct arg_lookup *k, tree n)
4383 if (n == error_mark_node)
4387 return arg_assoc_type (k, n);
4389 if (! type_unknown_p (n))
4390 return arg_assoc_type (k, TREE_TYPE (n));
4392 if (TREE_CODE (n) == ADDR_EXPR)
4393 n = TREE_OPERAND (n, 0);
4394 if (TREE_CODE (n) == COMPONENT_REF)
4395 n = TREE_OPERAND (n, 1);
4396 if (TREE_CODE (n) == OFFSET_REF)
4397 n = TREE_OPERAND (n, 1);
4398 while (TREE_CODE (n) == TREE_LIST)
4400 if (TREE_CODE (n) == BASELINK)
4401 n = BASELINK_FUNCTIONS (n);
4403 if (TREE_CODE (n) == FUNCTION_DECL)
4404 return arg_assoc_type (k, TREE_TYPE (n));
4405 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4407 /* [basic.lookup.koenig]
4409 If T is a template-id, its associated namespaces and classes
4410 are the namespace in which the template is defined; for
4411 member templates, the member template's class... */
4412 tree template = TREE_OPERAND (n, 0);
4413 tree args = TREE_OPERAND (n, 1);
4417 if (TREE_CODE (template) == COMPONENT_REF)
4418 template = TREE_OPERAND (template, 1);
4420 /* First, the template. There may actually be more than one if
4421 this is an overloaded function template. But, in that case,
4422 we only need the first; all the functions will be in the same
4424 template = OVL_CURRENT (template);
4426 ctx = CP_DECL_CONTEXT (template);
4428 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4430 if (arg_assoc_namespace (k, ctx) == 1)
4433 /* It must be a member template. */
4434 else if (arg_assoc_class (k, ctx) == 1)
4437 /* Now the arguments. */
4438 for (ix = TREE_VEC_LENGTH (args); ix--;)
4439 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4442 else if (TREE_CODE (n) == OVERLOAD)
4444 for (; n; n = OVL_CHAIN (n))
4445 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4452 /* Performs Koenig lookup depending on arguments, where fns
4453 are the functions found in normal lookup. */
4456 lookup_arg_dependent (tree name, tree fns, tree args)
4458 struct arg_lookup k;
4459 tree fn = NULL_TREE;
4461 timevar_push (TV_NAME_LOOKUP);
4464 k.classes = NULL_TREE;
4466 /* We've already looked at some namespaces during normal unqualified
4467 lookup -- but we don't know exactly which ones. If the functions
4468 we found were brought into the current namespace via a using
4469 declaration, we have not really checked the namespace from which
4470 they came. Therefore, we check all namespaces here -- unless the
4471 function we have is from the current namespace. Even then, we
4472 must check all namespaces if the function is a local
4473 declaration; any other declarations present at namespace scope
4474 should be visible during argument-dependent lookup. */
4476 fn = OVL_CURRENT (fns);
4477 if (fn && TREE_CODE (fn) == FUNCTION_DECL
4478 && (CP_DECL_CONTEXT (fn) != current_decl_namespace ()
4479 || DECL_LOCAL_FUNCTION_P (fn)))
4480 k.namespaces = NULL_TREE;
4482 /* Setting NAMESPACES is purely an optimization; it prevents
4483 adding functions which are already in FNS. Adding them would
4484 be safe -- "joust" will eliminate the duplicates -- but
4486 k.namespaces = build_tree_list (current_decl_namespace (), NULL_TREE);
4488 arg_assoc_args (&k, args);
4489 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4492 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4493 changed (i.e. there was already a directive), or the fresh
4494 TREE_LIST otherwise. */
4497 push_using_directive (tree used)
4499 tree ud = current_binding_level->using_directives;
4500 tree iter, ancestor;
4502 timevar_push (TV_NAME_LOOKUP);
4503 /* Check if we already have this. */
4504 if (purpose_member (used, ud) != NULL_TREE)
4505 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4507 ancestor = namespace_ancestor (current_decl_namespace (), used);
4508 ud = current_binding_level->using_directives;
4509 ud = tree_cons (used, ancestor, ud);
4510 current_binding_level->using_directives = ud;
4512 /* Recursively add all namespaces used. */
4513 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4514 push_using_directive (TREE_PURPOSE (iter));
4516 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4519 /* The type TYPE is being declared. If it is a class template, or a
4520 specialization of a class template, do any processing required and
4521 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4522 being declared a friend. B is the binding level at which this TYPE
4525 Returns the TYPE_DECL for TYPE, which may have been altered by this
4529 maybe_process_template_type_declaration (tree type, int globalize,
4532 tree decl = TYPE_NAME (type);
4534 if (processing_template_parmlist)
4535 /* You can't declare a new template type in a template parameter
4536 list. But, you can declare a non-template type:
4538 template <class A*> struct S;
4540 is a forward-declaration of `A'. */
4544 maybe_check_template_type (type);
4546 my_friendly_assert (IS_AGGR_TYPE (type)
4547 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
4550 if (processing_template_decl)
4552 /* This may change after the call to
4553 push_template_decl_real, but we want the original value. */
4554 tree name = DECL_NAME (decl);
4556 decl = push_template_decl_real (decl, globalize);
4557 /* If the current binding level is the binding level for the
4558 template parameters (see the comment in
4559 begin_template_parm_list) and the enclosing level is a class
4560 scope, and we're not looking at a friend, push the
4561 declaration of the member class into the class scope. In the
4562 friend case, push_template_decl will already have put the
4563 friend into global scope, if appropriate. */
4564 if (TREE_CODE (type) != ENUMERAL_TYPE
4565 && !globalize && b->kind == sk_template_parms
4566 && b->level_chain->kind == sk_class)
4568 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4569 /* Put this UDT in the table of UDTs for the class, since
4570 that won't happen below because B is not the class
4571 binding level, but is instead the pseudo-global level. */
4572 if (b->level_chain->type_decls == NULL)
4573 b->level_chain->type_decls =
4574 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4575 binding_table_insert (b->level_chain->type_decls, name, type);
4576 if (!COMPLETE_TYPE_P (current_class_type))
4578 maybe_add_class_template_decl_list (current_class_type,
4579 type, /*friend_p=*/0);
4580 CLASSTYPE_NESTED_UTDS (current_class_type) =
4581 b->level_chain->type_decls;
4590 /* Push a tag name NAME for struct/class/union/enum type TYPE.
4591 Normally put it into the inner-most non-sk_cleanup scope,
4592 but if GLOBALIZE is true, put it in the inner-most non-class scope.
4593 The latter is needed for implicit declarations. */
4596 pushtag (tree name, tree type, int globalize)
4598 struct cp_binding_level *b;
4600 timevar_push (TV_NAME_LOOKUP);
4601 b = current_binding_level;
4602 while (/* Cleanup scopes are not scopes from the point of view of
4604 b->kind == sk_cleanup
4605 /* Neither are the scopes used to hold template parameters
4606 for an explicit specialization. For an ordinary template
4607 declaration, these scopes are not scopes from the point of
4608 view of the language -- but we need a place to stash
4609 things that will go in the containing namespace when the
4610 template is instantiated. */
4611 || (b->kind == sk_template_parms && b->explicit_spec_p)
4612 || (b->kind == sk_class
4614 /* We may be defining a new type in the initializer
4615 of a static member variable. We allow this when
4616 not pedantic, and it is particularly useful for
4617 type punning via an anonymous union. */
4618 || COMPLETE_TYPE_P (b->this_entity))))
4621 if (b->type_decls == NULL)
4622 b->type_decls = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4623 binding_table_insert (b->type_decls, name, type);
4627 /* Do C++ gratuitous typedefing. */
4628 if (IDENTIFIER_TYPE_VALUE (name) != type)
4632 tree context = TYPE_CONTEXT (type);
4636 tree cs = current_scope ();
4640 else if (cs != NULL_TREE && TYPE_P (cs))
4641 /* When declaring a friend class of a local class, we want
4642 to inject the newly named class into the scope
4643 containing the local class, not the namespace scope. */
4644 context = decl_function_context (get_type_decl (cs));
4647 context = current_namespace;
4649 if (b->kind == sk_class
4650 || (b->kind == sk_template_parms
4651 && b->level_chain->kind == sk_class))
4654 if (current_lang_name == lang_name_java)
4655 TYPE_FOR_JAVA (type) = 1;
4657 d = create_implicit_typedef (name, type);
4658 DECL_CONTEXT (d) = FROB_CONTEXT (context);
4660 set_identifier_type_value_with_scope (name, d, b);
4662 d = maybe_process_template_type_declaration (type,
4665 if (b->kind == sk_class)
4667 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4668 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4669 class. But if it's a member template class, we
4670 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4672 finish_member_declaration (d);
4674 pushdecl_class_level (d);
4677 d = pushdecl_with_scope (d, b);
4679 /* FIXME what if it gets a name from typedef? */
4680 if (ANON_AGGRNAME_P (name))
4681 DECL_IGNORED_P (d) = 1;
4683 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
4685 /* If this is a local class, keep track of it. We need this
4686 information for name-mangling, and so that it is possible to find
4687 all function definitions in a translation unit in a convenient
4688 way. (It's otherwise tricky to find a member function definition
4689 it's only pointed to from within a local class.) */
4690 if (TYPE_CONTEXT (type)
4691 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
4692 && !processing_template_decl)
4693 VARRAY_PUSH_TREE (local_classes, type);
4695 if (b->kind == sk_class
4696 && !COMPLETE_TYPE_P (current_class_type))
4698 maybe_add_class_template_decl_list (current_class_type,
4699 type, /*friend_p=*/0);
4700 CLASSTYPE_NESTED_UTDS (current_class_type) = b->type_decls;
4704 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
4705 /* Use the canonical TYPE_DECL for this node. */
4706 TYPE_STUB_DECL (type) = TYPE_NAME (type);
4709 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4710 will be the tagged type we just added to the current
4711 binding level. This fake NULL-named TYPE_DECL node helps
4712 dwarfout.c to know when it needs to output a
4713 representation of a tagged type, and it also gives us a
4714 convenient place to record the "scope start" address for
4717 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
4718 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
4720 timevar_pop (TV_NAME_LOOKUP);
4723 /* Allocate storage for saving a C++ binding. */
4724 #define cxx_saved_binding_make() \
4725 (ggc_alloc (sizeof (cxx_saved_binding)))
4727 struct cxx_saved_binding GTY(())
4729 /* Link that chains saved C++ bindings for a given name into a stack. */
4730 cxx_saved_binding *previous;
4731 /* The name of the current binding. */
4733 /* The binding we're saving. */
4734 cxx_binding *binding;
4736 tree real_type_value;
4739 /* Subroutines for reverting temporarily to top-level for instantiation
4740 of templates and such. We actually need to clear out the class- and
4741 local-value slots of all identifiers, so that only the global values
4742 are at all visible. Simply setting current_binding_level to the global
4743 scope isn't enough, because more binding levels may be pushed. */
4744 struct saved_scope *scope_chain;
4746 static cxx_saved_binding *
4747 store_bindings (tree names, cxx_saved_binding *old_bindings)
4750 cxx_saved_binding *search_bindings = old_bindings;
4752 timevar_push (TV_NAME_LOOKUP);
4753 for (t = names; t; t = TREE_CHAIN (t))
4756 cxx_saved_binding *saved;
4757 cxx_saved_binding *t1;
4759 if (TREE_CODE (t) == TREE_LIST)
4760 id = TREE_PURPOSE (t);
4765 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
4766 we have no IDENTIFIER_BINDING if we have left the class
4767 scope, but cached the class-level declarations. */
4768 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
4771 for (t1 = search_bindings; t1; t1 = t1->previous)
4772 if (t1->identifier == id)
4775 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
4776 saved = cxx_saved_binding_make ();
4777 saved->previous = old_bindings;
4778 saved->identifier = id;
4779 saved->binding = IDENTIFIER_BINDING (id);
4780 saved->class_value = IDENTIFIER_CLASS_VALUE (id);;
4781 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4782 IDENTIFIER_BINDING (id) = NULL;
4783 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
4784 old_bindings = saved;
4788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
4792 push_to_top_level (void)
4794 struct saved_scope *s;
4795 struct cp_binding_level *b;
4796 cxx_saved_binding *old_bindings;
4799 timevar_push (TV_NAME_LOOKUP);
4800 s = ggc_alloc_cleared (sizeof (struct saved_scope));
4802 b = scope_chain ? current_binding_level : 0;
4804 /* If we're in the middle of some function, save our state. */
4808 push_function_context_to (NULL_TREE);
4813 old_bindings = NULL;
4814 if (scope_chain && previous_class_type)
4815 old_bindings = store_bindings (previous_class_values, old_bindings);
4817 /* Have to include the global scope, because class-scope decls
4818 aren't listed anywhere useful. */
4819 for (; b; b = b->level_chain)
4823 /* Template IDs are inserted into the global level. If they were
4824 inserted into namespace level, finish_file wouldn't find them
4825 when doing pending instantiations. Therefore, don't stop at
4826 namespace level, but continue until :: . */
4827 if (global_scope_p (b))
4830 old_bindings = store_bindings (b->names, old_bindings);
4831 /* We also need to check class_shadowed to save class-level type
4832 bindings, since pushclass doesn't fill in b->names. */
4833 if (b->kind == sk_class)
4834 old_bindings = store_bindings (b->class_shadowed, old_bindings);
4836 /* Unwind type-value slots back to top level. */
4837 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4838 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4840 s->prev = scope_chain;
4841 s->old_bindings = old_bindings;
4843 s->need_pop_function_context = need_pop;
4844 s->function_decl = current_function_decl;
4847 current_function_decl = NULL_TREE;
4848 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
4849 current_lang_name = lang_name_cplusplus;
4850 current_namespace = global_namespace;
4851 timevar_pop (TV_NAME_LOOKUP);
4855 pop_from_top_level (void)
4857 struct saved_scope *s = scope_chain;
4858 cxx_saved_binding *saved;
4860 timevar_push (TV_NAME_LOOKUP);
4861 /* Clear out class-level bindings cache. */
4862 if (previous_class_type)
4863 invalidate_class_lookup_cache ();
4865 current_lang_base = 0;
4867 scope_chain = s->prev;
4868 for (saved = s->old_bindings; saved; saved = saved->previous)
4870 tree id = saved->identifier;
4872 IDENTIFIER_BINDING (id) = saved->binding;
4873 IDENTIFIER_CLASS_VALUE (id) = saved->class_value;
4874 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
4877 /* If we were in the middle of compiling a function, restore our
4879 if (s->need_pop_function_context)
4880 pop_function_context_from (NULL_TREE);
4881 current_function_decl = s->function_decl;
4882 timevar_pop (TV_NAME_LOOKUP);
4885 /* Pop off extraneous binding levels left over due to syntax errors.
4887 We don't pop past namespaces, as they might be valid. */
4890 pop_everything (void)
4892 if (ENABLE_SCOPE_CHECKING)
4893 verbatim ("XXX entering pop_everything ()\n");
4894 while (!toplevel_bindings_p ())
4896 if (current_binding_level->kind == sk_class)
4897 pop_nested_class ();
4901 if (ENABLE_SCOPE_CHECKING)
4902 verbatim ("XXX leaving pop_everything ()\n");
4905 #include "gt-cp-name-lookup.h"