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 || bval == error_mark_node)
443 /* VALUE is null when push_class_level_binding moves an inherited
444 type-binding out of the way to make room for a new value binding.
445 It is an error_mark_node when DECL's name has been used in a
446 non-class scope prior declaration. In that case, we should have
447 already issued a diagnostic; for graceful error recovery purpose,
448 pretend this was the intended declaration for that name. */
449 binding->value = decl;
450 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
452 /* The old binding was a type name. It was placed in
453 VALUE field because it was thought, at the point it was
454 declared, to be the only entity with such a name. Move the
455 type name into the type slot; it is now hidden by the new
457 binding->type = bval;
458 binding->value = decl;
459 binding->value_is_inherited = false;
461 else if (TREE_CODE (bval) == TYPE_DECL
462 && TREE_CODE (decl) == TYPE_DECL
463 && DECL_NAME (decl) == DECL_NAME (bval)
464 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
465 /* If either type involves template parameters, we must
466 wait until instantiation. */
467 || uses_template_parms (TREE_TYPE (decl))
468 || uses_template_parms (TREE_TYPE (bval))))
469 /* We have two typedef-names, both naming the same type to have
470 the same name. This is OK because of:
474 In a given scope, a typedef specifier can be used to redefine
475 the name of any type declared in that scope to refer to the
476 type to which it already refers. */
478 /* There can be two block-scope declarations of the same variable,
479 so long as they are `extern' declarations. However, there cannot
480 be two declarations of the same static data member:
484 A member shall not be declared twice in the
485 member-specification. */
486 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
487 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
488 && !DECL_CLASS_SCOPE_P (decl))
490 duplicate_decls (decl, binding->value);
495 error ("declaration of `%#D'", decl);
496 cp_error_at ("conflicts with previous declaration `%#D'",
501 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
504 /* Add DECL to the list of things declared in B. */
507 add_decl_to_level (tree decl, cxx_scope *b)
509 if (TREE_CODE (decl) == NAMESPACE_DECL
510 && !DECL_NAMESPACE_ALIAS (decl))
512 TREE_CHAIN (decl) = b->namespaces;
513 b->namespaces = decl;
515 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
517 TREE_CHAIN (decl) = b->vtables;
522 /* We build up the list in reverse order, and reverse it later if
524 TREE_CHAIN (decl) = b->names;
528 /* If appropriate, add decl to separate list of statics. */
529 if (b->kind == sk_namespace)
530 if ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
531 || (TREE_CODE (decl) == FUNCTION_DECL
532 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
533 VARRAY_PUSH_TREE (b->static_decls, decl);
537 /* Record a decl-node X as belonging to the current lexical scope.
538 Check for errors (such as an incompatible declaration for the same
539 name already seen in the same scope).
541 Returns either X or an old decl for the same name.
542 If an old decl is returned, it may have been smashed
543 to agree with what X says. */
550 int need_new_binding;
552 timevar_push (TV_NAME_LOOKUP);
554 need_new_binding = 1;
556 if (DECL_TEMPLATE_PARM_P (x))
557 /* Template parameters have no context; they are not X::T even
558 when declared within a class or namespace. */
562 if (current_function_decl && x != current_function_decl
563 /* A local declaration for a function doesn't constitute
565 && TREE_CODE (x) != FUNCTION_DECL
566 /* A local declaration for an `extern' variable is in the
567 scope of the current namespace, not the current
569 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
570 && !DECL_CONTEXT (x))
571 DECL_CONTEXT (x) = current_function_decl;
573 /* If this is the declaration for a namespace-scope function,
574 but the declaration itself is in a local scope, mark the
576 if (TREE_CODE (x) == FUNCTION_DECL
577 && DECL_NAMESPACE_SCOPE_P (x)
578 && current_function_decl
579 && x != current_function_decl)
580 DECL_LOCAL_FUNCTION_P (x) = 1;
583 name = DECL_NAME (x);
586 int different_binding_level = 0;
588 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
589 name = TREE_OPERAND (name, 0);
591 /* In case this decl was explicitly namespace-qualified, look it
592 up in its namespace context. */
593 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
594 t = namespace_binding (name, DECL_CONTEXT (x));
596 t = lookup_name_current_level (name);
598 /* [basic.link] If there is a visible declaration of an entity
599 with linkage having the same name and type, ignoring entities
600 declared outside the innermost enclosing namespace scope, the
601 block scope declaration declares that same entity and
602 receives the linkage of the previous declaration. */
603 if (! t && current_function_decl && x != current_function_decl
604 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
605 && DECL_EXTERNAL (x))
607 /* Look in block scope. */
608 t = IDENTIFIER_VALUE (name);
609 /* Or in the innermost namespace. */
611 t = namespace_binding (name, DECL_CONTEXT (x));
612 /* Does it have linkage? Note that if this isn't a DECL, it's an
613 OVERLOAD, which is OK. */
614 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
617 different_binding_level = 1;
620 /* If we are declaring a function, and the result of name-lookup
621 was an OVERLOAD, look for an overloaded instance that is
622 actually the same as the function we are declaring. (If
623 there is one, we have to merge our declaration with the
624 previous declaration.) */
625 if (t && TREE_CODE (t) == OVERLOAD)
629 if (TREE_CODE (x) == FUNCTION_DECL)
630 for (match = t; match; match = OVL_NEXT (match))
632 if (decls_match (OVL_CURRENT (match), x))
636 /* Just choose one. */
640 t = OVL_CURRENT (match);
645 if (t == error_mark_node)
647 /* error_mark_node is 0 for a while during initialization! */
649 cp_error_at ("`%#D' used prior to declaration", x);
651 else if (t != NULL_TREE)
653 if (different_binding_level)
655 if (decls_match (x, t))
656 /* The standard only says that the local extern
657 inherits linkage from the previous decl; in
658 particular, default args are not shared. It would
659 be nice to propagate inlining info, though. FIXME. */
660 TREE_PUBLIC (x) = TREE_PUBLIC (t);
662 else if (TREE_CODE (t) == PARM_DECL)
664 if (DECL_CONTEXT (t) == NULL_TREE)
665 /* This is probably caused by too many errors, but calling
666 abort will say that if errors have occurred. */
669 /* Check for duplicate params. */
670 if (duplicate_decls (x, t))
671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
673 else if ((DECL_EXTERN_C_FUNCTION_P (x)
674 || DECL_FUNCTION_TEMPLATE_P (x))
675 && is_overloaded_fn (t))
676 /* Don't do anything just yet. */;
677 else if (t == wchar_decl_node)
679 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
680 pedwarn ("redeclaration of `wchar_t' as `%T'",
683 /* Throw away the redeclaration. */
684 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
688 tree olddecl = duplicate_decls (x, t);
690 /* If the redeclaration failed, we can stop at this
692 if (olddecl == error_mark_node)
693 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
697 if (TREE_CODE (t) == TYPE_DECL)
698 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
699 else if (TREE_CODE (t) == FUNCTION_DECL)
700 check_default_args (t);
702 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
704 else if (DECL_MAIN_P (x))
706 /* A redeclaration of main, but not a duplicate of the
711 This function shall not be overloaded. */
712 cp_error_at ("invalid redeclaration of `%D'", t);
713 error ("as `%D'", x);
714 /* We don't try to push this declaration since that
716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
721 check_template_shadow (x);
723 /* If this is a function conjured up by the backend, massage it
724 so it looks friendly. */
725 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
727 retrofit_lang_decl (x);
728 SET_DECL_LANGUAGE (x, lang_c);
731 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
733 t = push_overloaded_decl (x, PUSH_LOCAL);
735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
736 if (!namespace_bindings_p ())
737 /* We do not need to create a binding for this name;
738 push_overloaded_decl will have already done so if
740 need_new_binding = 0;
742 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
744 t = push_overloaded_decl (x, PUSH_GLOBAL);
746 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
750 /* If declaring a type as a typedef, copy the type (unless we're
751 at line 0), and install this TYPE_DECL as the new type's typedef
752 name. See the extensive comment in ../c-decl.c (pushdecl). */
753 if (TREE_CODE (x) == TYPE_DECL)
755 tree type = TREE_TYPE (x);
756 if (DECL_SOURCE_LINE (x) == 0)
758 if (TYPE_NAME (type) == 0)
759 TYPE_NAME (type) = x;
761 else if (type != error_mark_node && TYPE_NAME (type) != x
762 /* We don't want to copy the type when all we're
763 doing is making a TYPE_DECL for the purposes of
765 && (!TYPE_NAME (type)
766 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
768 DECL_ORIGINAL_TYPE (x) = type;
769 type = build_type_copy (type);
770 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
771 TYPE_NAME (type) = x;
772 TREE_TYPE (x) = type;
775 if (type != error_mark_node
777 && TYPE_IDENTIFIER (type))
778 set_identifier_type_value (DECL_NAME (x), x);
781 /* Multiple external decls of the same identifier ought to match.
783 We get warnings about inline functions where they are defined.
784 We get warnings about other functions from push_overloaded_decl.
786 Avoid duplicate warnings where they are used. */
787 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
791 decl = IDENTIFIER_NAMESPACE_VALUE (name);
792 if (decl && TREE_CODE (decl) == OVERLOAD)
793 decl = OVL_FUNCTION (decl);
795 if (decl && decl != error_mark_node
796 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
797 /* If different sort of thing, we already gave an error. */
798 && TREE_CODE (decl) == TREE_CODE (x)
799 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
801 pedwarn ("type mismatch with previous external decl of `%#D'", x);
802 cp_pedwarn_at ("previous external decl of `%#D'", decl);
806 /* This name is new in its binding level.
807 Install the new declaration and return it. */
808 if (namespace_bindings_p ())
810 /* Install a global value. */
812 /* If the first global decl has external linkage,
813 warn if we later see static one. */
814 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
815 TREE_PUBLIC (name) = 1;
817 /* Bind the name for the entity. */
818 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
820 && (TREE_CODE (x) == TYPE_DECL
821 || TREE_CODE (x) == VAR_DECL
822 || TREE_CODE (x) == ALIAS_DECL
823 || TREE_CODE (x) == NAMESPACE_DECL
824 || TREE_CODE (x) == CONST_DECL
825 || TREE_CODE (x) == TEMPLATE_DECL))
826 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
828 /* Don't forget if the function was used via an implicit decl. */
829 if (IDENTIFIER_IMPLICIT_DECL (name)
830 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
833 /* Don't forget if its address was taken in that way. */
834 if (IDENTIFIER_IMPLICIT_DECL (name)
835 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
836 TREE_ADDRESSABLE (x) = 1;
838 /* Warn about mismatches against previous implicit decl. */
839 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
840 /* If this real decl matches the implicit, don't complain. */
841 && ! (TREE_CODE (x) == FUNCTION_DECL
842 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
844 ("`%D' was previously implicitly declared to return `int'", x);
846 /* If new decl is `static' and an `extern' was seen previously,
848 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
849 warn_extern_redeclared_static (x, t);
853 /* Here to install a non-global value. */
854 tree oldlocal = IDENTIFIER_VALUE (name);
855 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
857 if (need_new_binding)
859 push_local_binding (name, x, 0);
860 /* Because push_local_binding will hook X on to the
861 current_binding_level's name list, we don't want to
862 do that again below. */
863 need_new_binding = 0;
866 /* If this is a TYPE_DECL, push it into the type value slot. */
867 if (TREE_CODE (x) == TYPE_DECL)
868 set_identifier_type_value (name, x);
870 /* Clear out any TYPE_DECL shadowed by a namespace so that
871 we won't think this is a type. The C struct hack doesn't
872 go through namespaces. */
873 if (TREE_CODE (x) == NAMESPACE_DECL)
874 set_identifier_type_value (name, NULL_TREE);
881 && TREE_CODE (oldlocal) == VAR_DECL
882 && DECL_DEAD_FOR_LOCAL (oldlocal))
883 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
885 if (oldlocal == NULL_TREE)
886 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
889 /* If this is an extern function declaration, see if we
890 have a global definition or declaration for the function. */
891 if (oldlocal == NULL_TREE
893 && oldglobal != NULL_TREE
894 && TREE_CODE (x) == FUNCTION_DECL
895 && TREE_CODE (oldglobal) == FUNCTION_DECL)
897 /* We have one. Their types must agree. */
898 if (decls_match (x, oldglobal))
902 warning ("extern declaration of `%#D' doesn't match", x);
903 cp_warning_at ("global declaration `%#D'", oldglobal);
906 /* If we have a local external declaration,
907 and no file-scope declaration has yet been seen,
908 then if we later have a file-scope decl it must not be static. */
909 if (oldlocal == NULL_TREE
910 && oldglobal == NULL_TREE
913 TREE_PUBLIC (name) = 1;
915 /* Warn if shadowing an argument at the top level of the body. */
916 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
917 /* Inline decls shadow nothing. */
918 && !DECL_FROM_INLINE (x)
919 && TREE_CODE (oldlocal) == PARM_DECL
920 /* Don't check the `this' parameter. */
921 && !DECL_ARTIFICIAL (oldlocal))
925 /* Don't complain if it's from an enclosing function. */
926 if (DECL_CONTEXT (oldlocal) == current_function_decl
927 && TREE_CODE (x) != PARM_DECL)
929 /* Go to where the parms should be and see if we find
931 struct cp_binding_level *b = current_binding_level->level_chain;
933 /* Skip the ctor/dtor cleanup level. */
937 if (b->kind == sk_function_parms)
939 error ("declaration of `%#D' shadows a parameter",
945 if (warn_shadow && !err)
946 shadow_warning (SW_PARAM,
947 IDENTIFIER_POINTER (name), oldlocal);
950 /* Maybe warn if shadowing something else. */
951 else if (warn_shadow && !DECL_EXTERNAL (x)
952 /* No shadow warnings for internally generated vars. */
953 && ! DECL_ARTIFICIAL (x)
954 /* No shadow warnings for vars made for inlining. */
955 && ! DECL_FROM_INLINE (x))
957 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
959 && !TREE_STATIC (name))
960 warning ("declaration of `%s' shadows a member of `this'",
961 IDENTIFIER_POINTER (name));
962 else if (oldlocal != NULL_TREE
963 && TREE_CODE (oldlocal) == VAR_DECL)
964 shadow_warning (SW_LOCAL,
965 IDENTIFIER_POINTER (name), oldlocal);
966 else if (oldglobal != NULL_TREE
967 && TREE_CODE (oldglobal) == VAR_DECL)
968 /* XXX shadow warnings in outer-more namespaces */
969 shadow_warning (SW_GLOBAL,
970 IDENTIFIER_POINTER (name), oldglobal);
974 if (TREE_CODE (x) == FUNCTION_DECL)
975 check_default_args (x);
977 if (TREE_CODE (x) == VAR_DECL)
978 maybe_register_incomplete_var (x);
981 if (need_new_binding)
982 add_decl_to_level (x,
983 DECL_NAMESPACE_SCOPE_P (x)
984 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
985 : current_binding_level);
987 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
990 /* Enter DECL into the symbol table, if that's appropriate. Returns
991 DECL, or a modified version thereof. */
994 maybe_push_decl (tree decl)
996 tree type = TREE_TYPE (decl);
998 /* Add this decl to the current binding level, but not if it comes
999 from another scope, e.g. a static member variable. TEM may equal
1000 DECL or it may be a previous decl of the same name. */
1001 if (decl == error_mark_node
1002 || (TREE_CODE (decl) != PARM_DECL
1003 && DECL_CONTEXT (decl) != NULL_TREE
1004 /* Definitions of namespace members outside their namespace are
1006 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1007 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1008 || TREE_CODE (type) == UNKNOWN_TYPE
1009 /* The declaration of a template specialization does not affect
1010 the functions available for overload resolution, so we do not
1012 || (TREE_CODE (decl) == FUNCTION_DECL
1013 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1016 return pushdecl (decl);
1019 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1020 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1021 doesn't really belong to this binding level, that it got here
1022 through a using-declaration. */
1025 push_local_binding (tree id, tree decl, int flags)
1027 struct cp_binding_level *b;
1029 /* Skip over any local classes. This makes sense if we call
1030 push_local_binding with a friend decl of a local class. */
1031 b = innermost_nonclass_level ();
1033 if (lookup_name_current_level (id))
1035 /* Supplement the existing binding. */
1036 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1037 /* It didn't work. Something else must be bound at this
1038 level. Do not add DECL to the list of things to pop
1043 /* Create a new binding. */
1044 push_binding (id, decl, b);
1046 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1047 /* We must put the OVERLOAD into a TREE_LIST since the
1048 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1049 decls that got here through a using-declaration. */
1050 decl = build_tree_list (NULL_TREE, decl);
1052 /* And put DECL on the list of things declared by the current
1054 add_decl_to_level (decl, b);
1057 /* The old ARM scoping rules injected variables declared in the
1058 initialization statement of a for-statement into the surrounding
1059 scope. We support this usage, in order to be backward-compatible.
1060 DECL is a just-declared VAR_DECL; if necessary inject its
1061 declaration into the surrounding scope. */
1064 maybe_inject_for_scope_var (tree decl)
1066 timevar_push (TV_NAME_LOOKUP);
1067 if (!DECL_NAME (decl))
1069 timevar_pop (TV_NAME_LOOKUP);
1073 /* Declarations of __FUNCTION__ and its ilk appear magically when
1074 the variable is first used. If that happens to be inside a
1075 for-loop, we don't want to do anything special. */
1076 if (DECL_PRETTY_FUNCTION_P (decl))
1078 timevar_pop (TV_NAME_LOOKUP);
1082 if (current_binding_level->kind == sk_for)
1084 struct cp_binding_level *outer
1085 = current_binding_level->level_chain;
1087 /* Check to see if the same name is already bound at the outer
1088 level, either because it was directly declared, or because a
1089 dead for-decl got preserved. In either case, the code would
1090 not have been valid under the ARM scope rules, so clear
1091 is_for_scope for the current_binding_level.
1093 Otherwise, we need to preserve the temp slot for decl to last
1094 into the outer binding level. */
1096 cxx_binding *outer_binding
1097 = IDENTIFIER_BINDING (DECL_NAME (decl))->previous;
1099 if (outer_binding && outer_binding->scope == outer
1100 && (TREE_CODE (outer_binding->value) == VAR_DECL)
1101 && DECL_DEAD_FOR_LOCAL (outer_binding->value))
1103 outer_binding->value = DECL_SHADOWED_FOR_VAR (outer_binding->value);
1104 current_binding_level->kind = sk_block;
1107 timevar_pop (TV_NAME_LOOKUP);
1110 /* Check to see whether or not DECL is a variable that would have been
1111 in scope under the ARM, but is not in scope under the ANSI/ISO
1112 standard. If so, issue an error message. If name lookup would
1113 work in both cases, but return a different result, this function
1114 returns the result of ANSI/ISO lookup. Otherwise, it returns
1118 check_for_out_of_scope_variable (tree decl)
1122 /* We only care about out of scope variables. */
1123 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1126 shadowed = DECL_SHADOWED_FOR_VAR (decl);
1127 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1128 && DECL_DEAD_FOR_LOCAL (shadowed))
1129 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1131 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1134 if (!DECL_ERROR_REPORTED (decl))
1136 warning ("name lookup of `%D' changed",
1138 cp_warning_at (" matches this `%D' under ISO standard rules",
1140 cp_warning_at (" matches this `%D' under old rules", decl);
1141 DECL_ERROR_REPORTED (decl) = 1;
1146 /* If we have already complained about this declaration, there's no
1147 need to do it again. */
1148 if (DECL_ERROR_REPORTED (decl))
1151 DECL_ERROR_REPORTED (decl) = 1;
1152 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1154 error ("name lookup of `%D' changed for new ISO `for' scoping",
1156 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
1157 return error_mark_node;
1161 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
1163 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
1169 /* true means unconditionally make a BLOCK for the next level pushed. */
1171 static bool keep_next_level_flag;
1173 static int binding_depth = 0;
1174 static int is_class_level = 0;
1181 for (i = 0; i < depth * 2; i++)
1185 /* Return a string describing the kind of SCOPE we have. */
1187 cxx_scope_descriptor (cxx_scope *scope)
1189 /* The order of this table must match the "scope_kind"
1191 static const char* scope_kind_names[] = {
1197 "function-parameter-scope",
1200 "template-parameter-scope",
1201 "template-explicit-spec-scope"
1203 const scope_kind kind = scope->explicit_spec_p
1204 ? sk_template_spec : scope->kind;
1206 return scope_kind_names[kind];
1209 /* Output a debugging information about SCOPE when performing
1212 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1214 const char *desc = cxx_scope_descriptor (scope);
1215 if (scope->this_entity)
1216 verbatim ("%s %s(%E) %p %d\n", action, desc,
1217 scope->this_entity, (void *) scope, line);
1219 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1222 /* Return the estimated initial size of the hashtable of a NAMESPACE
1225 static inline size_t
1226 namespace_scope_ht_size (tree ns)
1228 tree name = DECL_NAME (ns);
1230 return name == std_identifier
1231 ? NAMESPACE_STD_HT_SIZE
1232 : (name == global_scope_name
1233 ? GLOBAL_SCOPE_HT_SIZE
1234 : NAMESPACE_ORDINARY_HT_SIZE);
1237 /* A chain of binding_level structures awaiting reuse. */
1239 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
1241 /* Create a new KIND scope and make it the top of the active scopes stack.
1242 ENTITY is the scope of the associated C++ entity (namespace, class,
1243 function); it is NULL otherwise. */
1246 begin_scope (scope_kind kind, tree entity)
1250 /* Reuse or create a struct for this binding level. */
1251 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1253 scope = free_binding_level;
1254 free_binding_level = scope->level_chain;
1257 scope = ggc_alloc (sizeof (cxx_scope));
1258 memset (scope, 0, sizeof (cxx_scope));
1260 scope->this_entity = entity;
1261 scope->more_cleanups_ok = true;
1268 case sk_template_spec:
1269 scope->explicit_spec_p = true;
1270 kind = sk_template_parms;
1272 case sk_template_parms:
1278 case sk_function_parms:
1279 scope->keep = keep_next_level_flag;
1283 scope->type_decls = binding_table_new (namespace_scope_ht_size (entity));
1284 NAMESPACE_LEVEL (entity) = scope;
1285 VARRAY_TREE_INIT (scope->static_decls,
1286 DECL_NAME (entity) == std_identifier
1287 || DECL_NAME (entity) == global_scope_name
1289 "Static declarations");
1293 /* Should not happen. */
1294 my_friendly_assert (false, 20030922);
1299 /* Add it to the front of currently active scopes stack. */
1300 scope->level_chain = current_binding_level;
1301 current_binding_level = scope;
1302 keep_next_level_flag = false;
1304 if (ENABLE_SCOPE_CHECKING)
1306 scope->binding_depth = binding_depth;
1307 indent (binding_depth);
1308 cxx_scope_debug (scope, input_location.line, "push");
1316 /* We're about to leave current scope. Pop the top of the stack of
1317 currently active scopes. Return the enclosing scope, now active. */
1322 cxx_scope *scope = current_binding_level;
1324 if (scope->kind == sk_namespace && class_binding_level)
1325 current_binding_level = class_binding_level;
1327 /* We cannot leave a scope, if there are none left. */
1328 if (NAMESPACE_LEVEL (global_namespace))
1329 my_friendly_assert (!global_scope_p (scope), 20030527);
1331 if (ENABLE_SCOPE_CHECKING)
1333 indent (--binding_depth);
1334 cxx_scope_debug (scope, input_location.line, "leave");
1335 if (is_class_level != (scope == class_binding_level))
1337 indent (binding_depth);
1338 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1343 /* Move one nesting level up. */
1344 current_binding_level = scope->level_chain;
1346 /* Namespace-scopes are left most probably temporarily, not completely;
1347 they can be reopen later, e.g. in namespace-extension or any name
1348 binding activity that requires us to resume a namespace. For other
1349 scopes, we just make the structure available for reuse. */
1350 if (scope->kind != sk_namespace)
1352 scope->level_chain = free_binding_level;
1353 if (scope->kind == sk_class)
1354 scope->type_decls = NULL;
1356 binding_table_free (scope->type_decls);
1357 my_friendly_assert (!ENABLE_SCOPE_CHECKING
1358 || scope->binding_depth == binding_depth,
1360 free_binding_level = scope;
1363 /* Find the innermost enclosing class scope, and reset
1364 CLASS_BINDING_LEVEL appropriately. */
1365 for (scope = current_binding_level;
1366 scope && scope->kind != sk_class;
1367 scope = scope->level_chain)
1369 class_binding_level = scope && scope->kind == sk_class ? scope : NULL;
1371 return current_binding_level;
1375 resume_scope (struct cp_binding_level* b)
1377 /* Resuming binding levels is meant only for namespaces,
1378 and those cannot nest into classes. */
1379 my_friendly_assert(!class_binding_level, 386);
1380 /* Also, resuming a non-directly nested namespace is a no-no. */
1381 my_friendly_assert(b->level_chain == current_binding_level, 386);
1382 current_binding_level = b;
1383 if (ENABLE_SCOPE_CHECKING)
1385 b->binding_depth = binding_depth;
1386 indent (binding_depth);
1387 cxx_scope_debug (b, input_location.line, "resume");
1393 /* Return the innermost binding level that is not for a class scope. */
1396 innermost_nonclass_level (void)
1400 b = current_binding_level;
1401 while (b->kind == sk_class)
1407 /* We're defining an object of type TYPE. If it needs a cleanup, but
1408 we're not allowed to add any more objects with cleanups to the current
1409 scope, create a new binding level. */
1412 maybe_push_cleanup_level (tree type)
1414 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1415 && current_binding_level->more_cleanups_ok == 0)
1417 begin_scope (sk_cleanup, NULL);
1419 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
1423 /* Nonzero if we are currently in the global binding level. */
1426 global_bindings_p (void)
1428 return global_scope_p (current_binding_level);
1431 /* True if we are currently in a toplevel binding level. This
1432 means either the global binding level or a namespace in a toplevel
1433 binding level. Since there are no non-toplevel namespace levels,
1434 this really means any namespace or template parameter level. We
1435 also include a class whose context is toplevel. */
1438 toplevel_bindings_p (void)
1440 struct cp_binding_level *b = innermost_nonclass_level ();
1442 return b->kind == sk_namespace || b->kind == sk_template_parms;
1445 /* True if this is a namespace scope, or if we are defining a class
1446 which is itself at namespace scope, or whose enclosing class is
1447 such a class, etc. */
1450 namespace_bindings_p (void)
1452 struct cp_binding_level *b = innermost_nonclass_level ();
1454 return b->kind == sk_namespace;
1457 /* True if the current level needs to have a BLOCK made. */
1462 return (current_binding_level->blocks != NULL_TREE
1463 || current_binding_level->keep
1464 || current_binding_level->kind == sk_cleanup
1465 || current_binding_level->names != NULL_TREE
1466 || current_binding_level->type_decls != NULL);
1469 /* Returns the kind of the innermost scope. */
1472 innermost_scope_kind (void)
1474 return current_binding_level->kind;
1477 /* Returns true if this scope was created to store template parameters. */
1480 template_parm_scope_p (void)
1482 return innermost_scope_kind () == sk_template_parms;
1485 /* If KEEP is true, make a BLOCK node for the next binding level,
1486 unconditionally. Otherwise, use the normal logic to decide whether
1487 or not to create a BLOCK. */
1490 keep_next_level (bool keep)
1492 keep_next_level_flag = keep;
1495 /* Return the list of declarations of the current level.
1496 Note that this list is in reverse order unless/until
1497 you nreverse it; and when you do nreverse it, you must
1498 store the result back using `storedecls' or you will lose. */
1503 return current_binding_level->names;
1506 /* Set the current binding TABLE for type declarations.. This is a
1507 temporary workaround of the fact that the data structure classtypes
1508 does not currently carry its allocated cxx_scope structure. */
1510 cxx_remember_type_decls (binding_table table)
1512 current_binding_level->type_decls = table;
1515 /* For debugging. */
1516 static int no_print_functions = 0;
1517 static int no_print_builtins = 0;
1519 /* Called from print_binding_level through binding_table_foreach to
1520 print the content of binding ENTRY. DATA is a pointer to line offset
1523 bt_print_entry (binding_entry entry, void *data)
1525 int *p = (int *) data;
1528 if (entry->name == NULL)
1530 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1540 fprintf (stderr, "\n\t");
1543 if (entry->name == NULL)
1545 print_node_brief (stderr, "<unnamed-typedef", entry->type, 0);
1546 fprintf (stderr, ">");
1548 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1549 print_node_brief (stderr, "", entry->type, 0);
1552 print_node_brief (stderr, "<typedef", entry->name, 0);
1553 print_node_brief (stderr, "", entry->type, 0);
1554 fprintf (stderr, ">");
1559 print_binding_level (struct cp_binding_level* lvl)
1563 fprintf (stderr, " blocks=" HOST_PTR_PRINTF, (void *) lvl->blocks);
1564 if (lvl->more_cleanups_ok)
1565 fprintf (stderr, " more-cleanups-ok");
1566 if (lvl->have_cleanups)
1567 fprintf (stderr, " have-cleanups");
1568 fprintf (stderr, "\n");
1571 fprintf (stderr, " names:\t");
1572 /* We can probably fit 3 names to a line? */
1573 for (t = lvl->names; t; t = TREE_CHAIN (t))
1575 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1577 if (no_print_builtins
1578 && (TREE_CODE (t) == TYPE_DECL)
1579 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1582 /* Function decls tend to have longer names. */
1583 if (TREE_CODE (t) == FUNCTION_DECL)
1590 fprintf (stderr, "\n\t");
1593 print_node_brief (stderr, "", t, 0);
1594 if (t == error_mark_node)
1598 fprintf (stderr, "\n");
1600 if (lvl->type_decls)
1602 fprintf (stderr, " tags:\t");
1604 binding_table_foreach (lvl->type_decls, bt_print_entry, &i);
1606 fprintf (stderr, "\n");
1608 if (lvl->class_shadowed)
1610 fprintf (stderr, " class-shadowed:");
1611 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1613 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1615 fprintf (stderr, "\n");
1617 if (lvl->type_shadowed)
1619 fprintf (stderr, " type-shadowed:");
1620 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1622 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1624 fprintf (stderr, "\n");
1629 print_other_binding_stack (struct cp_binding_level *stack)
1631 struct cp_binding_level *level;
1632 for (level = stack; !global_scope_p (level); level = level->level_chain)
1634 fprintf (stderr, "binding level " HOST_PTR_PRINTF "\n", (void *) level);
1635 print_binding_level (level);
1640 print_binding_stack (void)
1642 struct cp_binding_level *b;
1643 fprintf (stderr, "current_binding_level=" HOST_PTR_PRINTF
1644 "\nclass_binding_level=" HOST_PTR_PRINTF
1645 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF "\n",
1646 (void *) current_binding_level, (void *) class_binding_level,
1647 (void *) NAMESPACE_LEVEL (global_namespace));
1648 if (class_binding_level)
1650 for (b = class_binding_level; b; b = b->level_chain)
1651 if (b == current_binding_level)
1654 b = class_binding_level;
1656 b = current_binding_level;
1659 b = current_binding_level;
1660 print_other_binding_stack (b);
1661 fprintf (stderr, "global:\n");
1662 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1665 /* Return the type associated with id. */
1668 identifier_type_value (tree id)
1670 timevar_push (TV_NAME_LOOKUP);
1671 /* There is no type with that name, anywhere. */
1672 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1673 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1674 /* This is not the type marker, but the real thing. */
1675 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1676 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1677 /* Have to search for it. It must be on the global level, now.
1678 Ask lookup_name not to return non-types. */
1679 id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
1681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1682 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1685 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1686 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1689 identifier_global_value (tree t)
1691 return IDENTIFIER_GLOBAL_VALUE (t);
1694 /* Push a definition of struct, union or enum tag named ID. into
1695 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1696 the tag ID is not already defined. */
1699 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1703 if (b->kind != sk_namespace)
1705 /* Shadow the marker, not the real thing, so that the marker
1706 gets restored later. */
1707 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1709 = tree_cons (id, old_type_value, b->type_shadowed);
1710 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1714 cxx_binding *binding =
1715 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1719 supplement_binding (binding, decl);
1721 binding->value = decl;
1725 /* Store marker instead of real type. */
1726 type = global_type_node;
1728 SET_IDENTIFIER_TYPE_VALUE (id, type);
1731 /* As set_identifier_type_value_with_scope, but using
1732 current_binding_level. */
1735 set_identifier_type_value (tree id, tree decl)
1737 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1740 /* Return the name for the constructor (or destructor) for the
1741 specified class TYPE. When given a template, this routine doesn't
1742 lose the specialization. */
1745 constructor_name_full (tree type)
1747 type = TYPE_MAIN_VARIANT (type);
1748 if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type)
1749 && TYPE_HAS_CONSTRUCTOR (type))
1750 return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1752 return TYPE_IDENTIFIER (type);
1755 /* Return the name for the constructor (or destructor) for the
1756 specified class. When given a template, return the plain
1757 unspecialized name. */
1760 constructor_name (tree type)
1763 name = constructor_name_full (type);
1764 if (IDENTIFIER_TEMPLATE (name))
1765 name = IDENTIFIER_TEMPLATE (name);
1769 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1772 constructor_name_p (tree name, tree type)
1779 if (TREE_CODE (name) != IDENTIFIER_NODE)
1782 ctor_name = constructor_name_full (type);
1783 if (name == ctor_name)
1785 if (IDENTIFIER_TEMPLATE (ctor_name)
1786 && name == IDENTIFIER_TEMPLATE (ctor_name))
1791 /* Counter used to create anonymous type names. */
1793 static GTY(()) int anon_cnt;
1795 /* Return an IDENTIFIER which can be used as a name for
1796 anonymous structs and unions. */
1799 make_anon_name (void)
1803 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1804 return get_identifier (buf);
1807 /* Clear the TREE_PURPOSE slot of UTDs which have anonymous typenames.
1808 This keeps dbxout from getting confused. */
1811 clear_anon_tags (void)
1813 struct cp_binding_level *b;
1814 static int last_cnt = 0;
1816 /* Fast out if no new anon names were declared. */
1817 if (last_cnt == anon_cnt)
1820 b = current_binding_level;
1821 while (b->kind == sk_cleanup)
1823 if (b->type_decls != NULL)
1824 binding_table_remove_anonymous_types (b->type_decls);
1825 last_cnt = anon_cnt;
1828 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1830 static inline cxx_binding *
1831 find_binding (cxx_scope *scope, cxx_binding *binding)
1833 timevar_push (TV_NAME_LOOKUP);
1835 for (; binding != NULL; binding = binding->previous)
1836 if (binding->scope == scope)
1837 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1839 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1842 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1844 static inline cxx_binding *
1845 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1847 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1850 /* Fold-in case where NAME is used only once. */
1851 if (scope == b->scope && b->previous == NULL)
1853 return find_binding (scope, b);
1858 /* Always returns a binding for name in scope. If no binding is
1859 found, make a new one. */
1861 static cxx_binding *
1862 binding_for_name (cxx_scope *scope, tree name)
1864 cxx_binding *result;
1866 result = cxx_scope_find_binding_for_name (scope, name);
1869 /* Not found, make a new one. */
1870 result = cxx_binding_make (NULL, NULL);
1871 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1872 result->scope = scope;
1873 result->is_local = false;
1874 result->value_is_inherited = false;
1875 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1879 /* Insert another USING_DECL into the current binding level, returning
1880 this declaration. If this is a redeclaration, do nothing, and
1881 return NULL_TREE if this not in namespace scope (in namespace
1882 scope, a using decl might extend any previous bindings). */
1885 push_using_decl (tree scope, tree name)
1889 timevar_push (TV_NAME_LOOKUP);
1890 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
1891 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
1892 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1893 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
1896 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1897 namespace_bindings_p () ? decl : NULL_TREE);
1898 decl = build_lang_decl (USING_DECL, name, void_type_node);
1899 DECL_INITIAL (decl) = scope;
1900 TREE_CHAIN (decl) = current_binding_level->usings;
1901 current_binding_level->usings = decl;
1902 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1905 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1906 caller to set DECL_CONTEXT properly. */
1909 pushdecl_with_scope (tree x, cxx_scope *level)
1911 struct cp_binding_level *b;
1912 tree function_decl = current_function_decl;
1914 timevar_push (TV_NAME_LOOKUP);
1915 current_function_decl = NULL_TREE;
1916 if (level->kind == sk_class)
1918 b = class_binding_level;
1919 class_binding_level = level;
1920 pushdecl_class_level (x);
1921 class_binding_level = b;
1925 b = current_binding_level;
1926 current_binding_level = level;
1928 current_binding_level = b;
1930 current_function_decl = function_decl;
1931 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1934 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1935 other definitions already in place. We get around this by making
1936 the value of the identifier point to a list of all the things that
1937 want to be referenced by that name. It is then up to the users of
1938 that name to decide what to do with that list.
1940 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1941 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1943 FLAGS is a bitwise-or of the following values:
1944 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1946 PUSH_USING: DECL is being pushed as the result of a using
1949 The value returned may be a previous declaration if we guessed wrong
1950 about what language DECL should belong to (C or C++). Otherwise,
1951 it's always DECL (and never something that's not a _DECL). */
1954 push_overloaded_decl (tree decl, int flags)
1956 tree name = DECL_NAME (decl);
1959 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1961 timevar_push (TV_NAME_LOOKUP);
1963 old = namespace_binding (name, DECL_CONTEXT (decl));
1965 old = lookup_name_current_level (name);
1969 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1971 tree t = TREE_TYPE (old);
1972 if (IS_AGGR_TYPE (t) && warn_shadow
1973 && (! DECL_IN_SYSTEM_HEADER (decl)
1974 || ! DECL_IN_SYSTEM_HEADER (old)))
1975 warning ("`%#D' hides constructor for `%#T'", decl, t);
1978 else if (is_overloaded_fn (old))
1982 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1984 tree fn = OVL_CURRENT (tmp);
1986 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1987 && !(flags & PUSH_USING)
1988 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1989 TYPE_ARG_TYPES (TREE_TYPE (decl))))
1990 error ("`%#D' conflicts with previous using declaration `%#D'",
1993 if (duplicate_decls (decl, fn) == fn)
1994 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
1997 else if (old == error_mark_node)
1998 /* Ignore the undefined symbol marker. */
2002 cp_error_at ("previous non-function declaration `%#D'", old);
2003 error ("conflicts with function declaration `%#D'", decl);
2004 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2008 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2009 /* If it's a using declaration, we always need to build an OVERLOAD,
2010 because it's the only way to remember that the declaration comes
2011 from 'using', and have the lookup behave correctly. */
2012 || (flags & PUSH_USING))
2014 if (old && TREE_CODE (old) != OVERLOAD)
2015 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2017 new_binding = ovl_cons (decl, old);
2018 if (flags & PUSH_USING)
2019 OVL_USED (new_binding) = 1;
2022 /* NAME is not ambiguous. */
2026 set_namespace_binding (name, current_namespace, new_binding);
2029 /* We only create an OVERLOAD if there was a previous binding at
2030 this level, or if decl is a template. In the former case, we
2031 need to remove the old binding and replace it with the new
2032 binding. We must also run through the NAMES on the binding
2033 level where the name was bound to update the chain. */
2035 if (TREE_CODE (new_binding) == OVERLOAD && old)
2039 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2041 d = &TREE_CHAIN (*d))
2043 || (TREE_CODE (*d) == TREE_LIST
2044 && TREE_VALUE (*d) == old))
2046 if (TREE_CODE (*d) == TREE_LIST)
2047 /* Just replace the old binding with the new. */
2048 TREE_VALUE (*d) = new_binding;
2050 /* Build a TREE_LIST to wrap the OVERLOAD. */
2051 *d = tree_cons (NULL_TREE, new_binding,
2054 /* And update the cxx_binding node. */
2055 IDENTIFIER_BINDING (name)->value = new_binding;
2056 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2059 /* We should always find a previous binding in this case. */
2063 /* Install the new binding. */
2064 push_local_binding (name, new_binding, flags);
2067 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2070 /* Check a non-member using-declaration. Return the name and scope
2071 being used, and the USING_DECL, or NULL_TREE on failure. */
2074 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2076 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2079 A using-declaration shall not name a template-id. */
2080 error ("a using-declaration cannot specify a template-id. Try `using %D'", name);
2084 if (TREE_CODE (decl) == NAMESPACE_DECL)
2086 error ("namespace `%D' not allowed in using-declaration", decl);
2090 if (TREE_CODE (decl) == SCOPE_REF)
2092 /* It's a nested name with template parameter dependent scope.
2093 This can only be using-declaration for class member. */
2094 error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
2098 if (is_overloaded_fn (decl))
2099 decl = get_first_fn (decl);
2101 my_friendly_assert (DECL_P (decl), 20020908);
2103 /* [namespace.udecl]
2104 A using-declaration for a class member shall be a
2105 member-declaration. */
2108 error ("`%T' is not a namespace", scope);
2112 /* Make a USING_DECL. */
2113 return push_using_decl (scope, name);
2116 /* Process local and global using-declarations. */
2119 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2120 tree *newval, tree *newtype)
2124 *newval = *newtype = NULL_TREE;
2125 cxx_binding_clear (&decls);
2126 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2130 if (!decls.value && !decls.type)
2132 error ("`%D' not declared", name);
2136 /* Check for using functions. */
2137 if (decls.value && is_overloaded_fn (decls.value))
2141 if (oldval && !is_overloaded_fn (oldval))
2143 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2144 error ("`%D' is already declared in this scope", name);
2149 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2151 tree new_fn = OVL_CURRENT (tmp);
2153 /* [namespace.udecl]
2155 If a function declaration in namespace scope or block
2156 scope has the same name and the same parameter types as a
2157 function introduced by a using declaration the program is
2159 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2161 tree old_fn = OVL_CURRENT (tmp1);
2163 if (new_fn == old_fn)
2164 /* The function already exists in the current namespace. */
2166 else if (OVL_USED (tmp1))
2167 continue; /* this is a using decl */
2168 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2169 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2171 /* There was already a non-using declaration in
2172 this scope with the same parameter types. If both
2173 are the same extern "C" functions, that's ok. */
2174 if (decls_match (new_fn, old_fn))
2176 /* If the OLD_FN was a builtin, there is now a
2177 real declaration. */
2178 if (DECL_ANTICIPATED (old_fn))
2179 DECL_ANTICIPATED (old_fn) = 0;
2182 else if (!DECL_ANTICIPATED (old_fn))
2184 /* If the OLD_FN was really declared, the
2185 declarations don't match. */
2186 error ("`%D' is already declared in this scope", name);
2190 /* If the OLD_FN was not really there, just ignore
2191 it and keep going. */
2195 /* If we broke out of the loop, there's no reason to add
2196 this function to the using declarations for this
2201 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2202 if (TREE_CODE (*newval) != OVERLOAD)
2203 *newval = ovl_cons (*newval, NULL_TREE);
2204 OVL_USED (*newval) = 1;
2209 *newval = decls.value;
2210 if (oldval && !decls_match (*newval, oldval))
2211 error ("`%D' is already declared in this scope", name);
2214 *newtype = decls.type;
2215 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2217 error ("using declaration `%D' introduced ambiguous type `%T'",
2223 /* Process a using-declaration at function scope. */
2226 do_local_using_decl (tree decl, tree scope, tree name)
2228 tree oldval, oldtype, newval, newtype;
2230 decl = validate_nonmember_using_decl (decl, scope, name);
2231 if (decl == NULL_TREE)
2234 if (building_stmt_tree ()
2235 && at_function_scope_p ())
2236 add_decl_stmt (decl);
2238 oldval = lookup_name_current_level (name);
2239 oldtype = lookup_type_current_level (name);
2241 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2245 if (is_overloaded_fn (newval))
2249 /* We only need to push declarations for those functions
2250 that were not already bound in the current level.
2251 The old value might be NULL_TREE, it might be a single
2252 function, or an OVERLOAD. */
2253 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2254 term = OVL_FUNCTION (oldval);
2257 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2259 push_overloaded_decl (OVL_CURRENT (fn),
2260 PUSH_LOCAL | PUSH_USING);
2263 push_local_binding (name, newval, PUSH_USING);
2266 set_identifier_type_value (name, newtype);
2269 /* Return the type that should be used when TYPE's name is preceded
2270 by a tag such as 'struct' or 'union', or null if the name cannot
2271 be used in this way.
2273 For example, when processing the third line of:
2279 lookup of A will find the typedef. Given A's typedef, this function
2280 will return the type associated with "struct A". For the tag to be
2281 anything other than TYPE, TYPE must be a typedef whose original type
2282 has the same name and context as TYPE itself.
2284 It is not valid for a typedef of an anonymous type to be used with
2287 typedef struct { ... } B;
2290 Return null for this case. */
2293 follow_tag_typedef (tree type)
2297 original = original_type (type);
2298 if (! TYPE_NAME (original))
2300 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
2301 && (CP_DECL_CONTEXT (TYPE_NAME (original))
2302 == CP_DECL_CONTEXT (TYPE_NAME (type)))
2303 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
2309 /* Given NAME, an IDENTIFIER_NODE,
2310 return the structure (or union or enum) definition for that name.
2311 Searches binding levels from its SCOPE up to the global level.
2312 If THISLEVEL_ONLY is nonzero, searches only the specified context
2313 (but skips any sk_cleanup contexts to find one that is
2314 meaningful for tags).
2315 FORM says which kind of type the caller wants;
2316 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2317 If the wrong kind of type is found, and it's not a template, an error is
2321 lookup_tag (enum tree_code form, tree name,
2322 cxx_scope *binding_level, int thislevel_only)
2324 struct cp_binding_level *level;
2325 /* Nonzero if, we should look past a template parameter level, even
2326 if THISLEVEL_ONLY. */
2327 int allow_template_parms_p = 1;
2328 bool type_is_anonymous = ANON_AGGRNAME_P (name);
2330 timevar_push (TV_NAME_LOOKUP);
2331 for (level = binding_level; level; level = level->level_chain)
2334 if (type_is_anonymous && level->type_decls != NULL)
2336 tree type = binding_table_find_anon_type (level->type_decls, name);
2337 /* There is no need for error checking here, because
2338 anon names are unique throughout the compilation. */
2340 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
2342 else if (level->kind == sk_namespace)
2343 /* Do namespace lookup. */
2344 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
2346 cxx_binding *binding =
2347 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (tail), name);
2350 /* If we just skipped past a template parameter level,
2351 even though THISLEVEL_ONLY, and we find a template
2352 class declaration, then we use the _TYPE node for the
2353 template. See the example below. */
2354 if (thislevel_only && !allow_template_parms_p
2355 && binding && binding->value
2356 && DECL_CLASS_TEMPLATE_P (binding->value))
2357 old = binding->value;
2359 old = select_decl (binding, LOOKUP_PREFER_TYPES);
2365 /* We've found something at this binding level. If it is
2366 a typedef, extract the tag it refers to. Lookup fails
2367 if the typedef doesn't refer to a taggable type. */
2368 old = TREE_TYPE (old);
2369 old = follow_tag_typedef (old);
2371 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2372 if (TREE_CODE (old) != form
2373 && (form == ENUMERAL_TYPE
2374 || TREE_CODE (old) == ENUMERAL_TYPE))
2376 error ("`%#D' redeclared as %C", old, form);
2377 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2379 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
2381 if (thislevel_only || tail == global_namespace)
2382 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2384 else if (level->type_decls != NULL)
2386 binding_entry entry = binding_table_find (level->type_decls, name);
2389 enum tree_code code = TREE_CODE (entry->type);
2392 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
2394 /* Definition isn't the kind we were looking for. */
2395 error ("`%#D' redeclared as %C", entry->type, form);
2396 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->type);
2401 if (thislevel_only && level->kind != sk_cleanup)
2403 if (level->kind == sk_template_parms && allow_template_parms_p)
2405 /* We must deal with cases like this:
2407 template <class T> struct S;
2408 template <class T> struct S {};
2410 When looking up `S', for the second declaration, we
2411 would like to find the first declaration. But, we
2412 are in the pseudo-global level created for the
2413 template parameters, rather than the (surrounding)
2414 namespace level. Thus, we keep going one more level,
2415 even though THISLEVEL_ONLY is nonzero. */
2416 allow_template_parms_p = 0;
2420 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2423 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2426 /* Given a type, find the tag that was defined for it and return the tag name.
2427 Otherwise return 0. However, the value can never be 0
2428 in the cases in which this is used.
2430 C++: If NAME is nonzero, this is the new name to install. This is
2431 done when replacing anonymous tags with real tag names. */
2434 lookup_tag_reverse (tree type, tree name)
2436 struct cp_binding_level *level;
2438 timevar_push (TV_NAME_LOOKUP);
2439 for (level = current_binding_level; level; level = level->level_chain)
2441 binding_entry entry = level->type_decls == NULL
2443 : binding_table_reverse_maybe_remap (level->type_decls, type, name);
2445 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->name);
2447 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2450 /* Returns true if ROOT (a namespace, class, or function) encloses
2451 CHILD. CHILD may be either a class type or a namespace. */
2454 is_ancestor (tree root, tree child)
2456 my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
2457 || TREE_CODE (root) == FUNCTION_DECL
2458 || CLASS_TYPE_P (root)), 20030307);
2459 my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
2460 || CLASS_TYPE_P (child)),
2463 /* The global namespace encloses everything. */
2464 if (root == global_namespace)
2469 /* If we've run out of scopes, stop. */
2472 /* If we've reached the ROOT, it encloses CHILD. */
2475 /* Go out one level. */
2477 child = TYPE_NAME (child);
2478 child = DECL_CONTEXT (child);
2482 /* Enter a class or namespace scope. */
2487 if (TREE_CODE (t) == NAMESPACE_DECL)
2488 push_decl_namespace (t);
2489 else if CLASS_TYPE_P (t)
2490 push_nested_class (t);
2493 /* Leave scope pushed by push_scope. */
2498 if (TREE_CODE (t) == NAMESPACE_DECL)
2499 pop_decl_namespace ();
2500 else if CLASS_TYPE_P (t)
2501 pop_nested_class ();
2504 /* Do a pushlevel for class declarations. */
2507 pushlevel_class (void)
2509 if (ENABLE_SCOPE_CHECKING)
2512 class_binding_level = begin_scope (sk_class, current_class_type);
2515 /* ...and a poplevel for class declarations. */
2518 poplevel_class (void)
2520 struct cp_binding_level *level = class_binding_level;
2523 timevar_push (TV_NAME_LOOKUP);
2524 my_friendly_assert (level != 0, 354);
2526 /* If we're leaving a toplevel class, don't bother to do the setting
2527 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
2528 shouldn't even be used when current_class_type isn't set, and second,
2529 if we don't touch it here, we're able to use the cache effect if the
2530 next time we're entering a class scope, it is the same class. */
2531 if (current_class_depth != 1)
2533 struct cp_binding_level* b;
2535 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
2536 for (shadowed = level->class_shadowed;
2538 shadowed = TREE_CHAIN (shadowed))
2539 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
2541 /* Find the next enclosing class, and recreate
2542 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
2543 b = level->level_chain;
2544 while (b && b->kind != sk_class)
2548 for (shadowed = b->class_shadowed;
2550 shadowed = TREE_CHAIN (shadowed))
2552 cxx_binding *binding;
2554 binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
2555 while (binding && binding->scope != b)
2556 binding = binding->previous;
2559 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
2564 /* Remember to save what IDENTIFIER's were bound in this scope so we
2565 can recover from cache misses. */
2567 previous_class_type = current_class_type;
2568 previous_class_values = class_binding_level->class_shadowed;
2570 for (shadowed = level->type_shadowed;
2572 shadowed = TREE_CHAIN (shadowed))
2573 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2575 /* Remove the bindings for all of the class-level declarations. */
2576 for (shadowed = level->class_shadowed;
2578 shadowed = TREE_CHAIN (shadowed))
2579 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
2581 /* Now, pop out of the binding level which we created up in the
2582 `pushlevel_class' routine. */
2583 if (ENABLE_SCOPE_CHECKING)
2587 timevar_pop (TV_NAME_LOOKUP);
2590 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
2591 binding was successful. */
2594 push_class_binding (tree id, tree decl)
2597 cxx_binding *binding = IDENTIFIER_BINDING (id);
2600 timevar_push (TV_NAME_LOOKUP);
2601 /* Note that we declared this value so that we can issue an error if
2602 this is an invalid redeclaration of a name already used for some
2604 note_name_declared_in_class (id, decl);
2606 if (binding && binding->scope == class_binding_level)
2607 /* Supplement the existing binding. */
2608 result = supplement_binding (IDENTIFIER_BINDING (id), decl);
2610 /* Create a new binding. */
2611 push_binding (id, decl, class_binding_level);
2613 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2614 class-level declaration. Note that we do not use DECL here
2615 because of the possibility of the `struct stat' hack; if DECL is
2616 a class-name or enum-name we might prefer a field-name, or some
2618 IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
2620 /* If this is a binding from a base class, mark it as such. */
2621 binding = IDENTIFIER_BINDING (id);
2622 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2624 if (TREE_CODE (decl) == OVERLOAD)
2625 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2628 my_friendly_assert (DECL_P (decl), 0);
2629 context = context_for_name_lookup (decl);
2632 if (is_properly_derived_from (current_class_type, context))
2633 INHERITED_VALUE_BINDING_P (binding) = 1;
2635 INHERITED_VALUE_BINDING_P (binding) = 0;
2637 else if (binding->value == decl)
2638 /* We only encounter a TREE_LIST when push_class_decls detects an
2639 ambiguity. Such an ambiguity can be overridden by a definition
2641 INHERITED_VALUE_BINDING_P (binding) = 1;
2643 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
2646 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
2647 for any names in enclosing classes. */
2650 clear_identifier_class_values (void)
2654 if (!class_binding_level)
2657 for (t = class_binding_level->class_shadowed;
2660 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
2663 /* Make the declaration of X appear in CLASS scope. */
2666 pushdecl_class_level (tree x)
2669 bool is_valid = true;
2671 timevar_push (TV_NAME_LOOKUP);
2672 /* Get the name of X. */
2673 if (TREE_CODE (x) == OVERLOAD)
2674 name = DECL_NAME (get_first_fn (x));
2676 name = DECL_NAME (x);
2680 is_valid = push_class_level_binding (name, x);
2681 if (TREE_CODE (x) == TYPE_DECL)
2682 set_identifier_type_value (name, x);
2684 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2686 /* If X is an anonymous aggregate, all of its members are
2687 treated as if they were members of the class containing the
2688 aggregate, for naming purposes. */
2691 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2693 location_t save_location = input_location;
2694 input_location = DECL_SOURCE_LOCATION (f);
2695 if (!pushdecl_class_level (f))
2697 input_location = save_location;
2700 timevar_pop (TV_NAME_LOOKUP);
2705 /* Make the declaration(s) of X appear in CLASS scope under the name
2706 NAME. Returns true if the binding is valid. */
2709 push_class_level_binding (tree name, tree x)
2711 cxx_binding *binding;
2713 timevar_push (TV_NAME_LOOKUP);
2714 /* The class_binding_level will be NULL if x is a template
2715 parameter name in a member template. */
2716 if (!class_binding_level)
2717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2719 /* Make sure that this new member does not have the same name
2720 as a template parameter. */
2721 if (TYPE_BEING_DEFINED (current_class_type))
2722 check_template_shadow (x);
2724 /* If this declaration shadows a declaration from an enclosing
2725 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2726 we leave this class. Record the shadowed declaration here. */
2727 binding = IDENTIFIER_BINDING (name);
2728 if (binding && binding->value)
2730 tree bval = binding->value;
2731 tree old_decl = NULL_TREE;
2733 if (INHERITED_VALUE_BINDING_P (binding))
2735 /* If the old binding was from a base class, and was for a
2736 tag name, slide it over to make room for the new binding.
2737 The old binding is still visible if explicitly qualified
2738 with a class-key. */
2739 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2740 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2742 old_decl = binding->type;
2743 binding->type = bval;
2744 binding->value = NULL_TREE;
2745 INHERITED_VALUE_BINDING_P (binding) = 0;
2750 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2752 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2753 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2754 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2756 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2757 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2763 /* Find the previous binding of name on the class-shadowed
2764 list, and update it. */
2765 for (shadow = class_binding_level->class_shadowed;
2767 shadow = TREE_CHAIN (shadow))
2768 if (TREE_PURPOSE (shadow) == name
2769 && TREE_TYPE (shadow) == old_decl)
2772 INHERITED_VALUE_BINDING_P (binding) = 0;
2773 TREE_TYPE (shadow) = x;
2774 IDENTIFIER_CLASS_VALUE (name) = x;
2775 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2780 /* If we didn't replace an existing binding, put the binding on the
2781 stack of bindings for the identifier, and update the shadowed list. */
2782 if (push_class_binding (name, x))
2784 class_binding_level->class_shadowed
2785 = tree_cons (name, NULL,
2786 class_binding_level->class_shadowed);
2787 /* Record the value we are binding NAME to so that we can know
2788 what to pop later. */
2789 TREE_TYPE (class_binding_level->class_shadowed) = x;
2790 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2793 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2797 do_class_using_decl (tree decl)
2799 tree name, value, scope, type;
2801 if (TREE_CODE (decl) != SCOPE_REF
2802 || !TREE_OPERAND (decl, 0)
2803 || !TYPE_P (TREE_OPERAND (decl, 0)))
2805 error ("using-declaration for non-member at class scope");
2808 scope = TREE_OPERAND (decl, 0);
2809 name = TREE_OPERAND (decl, 1);
2810 if (TREE_CODE (name) == BIT_NOT_EXPR)
2812 error ("using-declaration cannot name destructor");
2815 if (TREE_CODE (name) == TYPE_DECL)
2816 name = DECL_NAME (name);
2817 else if (TREE_CODE (name) == TEMPLATE_DECL)
2818 name = DECL_NAME (name);
2819 else if (BASELINK_P (name))
2821 tree fns = BASELINK_FUNCTIONS (name);
2822 name = DECL_NAME (get_first_fn (fns));
2825 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
2827 /* Dependent using decls have a NULL type, non-dependent ones have a
2829 type = dependent_type_p (scope) ? NULL_TREE : void_type_node;
2830 value = build_lang_decl (USING_DECL, name, type);
2831 DECL_INITIAL (value) = scope;
2836 set_class_shadows (tree shadows)
2838 class_binding_level->class_shadowed = shadows;
2841 /* Return the binding value for name in scope. */
2844 namespace_binding (tree name, tree scope)
2846 cxx_binding *binding;
2849 scope = global_namespace;
2850 scope = ORIGINAL_NAMESPACE (scope);
2851 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2853 return binding ? binding->value : NULL_TREE;
2856 /* Set the binding value for name in scope. */
2859 set_namespace_binding (tree name, tree scope, tree val)
2863 timevar_push (TV_NAME_LOOKUP);
2864 if (scope == NULL_TREE)
2865 scope = global_namespace;
2866 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2867 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2870 supplement_binding (b, val);
2871 timevar_pop (TV_NAME_LOOKUP);
2874 /* Compute the namespace where a declaration is defined. */
2877 decl_namespace (tree decl)
2879 timevar_push (TV_NAME_LOOKUP);
2881 decl = TYPE_STUB_DECL (decl);
2882 while (DECL_CONTEXT (decl))
2884 decl = DECL_CONTEXT (decl);
2885 if (TREE_CODE (decl) == NAMESPACE_DECL)
2886 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2888 decl = TYPE_STUB_DECL (decl);
2889 my_friendly_assert (DECL_P (decl), 390);
2892 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
2895 /* Set the context of a declaration to scope. Complain if we are not
2899 set_decl_namespace (tree decl, tree scope, bool friendp)
2903 /* Get rid of namespace aliases. */
2904 scope = ORIGINAL_NAMESPACE (scope);
2906 /* It is ok for friends to be qualified in parallel space. */
2907 if (!friendp && !is_ancestor (current_namespace, scope))
2908 error ("declaration of `%D' not in a namespace surrounding `%D'",
2910 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2911 if (scope != current_namespace)
2913 /* See whether this has been declared in the namespace. */
2914 old = namespace_binding (DECL_NAME (decl), scope);
2916 /* No old declaration at all. */
2918 /* A template can be explicitly specialized in any namespace. */
2919 if (processing_explicit_instantiation)
2921 if (!is_overloaded_fn (decl))
2922 /* Don't compare non-function decls with decls_match here,
2923 since it can't check for the correct constness at this
2924 point. pushdecl will find those errors later. */
2926 /* Since decl is a function, old should contain a function decl. */
2927 if (!is_overloaded_fn (old))
2929 if (processing_template_decl || processing_specialization)
2930 /* We have not yet called push_template_decl to turn a
2931 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
2932 won't match. But, we'll check later, when we construct the
2935 if (is_overloaded_fn (old))
2937 for (; old; old = OVL_NEXT (old))
2938 if (decls_match (decl, OVL_CURRENT (old)))
2942 if (decls_match (decl, old))
2948 error ("`%D' should have been declared inside `%D'",
2952 /* Return the namespace where the current declaration is declared. */
2955 current_decl_namespace (void)
2958 /* If we have been pushed into a different namespace, use it. */
2959 if (decl_namespace_list)
2960 return TREE_PURPOSE (decl_namespace_list);
2962 if (current_class_type)
2963 result = decl_namespace (TYPE_STUB_DECL (current_class_type));
2964 else if (current_function_decl)
2965 result = decl_namespace (current_function_decl);
2967 result = current_namespace;
2971 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2972 select a name that is unique to this compilation unit. */
2975 push_namespace (tree name)
2979 int implicit_use = 0;
2982 timevar_push (TV_NAME_LOOKUP);
2984 /* We should not get here if the global_namespace is not yet constructed
2985 nor if NAME designates the global namespace: The global scope is
2986 constructed elsewhere. */
2987 my_friendly_assert (global_namespace != NULL && name != global_scope_name,
2992 /* The name of anonymous namespace is unique for the translation
2994 if (!anonymous_namespace_name)
2995 anonymous_namespace_name = get_file_function_name ('N');
2996 name = anonymous_namespace_name;
2997 d = IDENTIFIER_NAMESPACE_VALUE (name);
2999 /* Reopening anonymous namespace. */
3005 /* Check whether this is an extended namespace definition. */
3006 d = IDENTIFIER_NAMESPACE_VALUE (name);
3007 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3010 if (DECL_NAMESPACE_ALIAS (d))
3012 error ("namespace alias `%D' not allowed here, assuming `%D'",
3013 d, DECL_NAMESPACE_ALIAS (d));
3014 d = DECL_NAMESPACE_ALIAS (d);
3021 /* Make a new namespace, binding the name to it. */
3022 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3023 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3027 /* Clear DECL_NAME for the benefit of debugging back ends. */
3028 SET_DECL_ASSEMBLER_NAME (d, name);
3029 DECL_NAME (d) = NULL_TREE;
3031 begin_scope (sk_namespace, d);
3034 resume_scope (NAMESPACE_LEVEL (d));
3037 do_using_directive (d);
3038 /* Enter the name space. */
3039 current_namespace = d;
3041 timevar_pop (TV_NAME_LOOKUP);
3044 /* Pop from the scope of the current namespace. */
3047 pop_namespace (void)
3049 my_friendly_assert (current_namespace != global_namespace, 20010801);
3050 current_namespace = CP_DECL_CONTEXT (current_namespace);
3051 /* The binding level is not popped, as it might be re-opened later. */
3055 /* Push into the scope of the namespace NS, even if it is deeply
3056 nested within another namespace. */
3059 push_nested_namespace (tree ns)
3061 if (ns == global_namespace)
3062 push_to_top_level ();
3065 push_nested_namespace (CP_DECL_CONTEXT (ns));
3066 push_namespace (DECL_NAME (ns));
3070 /* Pop back from the scope of the namespace NS, which was previously
3071 entered with push_nested_namespace. */
3074 pop_nested_namespace (tree ns)
3076 timevar_push (TV_NAME_LOOKUP);
3077 while (ns != global_namespace)
3080 ns = CP_DECL_CONTEXT (ns);
3083 pop_from_top_level ();
3084 timevar_pop (TV_NAME_LOOKUP);
3087 /* Temporarily set the namespace for the current declaration. */
3090 push_decl_namespace (tree decl)
3092 if (TREE_CODE (decl) != NAMESPACE_DECL)
3093 decl = decl_namespace (decl);
3094 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3095 NULL_TREE, decl_namespace_list);
3098 /* [namespace.memdef]/2 */
3101 pop_decl_namespace (void)
3103 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3106 /* Return the namespace that is the common ancestor
3107 of two given namespaces. */
3110 namespace_ancestor (tree ns1, tree ns2)
3112 timevar_push (TV_NAME_LOOKUP);
3113 if (is_ancestor (ns1, ns2))
3114 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3115 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3116 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3119 /* Process a namespace-alias declaration. */
3122 do_namespace_alias (tree alias, tree namespace)
3124 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3126 /* The parser did not find it, so it's not there. */
3127 error ("unknown namespace `%D'", namespace);
3131 namespace = ORIGINAL_NAMESPACE (namespace);
3133 /* Build the alias. */
3134 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3135 DECL_NAMESPACE_ALIAS (alias) = namespace;
3136 DECL_EXTERNAL (alias) = 1;
3140 /* Like pushdecl, only it places X in the current namespace,
3144 pushdecl_namespace_level (tree x)
3146 struct cp_binding_level *b = current_binding_level;
3149 timevar_push (TV_NAME_LOOKUP);
3150 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3152 /* Now, the type_shadowed stack may screw us. Munge it so it does
3154 if (TREE_CODE (x) == TYPE_DECL)
3156 tree name = DECL_NAME (x);
3158 tree *ptr = (tree *)0;
3159 for (; !global_scope_p (b); b = b->level_chain)
3161 tree shadowed = b->type_shadowed;
3162 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3163 if (TREE_PURPOSE (shadowed) == name)
3165 ptr = &TREE_VALUE (shadowed);
3166 /* Can't break out of the loop here because sometimes
3167 a binding level will have duplicate bindings for
3168 PT names. It's gross, but I haven't time to fix it. */
3171 newval = TREE_TYPE (x);
3172 if (ptr == (tree *)0)
3174 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3175 up here if this is changed to an assertion. --KR */
3176 SET_IDENTIFIER_TYPE_VALUE (name, x);
3183 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3186 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3187 directive is not directly from the source. Also find the common
3188 ancestor and let our users know about the new namespace */
3190 add_using_namespace (tree user, tree used, bool indirect)
3193 timevar_push (TV_NAME_LOOKUP);
3194 /* Using oneself is a no-op. */
3197 timevar_pop (TV_NAME_LOOKUP);
3200 my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3201 my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3202 /* Check if we already have this. */
3203 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3207 /* Promote to direct usage. */
3208 TREE_INDIRECT_USING (t) = 0;
3209 timevar_pop (TV_NAME_LOOKUP);
3213 /* Add used to the user's using list. */
3214 DECL_NAMESPACE_USING (user)
3215 = tree_cons (used, namespace_ancestor (user, used),
3216 DECL_NAMESPACE_USING (user));
3218 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3220 /* Add user to the used's users list. */
3221 DECL_NAMESPACE_USERS (used)
3222 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3224 /* Recursively add all namespaces used. */
3225 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3226 /* indirect usage */
3227 add_using_namespace (user, TREE_PURPOSE (t), 1);
3229 /* Tell everyone using us about the new used namespaces. */
3230 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3231 add_using_namespace (TREE_PURPOSE (t), used, 1);
3232 timevar_pop (TV_NAME_LOOKUP);
3235 /* Process a using-declaration not appearing in class or local scope. */
3238 do_toplevel_using_decl (tree decl, tree scope, tree name)
3240 tree oldval, oldtype, newval, newtype;
3241 cxx_binding *binding;
3243 decl = validate_nonmember_using_decl (decl, scope, name);
3244 if (decl == NULL_TREE)
3247 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3249 oldval = binding->value;
3250 oldtype = binding->type;
3252 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3254 /* Copy declarations found. */
3256 binding->value = newval;
3258 binding->type = newtype;
3262 /* Process a using-directive. */
3265 do_using_directive (tree namespace)
3267 if (building_stmt_tree ())
3268 add_stmt (build_stmt (USING_STMT, namespace));
3270 /* using namespace A::B::C; */
3271 if (TREE_CODE (namespace) == SCOPE_REF)
3272 namespace = TREE_OPERAND (namespace, 1);
3273 if (TREE_CODE (namespace) == IDENTIFIER_NODE)
3275 /* Lookup in lexer did not find a namespace. */
3276 if (!processing_template_decl)
3277 error ("namespace `%T' undeclared", namespace);
3280 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3282 if (!processing_template_decl)
3283 error ("`%T' is not a namespace", namespace);
3286 namespace = ORIGINAL_NAMESPACE (namespace);
3287 if (!toplevel_bindings_p ())
3288 push_using_directive (namespace);
3291 add_using_namespace (current_namespace, namespace, 0);
3294 /* Deal with a using-directive seen by the parser. Currently we only
3295 handle attributes here, since they cannot appear inside a template. */
3298 parse_using_directive (tree namespace, tree attribs)
3302 do_using_directive (namespace);
3304 for (a = attribs; a; a = TREE_CHAIN (a))
3306 tree name = TREE_PURPOSE (a);
3307 if (is_attribute_p ("strong", name))
3309 if (!toplevel_bindings_p ())
3310 error ("strong using only meaningful at namespace scope");
3312 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3313 = tree_cons (current_namespace, 0,
3314 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3317 warning ("`%D' attribute directive ignored", name);
3321 /* Like pushdecl, only it places X in the global scope if appropriate.
3322 Calls cp_finish_decl to register the variable, initializing it with
3323 *INIT, if INIT is non-NULL. */
3326 pushdecl_top_level_1 (tree x, tree *init)
3328 timevar_push (TV_NAME_LOOKUP);
3329 push_to_top_level ();
3330 x = pushdecl_namespace_level (x);
3332 cp_finish_decl (x, *init, NULL_TREE, 0);
3333 pop_from_top_level ();
3334 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3337 /* Like pushdecl, only it places X in the global scope if appropriate. */
3340 pushdecl_top_level (tree x)
3342 return pushdecl_top_level_1 (x, NULL);
3345 /* Like pushdecl, only it places X in the global scope if
3346 appropriate. Calls cp_finish_decl to register the variable,
3347 initializing it with INIT. */
3350 pushdecl_top_level_and_finish (tree x, tree init)
3352 return pushdecl_top_level_1 (x, &init);
3355 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3356 duplicates. The first list becomes the tail of the result.
3358 The algorithm is O(n^2). We could get this down to O(n log n) by
3359 doing a sort on the addresses of the functions, if that becomes
3363 merge_functions (tree s1, tree s2)
3365 for (; s2; s2 = OVL_NEXT (s2))
3367 tree fn2 = OVL_CURRENT (s2);
3370 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3372 tree fn1 = OVL_CURRENT (fns1);
3374 /* If the function from S2 is already in S1, there is no
3375 need to add it again. For `extern "C"' functions, we
3376 might have two FUNCTION_DECLs for the same function, in
3377 different namespaces; again, we only need one of them. */
3379 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3380 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3384 /* If we exhausted all of the functions in S1, FN2 is new. */
3386 s1 = build_overload (fn2, s1);
3391 /* This should return an error not all definitions define functions.
3392 It is not an error if we find two functions with exactly the
3393 same signature, only if these are selected in overload resolution.
3394 old is the current set of bindings, new the freshly-found binding.
3395 XXX Do we want to give *all* candidates in case of ambiguity?
3396 XXX In what way should I treat extern declarations?
3397 XXX I don't want to repeat the entire duplicate_decls here */
3399 static cxx_binding *
3400 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3403 my_friendly_assert (old != NULL, 393);
3404 /* Copy the value. */
3407 switch (TREE_CODE (val))
3410 /* If we expect types or namespaces, and not templates,
3411 or this is not a template class. */
3412 if (LOOKUP_QUALIFIERS_ONLY (flags)
3413 && !DECL_CLASS_TEMPLATE_P (val))
3417 if (LOOKUP_NAMESPACES_ONLY (flags))
3420 case NAMESPACE_DECL:
3421 if (LOOKUP_TYPES_ONLY (flags))
3425 /* Ignore built-in functions that are still anticipated. */
3426 if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3430 if (LOOKUP_QUALIFIERS_ONLY (flags))
3436 else if (val && val != old->value)
3438 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3439 old->value = merge_functions (old->value, val);
3442 /* Some declarations are functions, some are not. */
3443 if (flags & LOOKUP_COMPLAIN)
3445 /* If we've already given this error for this lookup,
3446 old->value is error_mark_node, so let's not
3447 repeat ourselves. */
3448 if (old->value != error_mark_node)
3450 error ("use of `%D' is ambiguous", name);
3451 cp_error_at (" first declared as `%#D' here",
3454 cp_error_at (" also declared as `%#D' here", val);
3456 old->value = error_mark_node;
3459 /* ... and copy the type. */
3461 if (LOOKUP_NAMESPACES_ONLY (flags))
3465 else if (type && old->type != type)
3467 if (flags & LOOKUP_COMPLAIN)
3469 error ("`%D' denotes an ambiguous type",name);
3470 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3471 error ("%J other type here", TYPE_MAIN_DECL (type));
3477 /* Return the declarations that are members of the namespace NS. */
3480 cp_namespace_decls (tree ns)
3482 return NAMESPACE_LEVEL (ns)->names;
3485 /* Combine prefer_type and namespaces_only into flags. */
3488 lookup_flags (int prefer_type, int namespaces_only)
3490 if (namespaces_only)
3491 return LOOKUP_PREFER_NAMESPACES;
3492 if (prefer_type > 1)
3493 return LOOKUP_PREFER_TYPES;
3494 if (prefer_type > 0)
3495 return LOOKUP_PREFER_BOTH;
3499 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3500 ignore it or not. Subroutine of lookup_name_real. */
3503 qualify_lookup (tree val, int flags)
3505 if (val == NULL_TREE)
3507 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3509 if ((flags & LOOKUP_PREFER_TYPES)
3510 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3512 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3517 /* Look up NAME in the NAMESPACE. */
3520 lookup_namespace_name (tree namespace, tree name)
3523 tree template_id = NULL_TREE;
3524 cxx_binding binding;
3526 timevar_push (TV_NAME_LOOKUP);
3527 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
3529 if (TREE_CODE (name) == NAMESPACE_DECL)
3530 /* This happens for A::B<int> when B is a namespace. */
3531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3532 else if (TREE_CODE (name) == TEMPLATE_DECL)
3534 /* This happens for A::B where B is a template, and there are no
3535 template arguments. */
3536 error ("invalid use of `%D'", name);
3537 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3540 namespace = ORIGINAL_NAMESPACE (namespace);
3542 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3545 name = TREE_OPERAND (name, 0);
3546 if (TREE_CODE (name) == OVERLOAD)
3547 name = DECL_NAME (OVL_CURRENT (name));
3548 else if (DECL_P (name))
3549 name = DECL_NAME (name);
3552 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
3554 cxx_binding_clear (&binding);
3555 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3556 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3560 val = binding.value;
3564 if (DECL_CLASS_TEMPLATE_P (val))
3565 val = lookup_template_class (val,
3566 TREE_OPERAND (template_id, 1),
3567 /*in_decl=*/NULL_TREE,
3568 /*context=*/NULL_TREE,
3569 /*entering_scope=*/0,
3570 tf_error | tf_warning);
3571 else if (DECL_FUNCTION_TEMPLATE_P (val)
3572 || TREE_CODE (val) == OVERLOAD)
3573 val = lookup_template_function (val,
3574 TREE_OPERAND (template_id, 1));
3577 error ("`%D::%D' is not a template",
3579 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3583 /* If we have a single function from a using decl, pull it out. */
3584 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3585 val = OVL_FUNCTION (val);
3587 /* Ignore built-in functions that haven't been prototyped yet. */
3588 if (!val || !DECL_P(val)
3589 || !DECL_LANG_SPECIFIC(val)
3590 || !DECL_ANTICIPATED (val))
3591 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3594 error ("`%D' undeclared in namespace `%D'", name, namespace);
3595 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3598 /* Select the right _DECL from multiple choices. */
3601 select_decl (cxx_binding *binding, int flags)
3604 val = binding->value;
3606 timevar_push (TV_NAME_LOOKUP);
3607 if (LOOKUP_NAMESPACES_ONLY (flags))
3609 /* We are not interested in types. */
3610 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3611 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3612 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3615 /* If looking for a type, or if there is no non-type binding, select
3616 the value binding. */
3617 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3618 val = binding->type;
3619 /* Don't return non-types if we really prefer types. */
3620 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
3621 && (TREE_CODE (val) != TEMPLATE_DECL
3622 || !DECL_CLASS_TEMPLATE_P (val)))
3625 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3628 /* Unscoped lookup of a global: iterate over current namespaces,
3629 considering using-directives. */
3632 unqualified_namespace_lookup (tree name, int flags)
3634 tree initial = current_decl_namespace ();
3635 tree scope = initial;
3637 struct cp_binding_level *level;
3638 tree val = NULL_TREE;
3639 cxx_binding binding;
3641 timevar_push (TV_NAME_LOOKUP);
3642 cxx_binding_clear (&binding);
3644 for (; !val; scope = CP_DECL_CONTEXT (scope))
3647 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3649 /* Ignore anticipated built-in functions. */
3650 if (b && b->value && DECL_P (b->value)
3651 && DECL_LANG_SPECIFIC (b->value) && DECL_ANTICIPATED (b->value))
3652 /* Keep binding cleared. */;
3655 /* Initialize binding for this context. */
3656 binding.value = b->value;
3657 binding.type = b->type;
3660 /* Add all _DECLs seen through local using-directives. */
3661 for (level = current_binding_level;
3662 level->kind != sk_namespace;
3663 level = level->level_chain)
3664 if (!lookup_using_namespace (name, &binding, level->using_directives,
3666 /* Give up because of error. */
3667 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3669 /* Add all _DECLs seen through global using-directives. */
3670 /* XXX local and global using lists should work equally. */
3674 if (!lookup_using_namespace (name, &binding,
3675 DECL_NAMESPACE_USING (siter),
3677 /* Give up because of error. */
3678 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3679 if (siter == scope) break;
3680 siter = CP_DECL_CONTEXT (siter);
3683 val = select_decl (&binding, flags);
3684 if (scope == global_namespace)
3687 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3690 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3691 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3694 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3695 declaration found. If no suitable declaration can be found,
3696 ERROR_MARK_NODE is returned. Iif COMPLAIN is true and SCOPE is
3697 neither a class-type nor a namespace a diagnostic is issued. */
3700 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3704 if (TREE_CODE (scope) == NAMESPACE_DECL)
3706 cxx_binding binding;
3708 cxx_binding_clear (&binding);
3709 flags |= LOOKUP_COMPLAIN;
3711 flags |= LOOKUP_PREFER_TYPES;
3712 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3713 return select_decl (&binding, flags);
3715 else if (is_aggr_type (scope, complain))
3718 t = lookup_member (scope, name, 0, is_type_p);
3723 return error_mark_node;
3726 /* Subroutine of unqualified_namespace_lookup:
3727 Add the bindings of NAME in used namespaces to VAL.
3728 We are currently looking for names in namespace SCOPE, so we
3729 look through USINGS for using-directives of namespaces
3730 which have SCOPE as a common ancestor with the current scope.
3731 Returns false on errors. */
3734 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3738 timevar_push (TV_NAME_LOOKUP);
3739 /* Iterate over all used namespaces in current, searching for using
3740 directives of scope. */
3741 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3742 if (TREE_VALUE (iter) == scope)
3744 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3746 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3747 /* Resolve ambiguities. */
3749 val = ambiguous_decl (name, val, val1, flags);
3751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3755 Accepts the NAME to lookup and its qualifying SCOPE.
3756 Returns the name/type pair found into the cxx_binding *RESULT,
3757 or false on error. */
3760 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3763 /* Maintain a list of namespaces visited... */
3764 tree seen = NULL_TREE;
3765 /* ... and a list of namespace yet to see. */
3766 tree todo = NULL_TREE;
3767 tree todo_maybe = NULL_TREE;
3769 timevar_push (TV_NAME_LOOKUP);
3770 /* Look through namespace aliases. */
3771 scope = ORIGINAL_NAMESPACE (scope);
3772 while (scope && result->value != error_mark_node)
3774 cxx_binding *binding =
3775 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3776 seen = tree_cons (scope, NULL_TREE, seen);
3778 result = ambiguous_decl (name, result, binding, flags);
3780 /* Consider strong using directives always, and non-strong ones
3781 if we haven't found a binding yet. ??? Shouldn't we consider
3782 non-strong ones if the initial RESULT is non-NULL, but the
3783 binding in the given namespace is? */
3784 for (usings = DECL_NAMESPACE_USING (scope); usings;
3785 usings = TREE_CHAIN (usings))
3786 /* If this was a real directive, and we have not seen it. */
3787 if (!TREE_INDIRECT_USING (usings))
3789 /* Try to avoid queuing the same namespace more than once,
3790 the exception being when a namespace was already
3791 enqueued for todo_maybe and then a strong using is
3792 found for it. We could try to remove it from
3793 todo_maybe, but it's probably not worth the effort. */
3794 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3795 && !purpose_member (TREE_PURPOSE (usings), seen)
3796 && !purpose_member (TREE_PURPOSE (usings), todo))
3797 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3798 else if ((!result->value && !result->type)
3799 && !purpose_member (TREE_PURPOSE (usings), seen)
3800 && !purpose_member (TREE_PURPOSE (usings), todo)
3801 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3802 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3807 scope = TREE_PURPOSE (todo);
3808 todo = TREE_CHAIN (todo);
3811 && (!result->value && !result->type))
3813 scope = TREE_PURPOSE (todo_maybe);
3814 todo = TREE_CHAIN (todo_maybe);
3815 todo_maybe = NULL_TREE;
3818 scope = NULL_TREE; /* If there never was a todo list. */
3820 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3823 /* Look up NAME in the current binding level and its superiors in the
3824 namespace of variables, functions and typedefs. Return a ..._DECL
3825 node of some kind representing its definition if there is only one
3826 such declaration, or return a TREE_LIST with all the overloaded
3827 definitions if there are many, or return 0 if it is undefined.
3829 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3830 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3831 Otherwise we prefer non-TYPE_DECLs.
3833 If NONCLASS is nonzero, we don't look for the NAME in class scope,
3834 using IDENTIFIER_CLASS_VALUE. */
3837 lookup_name_real (tree name, int prefer_type, int nonclass,
3838 int namespaces_only, int flags)
3841 tree val = NULL_TREE;
3843 timevar_push (TV_NAME_LOOKUP);
3844 /* Conversion operators are handled specially because ordinary
3845 unqualified name lookup will not find template conversion
3847 if (IDENTIFIER_TYPENAME_P (name))
3849 struct cp_binding_level *level;
3851 for (level = current_binding_level;
3852 level && level->kind != sk_namespace;
3853 level = level->level_chain)
3858 /* A conversion operator can only be declared in a class
3860 if (level->kind != sk_class)
3863 /* Lookup the conversion operator in the class. */
3864 class_type = level->this_entity;
3865 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3867 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3873 flags |= lookup_flags (prefer_type, namespaces_only);
3875 /* First, look in non-namespace scopes. */
3877 if (current_class_type == NULL_TREE)
3880 for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
3884 if (!LOCAL_BINDING_P (iter) && nonclass)
3885 /* We're not looking for class-scoped bindings, so keep going. */
3888 /* If this is the kind of thing we're looking for, we're done. */
3889 if (qualify_lookup (iter->value, flags))
3890 binding = iter->value;
3891 else if ((flags & LOOKUP_PREFER_TYPES)
3892 && qualify_lookup (iter->type, flags))
3893 binding = iter->type;
3895 binding = NULL_TREE;
3904 /* Now lookup in namespace scopes. */
3907 tree t = unqualified_namespace_lookup (name, flags);
3914 /* If we have a single function from a using decl, pull it out. */
3915 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3916 val = OVL_FUNCTION (val);
3919 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3923 lookup_name_nonclass (tree name)
3925 return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
3929 lookup_function_nonclass (tree name, tree args)
3931 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
3935 lookup_name (tree name, int prefer_type)
3937 return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
3940 /* Similar to `lookup_name' but look only in the innermost non-class
3944 lookup_name_current_level (tree name)
3946 struct cp_binding_level *b;
3949 timevar_push (TV_NAME_LOOKUP);
3950 b = innermost_nonclass_level ();
3952 if (b->kind == sk_namespace)
3954 t = IDENTIFIER_NAMESPACE_VALUE (name);
3956 /* extern "C" function() */
3957 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
3960 else if (IDENTIFIER_BINDING (name)
3961 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
3965 if (IDENTIFIER_BINDING (name)->scope == b)
3966 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
3968 if (b->kind == sk_cleanup)
3975 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3978 /* Like lookup_name_current_level, but for types. */
3981 lookup_type_current_level (tree name)
3985 timevar_push (TV_NAME_LOOKUP);
3986 my_friendly_assert (current_binding_level->kind != sk_namespace,
3989 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
3990 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
3992 struct cp_binding_level *b = current_binding_level;
3995 if (purpose_member (name, b->type_shadowed))
3996 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3997 REAL_IDENTIFIER_TYPE_VALUE (name));
3998 if (b->kind == sk_cleanup)
4005 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4008 /* [basic.lookup.koenig] */
4009 /* A nonzero return value in the functions below indicates an error. */
4019 static bool arg_assoc (struct arg_lookup*, tree);
4020 static bool arg_assoc_args (struct arg_lookup*, tree);
4021 static bool arg_assoc_type (struct arg_lookup*, tree);
4022 static bool add_function (struct arg_lookup *, tree);
4023 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4024 static bool arg_assoc_class (struct arg_lookup *, tree);
4025 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4027 /* Add a function to the lookup structure.
4028 Returns true on error. */
4031 add_function (struct arg_lookup *k, tree fn)
4033 /* We used to check here to see if the function was already in the list,
4034 but that's O(n^2), which is just too expensive for function lookup.
4035 Now we deal with the occasional duplicate in joust. In doing this, we
4036 assume that the number of duplicates will be small compared to the
4037 total number of functions being compared, which should usually be the
4040 /* We must find only functions, or exactly one non-function. */
4043 else if (fn == k->functions)
4045 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4046 k->functions = build_overload (fn, k->functions);
4049 tree f1 = OVL_CURRENT (k->functions);
4051 if (is_overloaded_fn (f1))
4053 fn = f1; f1 = f2; f2 = fn;
4055 cp_error_at ("`%D' is not a function,", f1);
4056 cp_error_at (" conflict with `%D'", f2);
4057 error (" in call to `%D'", k->name);
4064 /* Returns true iff CURRENT has declared itself to be an associated
4065 namespace of SCOPE via a strong using-directive (or transitive chain
4066 thereof). Both are namespaces. */
4069 is_associated_namespace (tree current, tree scope)
4071 tree seen = NULL_TREE;
4072 tree todo = NULL_TREE;
4076 if (scope == current)
4078 seen = tree_cons (scope, NULL_TREE, seen);
4079 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4080 if (!purpose_member (TREE_PURPOSE (t), seen))
4081 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4084 scope = TREE_PURPOSE (todo);
4085 todo = TREE_CHAIN (todo);
4092 /* Add functions of a namespace to the lookup structure.
4093 Returns true on error. */
4096 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4100 if (purpose_member (scope, k->namespaces))
4102 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4104 /* Check out our super-users. */
4105 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4106 value = TREE_CHAIN (value))
4107 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4110 value = namespace_binding (k->name, scope);
4114 for (; value; value = OVL_NEXT (value))
4115 if (add_function (k, OVL_CURRENT (value)))
4121 /* Adds everything associated with a template argument to the lookup
4122 structure. Returns true on error. */
4125 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4127 /* [basic.lookup.koenig]
4129 If T is a template-id, its associated namespaces and classes are
4130 ... the namespaces and classes associated with the types of the
4131 template arguments provided for template type parameters
4132 (excluding template template parameters); the namespaces in which
4133 any template template arguments are defined; and the classes in
4134 which any member templates used as template template arguments
4135 are defined. [Note: non-type template arguments do not
4136 contribute to the set of associated namespaces. ] */
4138 /* Consider first template template arguments. */
4139 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4140 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4142 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4144 tree ctx = CP_DECL_CONTEXT (arg);
4146 /* It's not a member template. */
4147 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4148 return arg_assoc_namespace (k, ctx);
4149 /* Otherwise, it must be member template. */
4151 return arg_assoc_class (k, ctx);
4153 /* It's not a template template argument, but it is a type template
4155 else if (TYPE_P (arg))
4156 return arg_assoc_type (k, arg);
4157 /* It's a non-type template argument. */
4162 /* Adds everything associated with class to the lookup structure.
4163 Returns true on error. */
4166 arg_assoc_class (struct arg_lookup *k, tree type)
4168 tree list, friends, context;
4171 /* Backend build structures, such as __builtin_va_list, aren't
4172 affected by all this. */
4173 if (!CLASS_TYPE_P (type))
4176 if (purpose_member (type, k->classes))
4178 k->classes = tree_cons (type, NULL_TREE, k->classes);
4180 context = decl_namespace (TYPE_MAIN_DECL (type));
4181 if (arg_assoc_namespace (k, context))
4184 /* Process baseclasses. */
4185 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4186 if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4189 /* Process friends. */
4190 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4191 list = TREE_CHAIN (list))
4192 if (k->name == FRIEND_NAME (list))
4193 for (friends = FRIEND_DECLS (list); friends;
4194 friends = TREE_CHAIN (friends))
4195 /* Only interested in global functions with potentially hidden
4196 (i.e. unqualified) declarations. */
4197 if (CP_DECL_CONTEXT (TREE_VALUE (friends)) == context)
4198 if (add_function (k, TREE_VALUE (friends)))
4201 /* Process template arguments. */
4202 if (CLASSTYPE_TEMPLATE_INFO (type))
4204 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4205 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4206 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4212 /* Adds everything associated with a given type.
4213 Returns 1 on error. */
4216 arg_assoc_type (struct arg_lookup *k, tree type)
4218 /* As we do not get the type of non-type dependent expressions
4219 right, we can end up with such things without a type. */
4223 if (TYPE_PTRMEM_P (type))
4225 /* Pointer to member: associate class type and value type. */
4226 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4228 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4230 else switch (TREE_CODE (type))
4243 if (TYPE_PTRMEMFUNC_P (type))
4244 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4245 return arg_assoc_class (k, type);
4247 case REFERENCE_TYPE:
4249 return arg_assoc_type (k, TREE_TYPE (type));
4252 return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4254 /* The basetype is referenced in the first arg type, so just
4257 /* Associate the parameter types. */
4258 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4260 /* Associate the return type. */
4261 return arg_assoc_type (k, TREE_TYPE (type));
4262 case TEMPLATE_TYPE_PARM:
4263 case BOUND_TEMPLATE_TEMPLATE_PARM:
4268 if (type == unknown_type_node)
4270 /* else fall through */
4277 /* Adds everything associated with arguments. Returns true on error. */
4280 arg_assoc_args (struct arg_lookup *k, tree args)
4282 for (; args; args = TREE_CHAIN (args))
4283 if (arg_assoc (k, TREE_VALUE (args)))
4288 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4291 arg_assoc (struct arg_lookup *k, tree n)
4293 if (n == error_mark_node)
4297 return arg_assoc_type (k, n);
4299 if (! type_unknown_p (n))
4300 return arg_assoc_type (k, TREE_TYPE (n));
4302 if (TREE_CODE (n) == ADDR_EXPR)
4303 n = TREE_OPERAND (n, 0);
4304 if (TREE_CODE (n) == COMPONENT_REF)
4305 n = TREE_OPERAND (n, 1);
4306 if (TREE_CODE (n) == OFFSET_REF)
4307 n = TREE_OPERAND (n, 1);
4308 while (TREE_CODE (n) == TREE_LIST)
4310 if (TREE_CODE (n) == BASELINK)
4311 n = BASELINK_FUNCTIONS (n);
4313 if (TREE_CODE (n) == FUNCTION_DECL)
4314 return arg_assoc_type (k, TREE_TYPE (n));
4315 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4317 /* [basic.lookup.koenig]
4319 If T is a template-id, its associated namespaces and classes
4320 are the namespace in which the template is defined; for
4321 member templates, the member template's class... */
4322 tree template = TREE_OPERAND (n, 0);
4323 tree args = TREE_OPERAND (n, 1);
4327 if (TREE_CODE (template) == COMPONENT_REF)
4328 template = TREE_OPERAND (template, 1);
4330 /* First, the template. There may actually be more than one if
4331 this is an overloaded function template. But, in that case,
4332 we only need the first; all the functions will be in the same
4334 template = OVL_CURRENT (template);
4336 ctx = CP_DECL_CONTEXT (template);
4338 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4340 if (arg_assoc_namespace (k, ctx) == 1)
4343 /* It must be a member template. */
4344 else if (arg_assoc_class (k, ctx) == 1)
4347 /* Now the arguments. */
4348 for (ix = TREE_VEC_LENGTH (args); ix--;)
4349 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4354 my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4356 for (; n; n = OVL_CHAIN (n))
4357 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4364 /* Performs Koenig lookup depending on arguments, where fns
4365 are the functions found in normal lookup. */
4368 lookup_arg_dependent (tree name, tree fns, tree args)
4370 struct arg_lookup k;
4371 tree fn = NULL_TREE;
4373 timevar_push (TV_NAME_LOOKUP);
4376 k.classes = NULL_TREE;
4378 /* We've already looked at some namespaces during normal unqualified
4379 lookup -- but we don't know exactly which ones. If the functions
4380 we found were brought into the current namespace via a using
4381 declaration, we have not really checked the namespace from which
4382 they came. Therefore, we check all namespaces here -- unless the
4383 function we have is from the current namespace. */
4385 fn = OVL_CURRENT (fns);
4386 if (fn && TREE_CODE (fn) == FUNCTION_DECL
4387 && CP_DECL_CONTEXT (fn) != current_decl_namespace ())
4388 k.namespaces = NULL_TREE;
4390 /* Setting NAMESPACES is purely an optimization; it prevents
4391 adding functions which are already in FNS. Adding them would
4392 be safe -- "joust" will eliminate the duplicates -- but
4394 k.namespaces = build_tree_list (current_decl_namespace (), NULL_TREE);
4396 arg_assoc_args (&k, args);
4397 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4400 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4401 changed (i.e. there was already a directive), or the fresh
4402 TREE_LIST otherwise. */
4405 push_using_directive (tree used)
4407 tree ud = current_binding_level->using_directives;
4408 tree iter, ancestor;
4410 timevar_push (TV_NAME_LOOKUP);
4411 /* Check if we already have this. */
4412 if (purpose_member (used, ud) != NULL_TREE)
4413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4415 ancestor = namespace_ancestor (current_decl_namespace (), used);
4416 ud = current_binding_level->using_directives;
4417 ud = tree_cons (used, ancestor, ud);
4418 current_binding_level->using_directives = ud;
4420 /* Recursively add all namespaces used. */
4421 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4422 push_using_directive (TREE_PURPOSE (iter));
4424 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4427 /* The type TYPE is being declared. If it is a class template, or a
4428 specialization of a class template, do any processing required and
4429 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4430 being declared a friend. B is the binding level at which this TYPE
4433 Returns the TYPE_DECL for TYPE, which may have been altered by this
4437 maybe_process_template_type_declaration (tree type, int globalize,
4440 tree decl = TYPE_NAME (type);
4442 if (processing_template_parmlist)
4443 /* You can't declare a new template type in a template parameter
4444 list. But, you can declare a non-template type:
4446 template <class A*> struct S;
4448 is a forward-declaration of `A'. */
4452 maybe_check_template_type (type);
4454 my_friendly_assert (IS_AGGR_TYPE (type)
4455 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
4458 if (processing_template_decl)
4460 /* This may change after the call to
4461 push_template_decl_real, but we want the original value. */
4462 tree name = DECL_NAME (decl);
4464 decl = push_template_decl_real (decl, globalize);
4465 /* If the current binding level is the binding level for the
4466 template parameters (see the comment in
4467 begin_template_parm_list) and the enclosing level is a class
4468 scope, and we're not looking at a friend, push the
4469 declaration of the member class into the class scope. In the
4470 friend case, push_template_decl will already have put the
4471 friend into global scope, if appropriate. */
4472 if (TREE_CODE (type) != ENUMERAL_TYPE
4473 && !globalize && b->kind == sk_template_parms
4474 && b->level_chain->kind == sk_class)
4476 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4477 /* Put this UDT in the table of UDTs for the class, since
4478 that won't happen below because B is not the class
4479 binding level, but is instead the pseudo-global level. */
4480 if (b->level_chain->type_decls == NULL)
4481 b->level_chain->type_decls =
4482 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4483 binding_table_insert (b->level_chain->type_decls, name, type);
4484 if (!COMPLETE_TYPE_P (current_class_type))
4486 maybe_add_class_template_decl_list (current_class_type,
4487 type, /*friend_p=*/0);
4488 CLASSTYPE_NESTED_UTDS (current_class_type) =
4489 b->level_chain->type_decls;
4498 /* Push a tag name NAME for struct/class/union/enum type TYPE.
4499 Normally put it into the inner-most non-sk_cleanup scope,
4500 but if GLOBALIZE is true, put it in the inner-most non-class scope.
4501 The latter is needed for implicit declarations. */
4504 pushtag (tree name, tree type, int globalize)
4506 struct cp_binding_level *b;
4508 timevar_push (TV_NAME_LOOKUP);
4509 b = current_binding_level;
4510 while (b->kind == sk_cleanup
4511 || (b->kind == sk_class
4513 /* We may be defining a new type in the initializer
4514 of a static member variable. We allow this when
4515 not pedantic, and it is particularly useful for
4516 type punning via an anonymous union. */
4517 || COMPLETE_TYPE_P (b->this_entity))))
4520 if (b->type_decls == NULL)
4521 b->type_decls = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4522 binding_table_insert (b->type_decls, name, type);
4526 /* Do C++ gratuitous typedefing. */
4527 if (IDENTIFIER_TYPE_VALUE (name) != type)
4531 tree context = TYPE_CONTEXT (type);
4535 tree cs = current_scope ();
4539 else if (cs != NULL_TREE && TYPE_P (cs))
4540 /* When declaring a friend class of a local class, we want
4541 to inject the newly named class into the scope
4542 containing the local class, not the namespace scope. */
4543 context = decl_function_context (get_type_decl (cs));
4546 context = current_namespace;
4548 if (b->kind == sk_class
4549 || (b->kind == sk_template_parms
4550 && b->level_chain->kind == sk_class))
4553 if (current_lang_name == lang_name_java)
4554 TYPE_FOR_JAVA (type) = 1;
4556 d = create_implicit_typedef (name, type);
4557 DECL_CONTEXT (d) = FROB_CONTEXT (context);
4559 set_identifier_type_value_with_scope (name, d, b);
4561 d = maybe_process_template_type_declaration (type,
4564 if (b->kind == sk_class)
4566 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4567 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4568 class. But if it's a member template class, we
4569 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4571 finish_member_declaration (d);
4573 pushdecl_class_level (d);
4576 d = pushdecl_with_scope (d, b);
4578 /* FIXME what if it gets a name from typedef? */
4579 if (ANON_AGGRNAME_P (name))
4580 DECL_IGNORED_P (d) = 1;
4582 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
4584 /* If this is a local class, keep track of it. We need this
4585 information for name-mangling, and so that it is possible to find
4586 all function definitions in a translation unit in a convenient
4587 way. (It's otherwise tricky to find a member function definition
4588 it's only pointed to from within a local class.) */
4589 if (TYPE_CONTEXT (type)
4590 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
4591 && !processing_template_decl)
4592 VARRAY_PUSH_TREE (local_classes, type);
4594 if (b->kind == sk_class
4595 && !COMPLETE_TYPE_P (current_class_type))
4597 maybe_add_class_template_decl_list (current_class_type,
4598 type, /*friend_p=*/0);
4599 CLASSTYPE_NESTED_UTDS (current_class_type) = b->type_decls;
4603 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
4604 /* Use the canonical TYPE_DECL for this node. */
4605 TYPE_STUB_DECL (type) = TYPE_NAME (type);
4608 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4609 will be the tagged type we just added to the current
4610 binding level. This fake NULL-named TYPE_DECL node helps
4611 dwarfout.c to know when it needs to output a
4612 representation of a tagged type, and it also gives us a
4613 convenient place to record the "scope start" address for
4616 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
4617 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
4619 timevar_pop (TV_NAME_LOOKUP);
4622 /* Allocate storage for saving a C++ binding. */
4623 #define cxx_saved_binding_make() \
4624 (ggc_alloc (sizeof (cxx_saved_binding)))
4626 struct cxx_saved_binding GTY(())
4628 /* Link that chains saved C++ bindings for a given name into a stack. */
4629 cxx_saved_binding *previous;
4630 /* The name of the current binding. */
4632 /* The binding we're saving. */
4633 cxx_binding *binding;
4635 tree real_type_value;
4638 /* Subroutines for reverting temporarily to top-level for instantiation
4639 of templates and such. We actually need to clear out the class- and
4640 local-value slots of all identifiers, so that only the global values
4641 are at all visible. Simply setting current_binding_level to the global
4642 scope isn't enough, because more binding levels may be pushed. */
4643 struct saved_scope *scope_chain;
4645 static cxx_saved_binding *
4646 store_bindings (tree names, cxx_saved_binding *old_bindings)
4649 cxx_saved_binding *search_bindings = old_bindings;
4651 timevar_push (TV_NAME_LOOKUP);
4652 for (t = names; t; t = TREE_CHAIN (t))
4655 cxx_saved_binding *saved;
4656 cxx_saved_binding *t1;
4658 if (TREE_CODE (t) == TREE_LIST)
4659 id = TREE_PURPOSE (t);
4664 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
4665 we have no IDENTIFIER_BINDING if we have left the class
4666 scope, but cached the class-level declarations. */
4667 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
4670 for (t1 = search_bindings; t1; t1 = t1->previous)
4671 if (t1->identifier == id)
4674 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
4675 saved = cxx_saved_binding_make ();
4676 saved->previous = old_bindings;
4677 saved->identifier = id;
4678 saved->binding = IDENTIFIER_BINDING (id);
4679 saved->class_value = IDENTIFIER_CLASS_VALUE (id);;
4680 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4681 IDENTIFIER_BINDING (id) = NULL;
4682 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
4683 old_bindings = saved;
4687 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
4691 push_to_top_level (void)
4693 struct saved_scope *s;
4694 struct cp_binding_level *b;
4695 cxx_saved_binding *old_bindings;
4698 timevar_push (TV_NAME_LOOKUP);
4699 s = ggc_alloc_cleared (sizeof (struct saved_scope));
4701 b = scope_chain ? current_binding_level : 0;
4703 /* If we're in the middle of some function, save our state. */
4707 push_function_context_to (NULL_TREE);
4712 old_bindings = NULL;
4713 if (scope_chain && previous_class_type)
4714 old_bindings = store_bindings (previous_class_values, old_bindings);
4716 /* Have to include the global scope, because class-scope decls
4717 aren't listed anywhere useful. */
4718 for (; b; b = b->level_chain)
4722 /* Template IDs are inserted into the global level. If they were
4723 inserted into namespace level, finish_file wouldn't find them
4724 when doing pending instantiations. Therefore, don't stop at
4725 namespace level, but continue until :: . */
4726 if (global_scope_p (b))
4729 old_bindings = store_bindings (b->names, old_bindings);
4730 /* We also need to check class_shadowed to save class-level type
4731 bindings, since pushclass doesn't fill in b->names. */
4732 if (b->kind == sk_class)
4733 old_bindings = store_bindings (b->class_shadowed, old_bindings);
4735 /* Unwind type-value slots back to top level. */
4736 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4737 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4739 s->prev = scope_chain;
4740 s->old_bindings = old_bindings;
4742 s->need_pop_function_context = need_pop;
4743 s->function_decl = current_function_decl;
4744 s->last_parms = last_function_parms;
4747 current_function_decl = NULL_TREE;
4748 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
4749 current_lang_name = lang_name_cplusplus;
4750 current_namespace = global_namespace;
4751 timevar_pop (TV_NAME_LOOKUP);
4755 pop_from_top_level (void)
4757 struct saved_scope *s = scope_chain;
4758 cxx_saved_binding *saved;
4760 timevar_push (TV_NAME_LOOKUP);
4761 /* Clear out class-level bindings cache. */
4762 if (previous_class_type)
4763 invalidate_class_lookup_cache ();
4765 current_lang_base = 0;
4767 scope_chain = s->prev;
4768 for (saved = s->old_bindings; saved; saved = saved->previous)
4770 tree id = saved->identifier;
4772 IDENTIFIER_BINDING (id) = saved->binding;
4773 IDENTIFIER_CLASS_VALUE (id) = saved->class_value;
4774 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
4777 /* If we were in the middle of compiling a function, restore our
4779 if (s->need_pop_function_context)
4780 pop_function_context_from (NULL_TREE);
4781 current_function_decl = s->function_decl;
4782 last_function_parms = s->last_parms;
4783 timevar_pop (TV_NAME_LOOKUP);
4786 /* Pop off extraneous binding levels left over due to syntax errors.
4788 We don't pop past namespaces, as they might be valid. */
4791 pop_everything (void)
4793 if (ENABLE_SCOPE_CHECKING)
4794 verbatim ("XXX entering pop_everything ()\n");
4795 while (!toplevel_bindings_p ())
4797 if (current_binding_level->kind == sk_class)
4798 pop_nested_class ();
4802 if (ENABLE_SCOPE_CHECKING)
4803 verbatim ("XXX leaving pop_everything ()\n");
4806 #include "gt-cp-name-lookup.h"