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"
35 static cxx_scope *innermost_nonclass_level (void);
36 static tree select_decl (cxx_binding *, int);
37 static cxx_binding *binding_for_name (cxx_scope *, tree);
38 static tree lookup_name_current_level (tree);
39 static void push_local_binding (tree, tree, int);
40 static tree push_overloaded_decl (tree, int);
41 static bool lookup_using_namespace (tree, cxx_binding *, tree,
43 static bool qualified_lookup_using_namespace (tree, tree, cxx_binding *, int);
44 static tree lookup_type_current_level (tree);
45 static tree push_using_directive (tree);
46 static void cp_emit_debug_info_for_using (tree, tree);
48 /* The :: namespace. */
50 tree global_namespace;
52 /* The name of the anonymous namespace, throughout this translation
54 GTY(()) tree anonymous_namespace_name;
57 /* Compute the chain index of a binding_entry given the HASH value of its
58 name and the total COUNT of chains. COUNT is assumed to be a power
61 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
63 /* A free list of "binding_entry"s awaiting for re-use. */
65 static GTY((deletable(""))) binding_entry free_binding_entry = NULL;
67 /* Create a binding_entry object for (NAME, TYPE). */
69 static inline binding_entry
70 binding_entry_make (tree name, tree type)
74 if (free_binding_entry)
76 entry = free_binding_entry;
77 free_binding_entry = entry->chain;
80 entry = ggc_alloc (sizeof (struct binding_entry_s));
89 /* Put ENTRY back on the free list. */
92 binding_entry_free (binding_entry entry)
96 entry->chain = free_binding_entry;
97 free_binding_entry = entry;
100 /* The datatype used to implement the mapping from names to types at
102 struct binding_table_s GTY(())
104 /* Array of chains of "binding_entry"s */
105 binding_entry * GTY((length ("%h.chain_count"))) chain;
107 /* The number of chains in this table. This is the length of the
108 the member "chain" considered as an array. */
111 /* Number of "binding_entry"s in this table. */
115 /* Construct TABLE with an initial CHAIN_COUNT. */
118 binding_table_construct (binding_table table, size_t chain_count)
120 table->chain_count = chain_count;
121 table->entry_count = 0;
122 table->chain = ggc_alloc_cleared
123 (table->chain_count * sizeof (binding_entry));
126 /* Make TABLE's entries ready for reuse. */
129 binding_table_free (binding_table table)
137 for (i = 0, count = table->chain_count; i < count; ++i)
139 binding_entry temp = table->chain[i];
142 binding_entry entry = temp;
144 binding_entry_free (entry);
146 table->chain[i] = NULL;
148 table->entry_count = 0;
151 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
153 static inline binding_table
154 binding_table_new (size_t chain_count)
156 binding_table table = ggc_alloc (sizeof (struct binding_table_s));
158 binding_table_construct (table, chain_count);
162 /* Expand TABLE to twice its current chain_count. */
165 binding_table_expand (binding_table table)
167 const size_t old_chain_count = table->chain_count;
168 const size_t old_entry_count = table->entry_count;
169 const size_t new_chain_count = 2 * old_chain_count;
170 binding_entry *old_chains = table->chain;
173 binding_table_construct (table, new_chain_count);
174 for (i = 0; i < old_chain_count; ++i)
176 binding_entry entry = old_chains[i];
177 for (; entry != NULL; entry = old_chains[i])
179 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
180 const size_t j = ENTRY_INDEX (hash, new_chain_count);
182 old_chains[i] = entry->chain;
183 entry->chain = table->chain[j];
184 table->chain[j] = entry;
187 table->entry_count = old_entry_count;
190 /* Insert a binding for NAME to TYPE into TABLE. */
193 binding_table_insert (binding_table table, tree name, tree type)
195 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
196 const size_t i = ENTRY_INDEX (hash, table->chain_count);
197 binding_entry entry = binding_entry_make (name, type);
199 entry->chain = table->chain[i];
200 table->chain[i] = entry;
201 ++table->entry_count;
203 if (3 * table->chain_count < 5 * table->entry_count)
204 binding_table_expand (table);
207 /* Return the binding_entry, if any, that maps NAME. */
210 binding_table_find (binding_table table, tree name)
212 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
213 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
215 while (entry != NULL && entry->name != name)
216 entry = entry->chain;
221 /* Return the binding_entry, if any, that maps NAME to an anonymous type. */
224 binding_table_find_anon_type (binding_table table, tree name)
226 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
227 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
229 while (entry != NULL && TYPE_IDENTIFIER (entry->type) != name)
230 entry = entry->chain;
232 return entry ? entry->type : NULL;
235 /* Return the binding_entry, if any, that has TYPE as target. If NAME
236 is non-null, then set the domain and rehash that entry. */
239 binding_table_reverse_maybe_remap (binding_table table, tree type, tree name)
241 const size_t chain_count = table->chain_count;
242 binding_entry entry = NULL;
243 binding_entry *p = NULL;
246 for (i = 0; i < chain_count && entry == NULL; ++i)
248 p = &table->chain[i];
249 while (*p != NULL && entry == NULL)
250 if ((*p)->type == type)
256 if (entry != NULL && name != NULL && entry->name != name)
258 /* Remove the bucket from the previous chain. */
261 /* Remap the name type to type. */
262 i = ENTRY_INDEX (IDENTIFIER_HASH_VALUE (name), chain_count);
263 entry->chain = table->chain[i];
265 table->chain[i] = entry;
271 /* Remove from TABLE all entries that map to anonymous enums or
275 binding_table_remove_anonymous_types (binding_table table)
277 const size_t chain_count = table->chain_count;
280 for (i = 0; i < chain_count; ++i)
282 binding_entry *p = &table->chain[i];
285 if (ANON_AGGRNAME_P ((*p)->name))
287 binding_entry e = *p;
289 --table->entry_count;
290 binding_entry_free (e);
297 /* Apply PROC -- with DATA -- to all entries in TABLE. */
300 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
302 const size_t chain_count = table->chain_count;
305 for (i = 0; i < chain_count; ++i)
307 binding_entry entry = table->chain[i];
308 for (; entry != NULL; entry = entry->chain)
313 #ifndef ENABLE_SCOPE_CHECKING
314 # define ENABLE_SCOPE_CHECKING 0
316 # define ENABLE_SCOPE_CHECKING 1
319 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
321 static GTY((deletable (""))) cxx_binding *free_bindings;
323 /* Zero out a cxx_binding pointed to by B. */
324 #define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))
326 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
329 cxx_binding_make (tree value, tree type)
331 cxx_binding *binding;
334 binding = free_bindings;
335 free_bindings = binding->previous;
338 binding = ggc_alloc (sizeof (cxx_binding));
340 binding->value = value;
341 binding->type = type;
342 binding->previous = NULL;
347 /* Put BINDING back on the free list. */
350 cxx_binding_free (cxx_binding *binding)
352 binding->scope = NULL;
353 binding->previous = free_bindings;
354 free_bindings = binding;
357 /* Make DECL the innermost binding for ID. The LEVEL is the binding
358 level at which this declaration is being bound. */
361 push_binding (tree id, tree decl, cxx_scope* level)
363 cxx_binding *binding = cxx_binding_make (decl, NULL);
365 /* Now, fill in the binding information. */
366 binding->previous = IDENTIFIER_BINDING (id);
367 binding->scope = level;
368 INHERITED_VALUE_BINDING_P (binding) = 0;
369 LOCAL_BINDING_P (binding) = (level != class_binding_level);
371 /* And put it on the front of the list of bindings for ID. */
372 IDENTIFIER_BINDING (id) = binding;
375 /* Remove the binding for DECL which should be the innermost binding
379 pop_binding (tree id, tree decl)
381 cxx_binding *binding;
384 /* It's easiest to write the loops that call this function without
385 checking whether or not the entities involved have names. We
386 get here for such an entity. */
389 /* Get the innermost binding for ID. */
390 binding = IDENTIFIER_BINDING (id);
392 /* The name should be bound. */
393 my_friendly_assert (binding != NULL, 0);
395 /* The DECL will be either the ordinary binding or the type
396 binding for this identifier. Remove that binding. */
397 if (binding->value == decl)
398 binding->value = NULL_TREE;
399 else if (binding->type == decl)
400 binding->type = NULL_TREE;
404 if (!binding->value && !binding->type)
406 /* We're completely done with the innermost binding for this
407 identifier. Unhook it from the list of bindings. */
408 IDENTIFIER_BINDING (id) = binding->previous;
410 /* Add it to the free list. */
411 cxx_binding_free (binding);
415 /* BINDING records an existing declaration for a namein the current scope.
416 But, DECL is another declaration for that same identifier in the
417 same scope. This is the `struct stat' hack whereby a non-typedef
418 class name or enum-name can be bound at the same level as some other
422 A class name (9.1) or enumeration name (7.2) can be hidden by the
423 name of an object, function, or enumerator declared in the same scope.
424 If a class or enumeration name and an object, function, or enumerator
425 are declared in the same scope (in any order) with the same name, the
426 class or enumeration name is hidden wherever the object, function, or
427 enumerator name is visible.
429 It's the responsibility of the caller to check that
430 inserting this name is valid here. Returns nonzero if the new binding
434 supplement_binding (cxx_binding *binding, tree decl)
436 tree bval = binding->value;
439 timevar_push (TV_NAME_LOOKUP);
440 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
441 /* The new name is the type name. */
442 binding->type = decl;
443 else if (!bval || bval == error_mark_node)
444 /* VALUE is null when push_class_level_binding moves an inherited
445 type-binding out of the way to make room for a new value binding.
446 It is an error_mark_node when DECL's name has been used in a
447 non-class scope prior declaration. In that case, we should have
448 already issued a diagnostic; for graceful error recovery purpose,
449 pretend this was the intended declaration for that name. */
450 binding->value = decl;
451 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
453 /* The old binding was a type name. It was placed in
454 VALUE field because it was thought, at the point it was
455 declared, to be the only entity with such a name. Move the
456 type name into the type slot; it is now hidden by the new
458 binding->type = bval;
459 binding->value = decl;
460 binding->value_is_inherited = false;
462 else if (TREE_CODE (bval) == TYPE_DECL
463 && TREE_CODE (decl) == TYPE_DECL
464 && DECL_NAME (decl) == DECL_NAME (bval)
465 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
466 /* If either type involves template parameters, we must
467 wait until instantiation. */
468 || uses_template_parms (TREE_TYPE (decl))
469 || uses_template_parms (TREE_TYPE (bval))))
470 /* We have two typedef-names, both naming the same type to have
471 the same name. This is OK because of:
475 In a given scope, a typedef specifier can be used to redefine
476 the name of any type declared in that scope to refer to the
477 type to which it already refers. */
479 /* There can be two block-scope declarations of the same variable,
480 so long as they are `extern' declarations. However, there cannot
481 be two declarations of the same static data member:
485 A member shall not be declared twice in the
486 member-specification. */
487 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
488 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
489 && !DECL_CLASS_SCOPE_P (decl))
491 duplicate_decls (decl, binding->value);
496 error ("declaration of `%#D'", decl);
497 cp_error_at ("conflicts with previous declaration `%#D'",
502 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
505 /* Add DECL to the list of things declared in B. */
508 add_decl_to_level (tree decl, cxx_scope *b)
510 if (TREE_CODE (decl) == NAMESPACE_DECL
511 && !DECL_NAMESPACE_ALIAS (decl))
513 TREE_CHAIN (decl) = b->namespaces;
514 b->namespaces = decl;
516 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
518 TREE_CHAIN (decl) = b->vtables;
523 /* We build up the list in reverse order, and reverse it later if
525 TREE_CHAIN (decl) = b->names;
529 /* If appropriate, add decl to separate list of statics. */
530 if (b->kind == sk_namespace)
531 if ((TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
532 || (TREE_CODE (decl) == FUNCTION_DECL
533 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
534 VARRAY_PUSH_TREE (b->static_decls, decl);
538 /* Record a decl-node X as belonging to the current lexical scope.
539 Check for errors (such as an incompatible declaration for the same
540 name already seen in the same scope).
542 Returns either X or an old decl for the same name.
543 If an old decl is returned, it may have been smashed
544 to agree with what X says. */
551 int need_new_binding;
553 timevar_push (TV_NAME_LOOKUP);
555 need_new_binding = 1;
557 if (DECL_TEMPLATE_PARM_P (x))
558 /* Template parameters have no context; they are not X::T even
559 when declared within a class or namespace. */
563 if (current_function_decl && x != current_function_decl
564 /* A local declaration for a function doesn't constitute
566 && TREE_CODE (x) != FUNCTION_DECL
567 /* A local declaration for an `extern' variable is in the
568 scope of the current namespace, not the current
570 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
571 && !DECL_CONTEXT (x))
572 DECL_CONTEXT (x) = current_function_decl;
574 /* If this is the declaration for a namespace-scope function,
575 but the declaration itself is in a local scope, mark the
577 if (TREE_CODE (x) == FUNCTION_DECL
578 && DECL_NAMESPACE_SCOPE_P (x)
579 && current_function_decl
580 && x != current_function_decl)
581 DECL_LOCAL_FUNCTION_P (x) = 1;
584 name = DECL_NAME (x);
587 int different_binding_level = 0;
589 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
590 name = TREE_OPERAND (name, 0);
592 /* In case this decl was explicitly namespace-qualified, look it
593 up in its namespace context. */
594 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
595 t = namespace_binding (name, DECL_CONTEXT (x));
597 t = lookup_name_current_level (name);
599 /* [basic.link] If there is a visible declaration of an entity
600 with linkage having the same name and type, ignoring entities
601 declared outside the innermost enclosing namespace scope, the
602 block scope declaration declares that same entity and
603 receives the linkage of the previous declaration. */
604 if (! t && current_function_decl && x != current_function_decl
605 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
606 && DECL_EXTERNAL (x))
608 /* Look in block scope. */
609 t = IDENTIFIER_VALUE (name);
610 /* Or in the innermost namespace. */
612 t = namespace_binding (name, DECL_CONTEXT (x));
613 /* Does it have linkage? Note that if this isn't a DECL, it's an
614 OVERLOAD, which is OK. */
615 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
618 different_binding_level = 1;
621 /* If we are declaring a function, and the result of name-lookup
622 was an OVERLOAD, look for an overloaded instance that is
623 actually the same as the function we are declaring. (If
624 there is one, we have to merge our declaration with the
625 previous declaration.) */
626 if (t && TREE_CODE (t) == OVERLOAD)
630 if (TREE_CODE (x) == FUNCTION_DECL)
631 for (match = t; match; match = OVL_NEXT (match))
633 if (decls_match (OVL_CURRENT (match), x))
637 /* Just choose one. */
641 t = OVL_CURRENT (match);
646 if (t == error_mark_node)
648 /* error_mark_node is 0 for a while during initialization! */
650 cp_error_at ("`%#D' used prior to declaration", x);
652 else if (t != NULL_TREE)
654 if (different_binding_level)
656 if (decls_match (x, t))
657 /* The standard only says that the local extern
658 inherits linkage from the previous decl; in
659 particular, default args are not shared. It would
660 be nice to propagate inlining info, though. FIXME. */
661 TREE_PUBLIC (x) = TREE_PUBLIC (t);
663 else if (TREE_CODE (t) == PARM_DECL)
665 if (DECL_CONTEXT (t) == NULL_TREE)
666 /* This is probably caused by too many errors, but calling
667 abort will say that if errors have occurred. */
670 /* Check for duplicate params. */
671 if (duplicate_decls (x, t))
672 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
674 else if ((DECL_EXTERN_C_FUNCTION_P (x)
675 || DECL_FUNCTION_TEMPLATE_P (x))
676 && is_overloaded_fn (t))
677 /* Don't do anything just yet. */;
678 else if (t == wchar_decl_node)
680 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
681 pedwarn ("redeclaration of `wchar_t' as `%T'",
684 /* Throw away the redeclaration. */
685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
689 tree olddecl = duplicate_decls (x, t);
691 /* If the redeclaration failed, we can stop at this
693 if (olddecl == error_mark_node)
694 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
698 if (TREE_CODE (t) == TYPE_DECL)
699 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
700 else if (TREE_CODE (t) == FUNCTION_DECL)
701 check_default_args (t);
703 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
705 else if (DECL_MAIN_P (x))
707 /* A redeclaration of main, but not a duplicate of the
712 This function shall not be overloaded. */
713 cp_error_at ("invalid redeclaration of `%D'", t);
714 error ("as `%D'", x);
715 /* We don't try to push this declaration since that
717 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
722 check_template_shadow (x);
724 /* If this is a function conjured up by the backend, massage it
725 so it looks friendly. */
726 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
728 retrofit_lang_decl (x);
729 SET_DECL_LANGUAGE (x, lang_c);
732 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
734 t = push_overloaded_decl (x, PUSH_LOCAL);
736 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
737 if (!namespace_bindings_p ())
738 /* We do not need to create a binding for this name;
739 push_overloaded_decl will have already done so if
741 need_new_binding = 0;
743 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
745 t = push_overloaded_decl (x, PUSH_GLOBAL);
747 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
751 /* If declaring a type as a typedef, copy the type (unless we're
752 at line 0), and install this TYPE_DECL as the new type's typedef
753 name. See the extensive comment in ../c-decl.c (pushdecl). */
754 if (TREE_CODE (x) == TYPE_DECL)
756 tree type = TREE_TYPE (x);
757 if (DECL_SOURCE_LINE (x) == 0)
759 if (TYPE_NAME (type) == 0)
760 TYPE_NAME (type) = x;
762 else if (type != error_mark_node && TYPE_NAME (type) != x
763 /* We don't want to copy the type when all we're
764 doing is making a TYPE_DECL for the purposes of
766 && (!TYPE_NAME (type)
767 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
769 DECL_ORIGINAL_TYPE (x) = type;
770 type = build_type_copy (type);
771 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
772 TYPE_NAME (type) = x;
773 TREE_TYPE (x) = type;
776 if (type != error_mark_node
778 && TYPE_IDENTIFIER (type))
779 set_identifier_type_value (DECL_NAME (x), x);
782 /* Multiple external decls of the same identifier ought to match.
784 We get warnings about inline functions where they are defined.
785 We get warnings about other functions from push_overloaded_decl.
787 Avoid duplicate warnings where they are used. */
788 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
792 decl = IDENTIFIER_NAMESPACE_VALUE (name);
793 if (decl && TREE_CODE (decl) == OVERLOAD)
794 decl = OVL_FUNCTION (decl);
796 if (decl && decl != error_mark_node
797 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
798 /* If different sort of thing, we already gave an error. */
799 && TREE_CODE (decl) == TREE_CODE (x)
800 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
802 pedwarn ("type mismatch with previous external decl of `%#D'", x);
803 cp_pedwarn_at ("previous external decl of `%#D'", decl);
807 /* This name is new in its binding level.
808 Install the new declaration and return it. */
809 if (namespace_bindings_p ())
811 /* Install a global value. */
813 /* If the first global decl has external linkage,
814 warn if we later see static one. */
815 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
816 TREE_PUBLIC (name) = 1;
818 /* Bind the name for the entity. */
819 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
821 && (TREE_CODE (x) == TYPE_DECL
822 || TREE_CODE (x) == VAR_DECL
823 || TREE_CODE (x) == ALIAS_DECL
824 || TREE_CODE (x) == NAMESPACE_DECL
825 || TREE_CODE (x) == CONST_DECL
826 || TREE_CODE (x) == TEMPLATE_DECL))
827 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
829 /* Don't forget if the function was used via an implicit decl. */
830 if (IDENTIFIER_IMPLICIT_DECL (name)
831 && TREE_USED (IDENTIFIER_IMPLICIT_DECL (name)))
834 /* Don't forget if its address was taken in that way. */
835 if (IDENTIFIER_IMPLICIT_DECL (name)
836 && TREE_ADDRESSABLE (IDENTIFIER_IMPLICIT_DECL (name)))
837 TREE_ADDRESSABLE (x) = 1;
839 /* Warn about mismatches against previous implicit decl. */
840 if (IDENTIFIER_IMPLICIT_DECL (name) != NULL_TREE
841 /* If this real decl matches the implicit, don't complain. */
842 && ! (TREE_CODE (x) == FUNCTION_DECL
843 && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
845 ("`%D' was previously implicitly declared to return `int'", x);
847 /* If new decl is `static' and an `extern' was seen previously,
849 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
850 warn_extern_redeclared_static (x, t);
854 /* Here to install a non-global value. */
855 tree oldlocal = IDENTIFIER_VALUE (name);
856 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
858 if (need_new_binding)
860 push_local_binding (name, x, 0);
861 /* Because push_local_binding will hook X on to the
862 current_binding_level's name list, we don't want to
863 do that again below. */
864 need_new_binding = 0;
867 /* If this is a TYPE_DECL, push it into the type value slot. */
868 if (TREE_CODE (x) == TYPE_DECL)
869 set_identifier_type_value (name, x);
871 /* Clear out any TYPE_DECL shadowed by a namespace so that
872 we won't think this is a type. The C struct hack doesn't
873 go through namespaces. */
874 if (TREE_CODE (x) == NAMESPACE_DECL)
875 set_identifier_type_value (name, NULL_TREE);
882 && TREE_CODE (oldlocal) == VAR_DECL
883 && DECL_DEAD_FOR_LOCAL (oldlocal))
884 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
886 if (oldlocal == NULL_TREE)
887 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
890 /* If this is an extern function declaration, see if we
891 have a global definition or declaration for the function. */
892 if (oldlocal == NULL_TREE
894 && oldglobal != NULL_TREE
895 && TREE_CODE (x) == FUNCTION_DECL
896 && TREE_CODE (oldglobal) == FUNCTION_DECL)
898 /* We have one. Their types must agree. */
899 if (decls_match (x, oldglobal))
903 warning ("extern declaration of `%#D' doesn't match", x);
904 cp_warning_at ("global declaration `%#D'", oldglobal);
907 /* If we have a local external declaration,
908 and no file-scope declaration has yet been seen,
909 then if we later have a file-scope decl it must not be static. */
910 if (oldlocal == NULL_TREE
911 && oldglobal == NULL_TREE
914 TREE_PUBLIC (name) = 1;
916 /* Warn if shadowing an argument at the top level of the body. */
917 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
918 /* Inline decls shadow nothing. */
919 && !DECL_FROM_INLINE (x)
920 && TREE_CODE (oldlocal) == PARM_DECL
921 /* Don't check the `this' parameter. */
922 && !DECL_ARTIFICIAL (oldlocal))
926 /* Don't complain if it's from an enclosing function. */
927 if (DECL_CONTEXT (oldlocal) == current_function_decl
928 && TREE_CODE (x) != PARM_DECL)
930 /* Go to where the parms should be and see if we find
932 struct cp_binding_level *b = current_binding_level->level_chain;
934 /* Skip the ctor/dtor cleanup level. */
938 if (b->kind == sk_function_parms)
940 error ("declaration of '%#D' shadows a parameter", x);
945 if (warn_shadow && !err)
947 warning ("declaration of '%#D' shadows a parameter", x);
948 warning ("%Jshadowed declaration is here", oldlocal);
952 /* Maybe warn if shadowing something else. */
953 else if (warn_shadow && !DECL_EXTERNAL (x)
954 /* No shadow warnings for internally generated vars. */
955 && ! DECL_ARTIFICIAL (x)
956 /* No shadow warnings for vars made for inlining. */
957 && ! DECL_FROM_INLINE (x))
959 if (IDENTIFIER_CLASS_VALUE (name) != NULL_TREE
961 && !TREE_STATIC (name))
963 /* Location of previous decl is not useful in this case. */
964 warning ("declaration of '%D' shadows a member of 'this'",
967 else if (oldlocal != NULL_TREE
968 && TREE_CODE (oldlocal) == VAR_DECL)
970 warning ("declaration of '%D' shadows a previous local", x);
971 warning ("%Jshadowed declaration is here", oldlocal);
973 else if (oldglobal != NULL_TREE
974 && TREE_CODE (oldglobal) == VAR_DECL)
975 /* XXX shadow warnings in outer-more namespaces */
977 warning ("declaration of '%D' shadows a global declaration",
979 warning ("%Jshadowed declaration is here", oldglobal);
984 if (TREE_CODE (x) == FUNCTION_DECL)
985 check_default_args (x);
987 if (TREE_CODE (x) == VAR_DECL)
988 maybe_register_incomplete_var (x);
991 if (need_new_binding)
992 add_decl_to_level (x,
993 DECL_NAMESPACE_SCOPE_P (x)
994 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
995 : current_binding_level);
997 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1000 /* Enter DECL into the symbol table, if that's appropriate. Returns
1001 DECL, or a modified version thereof. */
1004 maybe_push_decl (tree decl)
1006 tree type = TREE_TYPE (decl);
1008 /* Add this decl to the current binding level, but not if it comes
1009 from another scope, e.g. a static member variable. TEM may equal
1010 DECL or it may be a previous decl of the same name. */
1011 if (decl == error_mark_node
1012 || (TREE_CODE (decl) != PARM_DECL
1013 && DECL_CONTEXT (decl) != NULL_TREE
1014 /* Definitions of namespace members outside their namespace are
1016 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1017 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1018 || TREE_CODE (type) == UNKNOWN_TYPE
1019 /* The declaration of a template specialization does not affect
1020 the functions available for overload resolution, so we do not
1022 || (TREE_CODE (decl) == FUNCTION_DECL
1023 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1026 return pushdecl (decl);
1029 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1030 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1031 doesn't really belong to this binding level, that it got here
1032 through a using-declaration. */
1035 push_local_binding (tree id, tree decl, int flags)
1037 struct cp_binding_level *b;
1039 /* Skip over any local classes. This makes sense if we call
1040 push_local_binding with a friend decl of a local class. */
1041 b = innermost_nonclass_level ();
1043 if (lookup_name_current_level (id))
1045 /* Supplement the existing binding. */
1046 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1047 /* It didn't work. Something else must be bound at this
1048 level. Do not add DECL to the list of things to pop
1053 /* Create a new binding. */
1054 push_binding (id, decl, b);
1056 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1057 /* We must put the OVERLOAD into a TREE_LIST since the
1058 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1059 decls that got here through a using-declaration. */
1060 decl = build_tree_list (NULL_TREE, decl);
1062 /* And put DECL on the list of things declared by the current
1064 add_decl_to_level (decl, b);
1067 /* The old ARM scoping rules injected variables declared in the
1068 initialization statement of a for-statement into the surrounding
1069 scope. We support this usage, in order to be backward-compatible.
1070 DECL is a just-declared VAR_DECL; if necessary inject its
1071 declaration into the surrounding scope. */
1074 maybe_inject_for_scope_var (tree decl)
1076 timevar_push (TV_NAME_LOOKUP);
1077 if (!DECL_NAME (decl))
1079 timevar_pop (TV_NAME_LOOKUP);
1083 /* Declarations of __FUNCTION__ and its ilk appear magically when
1084 the variable is first used. If that happens to be inside a
1085 for-loop, we don't want to do anything special. */
1086 if (DECL_PRETTY_FUNCTION_P (decl))
1088 timevar_pop (TV_NAME_LOOKUP);
1092 if (current_binding_level->kind == sk_for)
1094 struct cp_binding_level *outer
1095 = current_binding_level->level_chain;
1097 /* Check to see if the same name is already bound at the outer
1098 level, either because it was directly declared, or because a
1099 dead for-decl got preserved. In either case, the code would
1100 not have been valid under the ARM scope rules, so clear
1101 is_for_scope for the current_binding_level.
1103 Otherwise, we need to preserve the temp slot for decl to last
1104 into the outer binding level. */
1106 cxx_binding *outer_binding
1107 = IDENTIFIER_BINDING (DECL_NAME (decl))->previous;
1109 if (outer_binding && outer_binding->scope == outer
1110 && (TREE_CODE (outer_binding->value) == VAR_DECL)
1111 && DECL_DEAD_FOR_LOCAL (outer_binding->value))
1113 outer_binding->value = DECL_SHADOWED_FOR_VAR (outer_binding->value);
1114 current_binding_level->kind = sk_block;
1117 timevar_pop (TV_NAME_LOOKUP);
1120 /* Check to see whether or not DECL is a variable that would have been
1121 in scope under the ARM, but is not in scope under the ANSI/ISO
1122 standard. If so, issue an error message. If name lookup would
1123 work in both cases, but return a different result, this function
1124 returns the result of ANSI/ISO lookup. Otherwise, it returns
1128 check_for_out_of_scope_variable (tree decl)
1132 /* We only care about out of scope variables. */
1133 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1136 shadowed = DECL_SHADOWED_FOR_VAR (decl);
1137 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1138 && DECL_DEAD_FOR_LOCAL (shadowed))
1139 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1141 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1144 if (!DECL_ERROR_REPORTED (decl))
1146 warning ("name lookup of `%D' changed",
1148 cp_warning_at (" matches this `%D' under ISO standard rules",
1150 cp_warning_at (" matches this `%D' under old rules", decl);
1151 DECL_ERROR_REPORTED (decl) = 1;
1156 /* If we have already complained about this declaration, there's no
1157 need to do it again. */
1158 if (DECL_ERROR_REPORTED (decl))
1161 DECL_ERROR_REPORTED (decl) = 1;
1162 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1164 error ("name lookup of `%D' changed for new ISO `for' scoping",
1166 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", decl);
1167 return error_mark_node;
1171 pedwarn ("name lookup of `%D' changed for new ISO `for' scoping",
1173 cp_pedwarn_at (" using obsolete binding at `%D'", decl);
1179 /* true means unconditionally make a BLOCK for the next level pushed. */
1181 static bool keep_next_level_flag;
1183 static int binding_depth = 0;
1184 static int is_class_level = 0;
1191 for (i = 0; i < depth * 2; i++)
1195 /* Return a string describing the kind of SCOPE we have. */
1197 cxx_scope_descriptor (cxx_scope *scope)
1199 /* The order of this table must match the "scope_kind"
1201 static const char* scope_kind_names[] = {
1207 "function-parameter-scope",
1210 "template-parameter-scope",
1211 "template-explicit-spec-scope"
1213 const scope_kind kind = scope->explicit_spec_p
1214 ? sk_template_spec : scope->kind;
1216 return scope_kind_names[kind];
1219 /* Output a debugging information about SCOPE when performing
1222 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1224 const char *desc = cxx_scope_descriptor (scope);
1225 if (scope->this_entity)
1226 verbatim ("%s %s(%E) %p %d\n", action, desc,
1227 scope->this_entity, (void *) scope, line);
1229 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1232 /* Return the estimated initial size of the hashtable of a NAMESPACE
1235 static inline size_t
1236 namespace_scope_ht_size (tree ns)
1238 tree name = DECL_NAME (ns);
1240 return name == std_identifier
1241 ? NAMESPACE_STD_HT_SIZE
1242 : (name == global_scope_name
1243 ? GLOBAL_SCOPE_HT_SIZE
1244 : NAMESPACE_ORDINARY_HT_SIZE);
1247 /* A chain of binding_level structures awaiting reuse. */
1249 static GTY((deletable (""))) struct cp_binding_level *free_binding_level;
1251 /* Create a new KIND scope and make it the top of the active scopes stack.
1252 ENTITY is the scope of the associated C++ entity (namespace, class,
1253 function); it is NULL otherwise. */
1256 begin_scope (scope_kind kind, tree entity)
1260 /* Reuse or create a struct for this binding level. */
1261 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1263 scope = free_binding_level;
1264 free_binding_level = scope->level_chain;
1267 scope = ggc_alloc (sizeof (cxx_scope));
1268 memset (scope, 0, sizeof (cxx_scope));
1270 scope->this_entity = entity;
1271 scope->more_cleanups_ok = true;
1278 case sk_template_spec:
1279 scope->explicit_spec_p = true;
1280 kind = sk_template_parms;
1282 case sk_template_parms:
1288 case sk_function_parms:
1289 scope->keep = keep_next_level_flag;
1293 scope->type_decls = binding_table_new (namespace_scope_ht_size (entity));
1294 NAMESPACE_LEVEL (entity) = scope;
1295 VARRAY_TREE_INIT (scope->static_decls,
1296 DECL_NAME (entity) == std_identifier
1297 || DECL_NAME (entity) == global_scope_name
1299 "Static declarations");
1303 /* Should not happen. */
1304 my_friendly_assert (false, 20030922);
1309 /* Add it to the front of currently active scopes stack. */
1310 scope->level_chain = current_binding_level;
1311 current_binding_level = scope;
1312 keep_next_level_flag = false;
1314 if (ENABLE_SCOPE_CHECKING)
1316 scope->binding_depth = binding_depth;
1317 indent (binding_depth);
1318 cxx_scope_debug (scope, input_location.line, "push");
1326 /* We're about to leave current scope. Pop the top of the stack of
1327 currently active scopes. Return the enclosing scope, now active. */
1332 cxx_scope *scope = current_binding_level;
1334 if (scope->kind == sk_namespace && class_binding_level)
1335 current_binding_level = class_binding_level;
1337 /* We cannot leave a scope, if there are none left. */
1338 if (NAMESPACE_LEVEL (global_namespace))
1339 my_friendly_assert (!global_scope_p (scope), 20030527);
1341 if (ENABLE_SCOPE_CHECKING)
1343 indent (--binding_depth);
1344 cxx_scope_debug (scope, input_location.line, "leave");
1345 if (is_class_level != (scope == class_binding_level))
1347 indent (binding_depth);
1348 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1353 /* Move one nesting level up. */
1354 current_binding_level = scope->level_chain;
1356 /* Namespace-scopes are left most probably temporarily, not completely;
1357 they can be reopen later, e.g. in namespace-extension or any name
1358 binding activity that requires us to resume a namespace. For other
1359 scopes, we just make the structure available for reuse. */
1360 if (scope->kind != sk_namespace)
1362 scope->level_chain = free_binding_level;
1363 if (scope->kind == sk_class)
1364 scope->type_decls = NULL;
1366 binding_table_free (scope->type_decls);
1367 my_friendly_assert (!ENABLE_SCOPE_CHECKING
1368 || scope->binding_depth == binding_depth,
1370 free_binding_level = scope;
1373 /* Find the innermost enclosing class scope, and reset
1374 CLASS_BINDING_LEVEL appropriately. */
1375 for (scope = current_binding_level;
1376 scope && scope->kind != sk_class;
1377 scope = scope->level_chain)
1379 class_binding_level = scope && scope->kind == sk_class ? scope : NULL;
1381 return current_binding_level;
1385 resume_scope (struct cp_binding_level* b)
1387 /* Resuming binding levels is meant only for namespaces,
1388 and those cannot nest into classes. */
1389 my_friendly_assert(!class_binding_level, 386);
1390 /* Also, resuming a non-directly nested namespace is a no-no. */
1391 my_friendly_assert(b->level_chain == current_binding_level, 386);
1392 current_binding_level = b;
1393 if (ENABLE_SCOPE_CHECKING)
1395 b->binding_depth = binding_depth;
1396 indent (binding_depth);
1397 cxx_scope_debug (b, input_location.line, "resume");
1403 /* Return the innermost binding level that is not for a class scope. */
1406 innermost_nonclass_level (void)
1410 b = current_binding_level;
1411 while (b->kind == sk_class)
1417 /* We're defining an object of type TYPE. If it needs a cleanup, but
1418 we're not allowed to add any more objects with cleanups to the current
1419 scope, create a new binding level. */
1422 maybe_push_cleanup_level (tree type)
1424 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1425 && current_binding_level->more_cleanups_ok == 0)
1427 begin_scope (sk_cleanup, NULL);
1429 add_scope_stmt (/*begin_p=*/1, /*partial_p=*/1);
1433 /* Nonzero if we are currently in the global binding level. */
1436 global_bindings_p (void)
1438 return global_scope_p (current_binding_level);
1441 /* True if we are currently in a toplevel binding level. This
1442 means either the global binding level or a namespace in a toplevel
1443 binding level. Since there are no non-toplevel namespace levels,
1444 this really means any namespace or template parameter level. We
1445 also include a class whose context is toplevel. */
1448 toplevel_bindings_p (void)
1450 struct cp_binding_level *b = innermost_nonclass_level ();
1452 return b->kind == sk_namespace || b->kind == sk_template_parms;
1455 /* True if this is a namespace scope, or if we are defining a class
1456 which is itself at namespace scope, or whose enclosing class is
1457 such a class, etc. */
1460 namespace_bindings_p (void)
1462 struct cp_binding_level *b = innermost_nonclass_level ();
1464 return b->kind == sk_namespace;
1467 /* True if the current level needs to have a BLOCK made. */
1472 return (current_binding_level->blocks != NULL_TREE
1473 || current_binding_level->keep
1474 || current_binding_level->kind == sk_cleanup
1475 || current_binding_level->names != NULL_TREE
1476 || current_binding_level->type_decls != NULL);
1479 /* Returns the kind of the innermost scope. */
1482 innermost_scope_kind (void)
1484 return current_binding_level->kind;
1487 /* Returns true if this scope was created to store template parameters. */
1490 template_parm_scope_p (void)
1492 return innermost_scope_kind () == sk_template_parms;
1495 /* If KEEP is true, make a BLOCK node for the next binding level,
1496 unconditionally. Otherwise, use the normal logic to decide whether
1497 or not to create a BLOCK. */
1500 keep_next_level (bool keep)
1502 keep_next_level_flag = keep;
1505 /* Return the list of declarations of the current level.
1506 Note that this list is in reverse order unless/until
1507 you nreverse it; and when you do nreverse it, you must
1508 store the result back using `storedecls' or you will lose. */
1513 return current_binding_level->names;
1516 /* Set the current binding TABLE for type declarations.. This is a
1517 temporary workaround of the fact that the data structure classtypes
1518 does not currently carry its allocated cxx_scope structure. */
1520 cxx_remember_type_decls (binding_table table)
1522 current_binding_level->type_decls = table;
1525 /* For debugging. */
1526 static int no_print_functions = 0;
1527 static int no_print_builtins = 0;
1529 /* Called from print_binding_level through binding_table_foreach to
1530 print the content of binding ENTRY. DATA is a pointer to line offset
1533 bt_print_entry (binding_entry entry, void *data)
1535 int *p = (int *) data;
1538 if (entry->name == NULL)
1540 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1550 fprintf (stderr, "\n\t");
1553 if (entry->name == NULL)
1555 print_node_brief (stderr, "<unnamed-typedef", entry->type, 0);
1556 fprintf (stderr, ">");
1558 else if (entry->name == TYPE_IDENTIFIER (entry->type))
1559 print_node_brief (stderr, "", entry->type, 0);
1562 print_node_brief (stderr, "<typedef", entry->name, 0);
1563 print_node_brief (stderr, "", entry->type, 0);
1564 fprintf (stderr, ">");
1569 print_binding_level (struct cp_binding_level* lvl)
1573 fprintf (stderr, " blocks=" HOST_PTR_PRINTF, (void *) lvl->blocks);
1574 if (lvl->more_cleanups_ok)
1575 fprintf (stderr, " more-cleanups-ok");
1576 if (lvl->have_cleanups)
1577 fprintf (stderr, " have-cleanups");
1578 fprintf (stderr, "\n");
1581 fprintf (stderr, " names:\t");
1582 /* We can probably fit 3 names to a line? */
1583 for (t = lvl->names; t; t = TREE_CHAIN (t))
1585 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1587 if (no_print_builtins
1588 && (TREE_CODE (t) == TYPE_DECL)
1589 && (!strcmp (DECL_SOURCE_FILE (t),"<built-in>")))
1592 /* Function decls tend to have longer names. */
1593 if (TREE_CODE (t) == FUNCTION_DECL)
1600 fprintf (stderr, "\n\t");
1603 print_node_brief (stderr, "", t, 0);
1604 if (t == error_mark_node)
1608 fprintf (stderr, "\n");
1610 if (lvl->type_decls)
1612 fprintf (stderr, " tags:\t");
1614 binding_table_foreach (lvl->type_decls, bt_print_entry, &i);
1616 fprintf (stderr, "\n");
1618 if (lvl->class_shadowed)
1620 fprintf (stderr, " class-shadowed:");
1621 for (t = lvl->class_shadowed; t; t = TREE_CHAIN (t))
1623 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1625 fprintf (stderr, "\n");
1627 if (lvl->type_shadowed)
1629 fprintf (stderr, " type-shadowed:");
1630 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1632 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1634 fprintf (stderr, "\n");
1639 print_other_binding_stack (struct cp_binding_level *stack)
1641 struct cp_binding_level *level;
1642 for (level = stack; !global_scope_p (level); level = level->level_chain)
1644 fprintf (stderr, "binding level " HOST_PTR_PRINTF "\n", (void *) level);
1645 print_binding_level (level);
1650 print_binding_stack (void)
1652 struct cp_binding_level *b;
1653 fprintf (stderr, "current_binding_level=" HOST_PTR_PRINTF
1654 "\nclass_binding_level=" HOST_PTR_PRINTF
1655 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF "\n",
1656 (void *) current_binding_level, (void *) class_binding_level,
1657 (void *) NAMESPACE_LEVEL (global_namespace));
1658 if (class_binding_level)
1660 for (b = class_binding_level; b; b = b->level_chain)
1661 if (b == current_binding_level)
1664 b = class_binding_level;
1666 b = current_binding_level;
1669 b = current_binding_level;
1670 print_other_binding_stack (b);
1671 fprintf (stderr, "global:\n");
1672 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1675 /* Return the type associated with id. */
1678 identifier_type_value (tree id)
1680 timevar_push (TV_NAME_LOOKUP);
1681 /* There is no type with that name, anywhere. */
1682 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1684 /* This is not the type marker, but the real thing. */
1685 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1686 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1687 /* Have to search for it. It must be on the global level, now.
1688 Ask lookup_name not to return non-types. */
1689 id = lookup_name_real (id, 2, 1, 0, LOOKUP_COMPLAIN);
1691 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1692 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1695 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1696 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1699 identifier_global_value (tree t)
1701 return IDENTIFIER_GLOBAL_VALUE (t);
1704 /* Push a definition of struct, union or enum tag named ID. into
1705 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1706 the tag ID is not already defined. */
1709 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1713 if (b->kind != sk_namespace)
1715 /* Shadow the marker, not the real thing, so that the marker
1716 gets restored later. */
1717 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1719 = tree_cons (id, old_type_value, b->type_shadowed);
1720 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1724 cxx_binding *binding =
1725 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1729 supplement_binding (binding, decl);
1731 binding->value = decl;
1735 /* Store marker instead of real type. */
1736 type = global_type_node;
1738 SET_IDENTIFIER_TYPE_VALUE (id, type);
1741 /* As set_identifier_type_value_with_scope, but using
1742 current_binding_level. */
1745 set_identifier_type_value (tree id, tree decl)
1747 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1750 /* Return the name for the constructor (or destructor) for the
1751 specified class TYPE. When given a template, this routine doesn't
1752 lose the specialization. */
1755 constructor_name_full (tree type)
1757 type = TYPE_MAIN_VARIANT (type);
1758 if (CLASS_TYPE_P (type) && TYPE_WAS_ANONYMOUS (type)
1759 && TYPE_HAS_CONSTRUCTOR (type))
1760 return DECL_NAME (OVL_CURRENT (CLASSTYPE_CONSTRUCTORS (type)));
1762 return TYPE_IDENTIFIER (type);
1765 /* Return the name for the constructor (or destructor) for the
1766 specified class. When given a template, return the plain
1767 unspecialized name. */
1770 constructor_name (tree type)
1773 name = constructor_name_full (type);
1774 if (IDENTIFIER_TEMPLATE (name))
1775 name = IDENTIFIER_TEMPLATE (name);
1779 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1782 constructor_name_p (tree name, tree type)
1789 if (TREE_CODE (name) != IDENTIFIER_NODE)
1792 ctor_name = constructor_name_full (type);
1793 if (name == ctor_name)
1795 if (IDENTIFIER_TEMPLATE (ctor_name)
1796 && name == IDENTIFIER_TEMPLATE (ctor_name))
1801 /* Counter used to create anonymous type names. */
1803 static GTY(()) int anon_cnt;
1805 /* Return an IDENTIFIER which can be used as a name for
1806 anonymous structs and unions. */
1809 make_anon_name (void)
1813 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1814 return get_identifier (buf);
1817 /* Clear the TREE_PURPOSE slot of UTDs which have anonymous typenames.
1818 This keeps dbxout from getting confused. */
1821 clear_anon_tags (void)
1823 struct cp_binding_level *b;
1824 static int last_cnt = 0;
1826 /* Fast out if no new anon names were declared. */
1827 if (last_cnt == anon_cnt)
1830 b = current_binding_level;
1831 while (b->kind == sk_cleanup)
1833 if (b->type_decls != NULL)
1834 binding_table_remove_anonymous_types (b->type_decls);
1835 last_cnt = anon_cnt;
1838 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1840 static inline cxx_binding *
1841 find_binding (cxx_scope *scope, cxx_binding *binding)
1843 timevar_push (TV_NAME_LOOKUP);
1845 for (; binding != NULL; binding = binding->previous)
1846 if (binding->scope == scope)
1847 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1849 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1852 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1854 static inline cxx_binding *
1855 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1857 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1860 /* Fold-in case where NAME is used only once. */
1861 if (scope == b->scope && b->previous == NULL)
1863 return find_binding (scope, b);
1868 /* Always returns a binding for name in scope. If no binding is
1869 found, make a new one. */
1871 static cxx_binding *
1872 binding_for_name (cxx_scope *scope, tree name)
1874 cxx_binding *result;
1876 result = cxx_scope_find_binding_for_name (scope, name);
1879 /* Not found, make a new one. */
1880 result = cxx_binding_make (NULL, NULL);
1881 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1882 result->scope = scope;
1883 result->is_local = false;
1884 result->value_is_inherited = false;
1885 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1889 /* Insert another USING_DECL into the current binding level, returning
1890 this declaration. If this is a redeclaration, do nothing, and
1891 return NULL_TREE if this not in namespace scope (in namespace
1892 scope, a using decl might extend any previous bindings). */
1895 push_using_decl (tree scope, tree name)
1899 timevar_push (TV_NAME_LOOKUP);
1900 my_friendly_assert (TREE_CODE (scope) == NAMESPACE_DECL, 383);
1901 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 384);
1902 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1903 if (DECL_INITIAL (decl) == scope && DECL_NAME (decl) == name)
1906 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1907 namespace_bindings_p () ? decl : NULL_TREE);
1908 decl = build_lang_decl (USING_DECL, name, void_type_node);
1909 DECL_INITIAL (decl) = scope;
1910 TREE_CHAIN (decl) = current_binding_level->usings;
1911 current_binding_level->usings = decl;
1912 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1915 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1916 caller to set DECL_CONTEXT properly. */
1919 pushdecl_with_scope (tree x, cxx_scope *level)
1921 struct cp_binding_level *b;
1922 tree function_decl = current_function_decl;
1924 timevar_push (TV_NAME_LOOKUP);
1925 current_function_decl = NULL_TREE;
1926 if (level->kind == sk_class)
1928 b = class_binding_level;
1929 class_binding_level = level;
1930 pushdecl_class_level (x);
1931 class_binding_level = b;
1935 b = current_binding_level;
1936 current_binding_level = level;
1938 current_binding_level = b;
1940 current_function_decl = function_decl;
1941 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1944 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1945 other definitions already in place. We get around this by making
1946 the value of the identifier point to a list of all the things that
1947 want to be referenced by that name. It is then up to the users of
1948 that name to decide what to do with that list.
1950 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1951 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1953 FLAGS is a bitwise-or of the following values:
1954 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1956 PUSH_USING: DECL is being pushed as the result of a using
1959 The value returned may be a previous declaration if we guessed wrong
1960 about what language DECL should belong to (C or C++). Otherwise,
1961 it's always DECL (and never something that's not a _DECL). */
1964 push_overloaded_decl (tree decl, int flags)
1966 tree name = DECL_NAME (decl);
1969 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1971 timevar_push (TV_NAME_LOOKUP);
1973 old = namespace_binding (name, DECL_CONTEXT (decl));
1975 old = lookup_name_current_level (name);
1979 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1981 tree t = TREE_TYPE (old);
1982 if (IS_AGGR_TYPE (t) && warn_shadow
1983 && (! DECL_IN_SYSTEM_HEADER (decl)
1984 || ! DECL_IN_SYSTEM_HEADER (old)))
1985 warning ("`%#D' hides constructor for `%#T'", decl, t);
1988 else if (is_overloaded_fn (old))
1992 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1994 tree fn = OVL_CURRENT (tmp);
1996 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1997 && !(flags & PUSH_USING)
1998 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1999 TYPE_ARG_TYPES (TREE_TYPE (decl))))
2000 error ("`%#D' conflicts with previous using declaration `%#D'",
2003 if (duplicate_decls (decl, fn) == fn)
2004 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
2007 else if (old == error_mark_node)
2008 /* Ignore the undefined symbol marker. */
2012 cp_error_at ("previous non-function declaration `%#D'", old);
2013 error ("conflicts with function declaration `%#D'", decl);
2014 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2018 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2019 /* If it's a using declaration, we always need to build an OVERLOAD,
2020 because it's the only way to remember that the declaration comes
2021 from 'using', and have the lookup behave correctly. */
2022 || (flags & PUSH_USING))
2024 if (old && TREE_CODE (old) != OVERLOAD)
2025 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2027 new_binding = ovl_cons (decl, old);
2028 if (flags & PUSH_USING)
2029 OVL_USED (new_binding) = 1;
2032 /* NAME is not ambiguous. */
2036 set_namespace_binding (name, current_namespace, new_binding);
2039 /* We only create an OVERLOAD if there was a previous binding at
2040 this level, or if decl is a template. In the former case, we
2041 need to remove the old binding and replace it with the new
2042 binding. We must also run through the NAMES on the binding
2043 level where the name was bound to update the chain. */
2045 if (TREE_CODE (new_binding) == OVERLOAD && old)
2049 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2051 d = &TREE_CHAIN (*d))
2053 || (TREE_CODE (*d) == TREE_LIST
2054 && TREE_VALUE (*d) == old))
2056 if (TREE_CODE (*d) == TREE_LIST)
2057 /* Just replace the old binding with the new. */
2058 TREE_VALUE (*d) = new_binding;
2060 /* Build a TREE_LIST to wrap the OVERLOAD. */
2061 *d = tree_cons (NULL_TREE, new_binding,
2064 /* And update the cxx_binding node. */
2065 IDENTIFIER_BINDING (name)->value = new_binding;
2066 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2069 /* We should always find a previous binding in this case. */
2073 /* Install the new binding. */
2074 push_local_binding (name, new_binding, flags);
2077 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2080 /* Check a non-member using-declaration. Return the name and scope
2081 being used, and the USING_DECL, or NULL_TREE on failure. */
2084 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2086 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2089 A using-declaration shall not name a template-id. */
2090 error ("a using-declaration cannot specify a template-id. Try `using %D'", name);
2094 if (TREE_CODE (decl) == NAMESPACE_DECL)
2096 error ("namespace `%D' not allowed in using-declaration", decl);
2100 if (TREE_CODE (decl) == SCOPE_REF)
2102 /* It's a nested name with template parameter dependent scope.
2103 This can only be using-declaration for class member. */
2104 error ("`%T' is not a namespace", TREE_OPERAND (decl, 0));
2108 if (is_overloaded_fn (decl))
2109 decl = get_first_fn (decl);
2111 my_friendly_assert (DECL_P (decl), 20020908);
2113 /* [namespace.udecl]
2114 A using-declaration for a class member shall be a
2115 member-declaration. */
2118 error ("`%T' is not a namespace", scope);
2122 /* Make a USING_DECL. */
2123 return push_using_decl (scope, name);
2126 /* Process local and global using-declarations. */
2129 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2130 tree *newval, tree *newtype)
2134 *newval = *newtype = NULL_TREE;
2135 cxx_binding_clear (&decls);
2136 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2140 if (!decls.value && !decls.type)
2142 error ("`%D' not declared", name);
2146 /* Check for using functions. */
2147 if (decls.value && is_overloaded_fn (decls.value))
2151 if (oldval && !is_overloaded_fn (oldval))
2153 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2154 error ("`%D' is already declared in this scope", name);
2159 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2161 tree new_fn = OVL_CURRENT (tmp);
2163 /* [namespace.udecl]
2165 If a function declaration in namespace scope or block
2166 scope has the same name and the same parameter types as a
2167 function introduced by a using declaration the program is
2169 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2171 tree old_fn = OVL_CURRENT (tmp1);
2173 if (new_fn == old_fn)
2174 /* The function already exists in the current namespace. */
2176 else if (OVL_USED (tmp1))
2177 continue; /* this is a using decl */
2178 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2179 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2181 /* There was already a non-using declaration in
2182 this scope with the same parameter types. If both
2183 are the same extern "C" functions, that's ok. */
2184 if (decls_match (new_fn, old_fn))
2186 /* If the OLD_FN was a builtin, there is now a
2187 real declaration. */
2188 if (DECL_ANTICIPATED (old_fn))
2189 DECL_ANTICIPATED (old_fn) = 0;
2192 else if (!DECL_ANTICIPATED (old_fn))
2194 /* If the OLD_FN was really declared, the
2195 declarations don't match. */
2196 error ("`%D' is already declared in this scope", name);
2200 /* If the OLD_FN was not really there, just ignore
2201 it and keep going. */
2205 /* If we broke out of the loop, there's no reason to add
2206 this function to the using declarations for this
2211 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2212 if (TREE_CODE (*newval) != OVERLOAD)
2213 *newval = ovl_cons (*newval, NULL_TREE);
2214 OVL_USED (*newval) = 1;
2219 *newval = decls.value;
2220 if (oldval && !decls_match (*newval, oldval))
2221 error ("`%D' is already declared in this scope", name);
2224 *newtype = decls.type;
2225 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2227 error ("using declaration `%D' introduced ambiguous type `%T'",
2233 /* Process a using-declaration at function scope. */
2236 do_local_using_decl (tree decl, tree scope, tree name)
2238 tree oldval, oldtype, newval, newtype;
2239 tree orig_decl = decl;
2241 decl = validate_nonmember_using_decl (decl, scope, name);
2242 if (decl == NULL_TREE)
2245 if (building_stmt_tree ()
2246 && at_function_scope_p ())
2247 add_decl_stmt (decl);
2249 oldval = lookup_name_current_level (name);
2250 oldtype = lookup_type_current_level (name);
2252 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2256 if (is_overloaded_fn (newval))
2260 /* We only need to push declarations for those functions
2261 that were not already bound in the current level.
2262 The old value might be NULL_TREE, it might be a single
2263 function, or an OVERLOAD. */
2264 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2265 term = OVL_FUNCTION (oldval);
2268 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2270 push_overloaded_decl (OVL_CURRENT (fn),
2271 PUSH_LOCAL | PUSH_USING);
2274 push_local_binding (name, newval, PUSH_USING);
2277 set_identifier_type_value (name, newtype);
2279 /* Emit debug info. */
2280 if (!processing_template_decl)
2281 cp_emit_debug_info_for_using (orig_decl, current_scope());
2284 /* Return the type that should be used when TYPE's name is preceded
2285 by a tag such as 'struct' or 'union', or null if the name cannot
2286 be used in this way.
2288 For example, when processing the third line of:
2294 lookup of A will find the typedef. Given A's typedef, this function
2295 will return the type associated with "struct A". For the tag to be
2296 anything other than TYPE, TYPE must be a typedef whose original type
2297 has the same name and context as TYPE itself.
2299 It is not valid for a typedef of an anonymous type to be used with
2302 typedef struct { ... } B;
2305 Return null for this case. */
2308 follow_tag_typedef (tree type)
2312 original = original_type (type);
2313 if (! TYPE_NAME (original))
2315 if (TYPE_IDENTIFIER (original) == TYPE_IDENTIFIER (type)
2316 && (CP_DECL_CONTEXT (TYPE_NAME (original))
2317 == CP_DECL_CONTEXT (TYPE_NAME (type)))
2318 && !(CLASS_TYPE_P (original) && TYPE_WAS_ANONYMOUS (original)))
2324 /* Given NAME, an IDENTIFIER_NODE,
2325 return the structure (or union or enum) definition for that name.
2326 Searches binding levels from its SCOPE up to the global level.
2327 If THISLEVEL_ONLY is nonzero, searches only the specified context
2328 (but skips any sk_cleanup contexts to find one that is
2329 meaningful for tags).
2330 FORM says which kind of type the caller wants;
2331 it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
2332 If the wrong kind of type is found, and it's not a template, an error is
2336 lookup_tag (enum tree_code form, tree name,
2337 cxx_scope *binding_level, int thislevel_only)
2339 struct cp_binding_level *level;
2340 /* Nonzero if, we should look past a template parameter level, even
2341 if THISLEVEL_ONLY. */
2342 int allow_template_parms_p = 1;
2343 bool type_is_anonymous = ANON_AGGRNAME_P (name);
2345 timevar_push (TV_NAME_LOOKUP);
2346 for (level = binding_level; level; level = level->level_chain)
2349 if (type_is_anonymous && level->type_decls != NULL)
2351 tree type = binding_table_find_anon_type (level->type_decls, name);
2352 /* There is no need for error checking here, because
2353 anon names are unique throughout the compilation. */
2355 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
2357 else if (level->kind == sk_namespace)
2358 /* Do namespace lookup. */
2359 for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
2361 cxx_binding *binding =
2362 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (tail), name);
2365 /* If we just skipped past a template parameter level,
2366 even though THISLEVEL_ONLY, and we find a template
2367 class declaration, then we use the _TYPE node for the
2368 template. See the example below. */
2369 if (thislevel_only && !allow_template_parms_p
2370 && binding && binding->value
2371 && DECL_CLASS_TEMPLATE_P (binding->value))
2372 old = binding->value;
2374 old = select_decl (binding, LOOKUP_PREFER_TYPES);
2380 /* We've found something at this binding level. If it is
2381 a typedef, extract the tag it refers to. Lookup fails
2382 if the typedef doesn't refer to a taggable type. */
2383 old = TREE_TYPE (old);
2384 old = follow_tag_typedef (old);
2386 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2387 if (TREE_CODE (old) != form
2388 && (form == ENUMERAL_TYPE
2389 || TREE_CODE (old) == ENUMERAL_TYPE))
2391 error ("`%#D' redeclared as %C", old, form);
2392 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2394 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old);
2396 if (thislevel_only || tail == global_namespace)
2397 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2399 else if (level->type_decls != NULL)
2401 binding_entry entry = binding_table_find (level->type_decls, name);
2404 enum tree_code code = TREE_CODE (entry->type);
2407 && (form == ENUMERAL_TYPE || code == ENUMERAL_TYPE))
2409 /* Definition isn't the kind we were looking for. */
2410 error ("`%#D' redeclared as %C", entry->type, form);
2411 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->type);
2416 if (thislevel_only && level->kind != sk_cleanup)
2418 if (level->kind == sk_template_parms && allow_template_parms_p)
2420 /* We must deal with cases like this:
2422 template <class T> struct S;
2423 template <class T> struct S {};
2425 When looking up `S', for the second declaration, we
2426 would like to find the first declaration. But, we
2427 are in the pseudo-global level created for the
2428 template parameters, rather than the (surrounding)
2429 namespace level. Thus, we keep going one more level,
2430 even though THISLEVEL_ONLY is nonzero. */
2431 allow_template_parms_p = 0;
2435 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2438 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2441 /* Given a type, find the tag that was defined for it and return the tag name.
2442 Otherwise return 0. However, the value can never be 0
2443 in the cases in which this is used.
2445 C++: If NAME is nonzero, this is the new name to install. This is
2446 done when replacing anonymous tags with real tag names. */
2449 lookup_tag_reverse (tree type, tree name)
2451 struct cp_binding_level *level;
2453 timevar_push (TV_NAME_LOOKUP);
2454 for (level = current_binding_level; level; level = level->level_chain)
2456 binding_entry entry = level->type_decls == NULL
2458 : binding_table_reverse_maybe_remap (level->type_decls, type, name);
2460 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, entry->name);
2462 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2465 /* Returns true if ROOT (a namespace, class, or function) encloses
2466 CHILD. CHILD may be either a class type or a namespace. */
2469 is_ancestor (tree root, tree child)
2471 my_friendly_assert ((TREE_CODE (root) == NAMESPACE_DECL
2472 || TREE_CODE (root) == FUNCTION_DECL
2473 || CLASS_TYPE_P (root)), 20030307);
2474 my_friendly_assert ((TREE_CODE (child) == NAMESPACE_DECL
2475 || CLASS_TYPE_P (child)),
2478 /* The global namespace encloses everything. */
2479 if (root == global_namespace)
2484 /* If we've run out of scopes, stop. */
2487 /* If we've reached the ROOT, it encloses CHILD. */
2490 /* Go out one level. */
2492 child = TYPE_NAME (child);
2493 child = DECL_CONTEXT (child);
2497 /* Enter a class or namespace scope. */
2502 if (TREE_CODE (t) == NAMESPACE_DECL)
2503 push_decl_namespace (t);
2504 else if CLASS_TYPE_P (t)
2505 push_nested_class (t);
2508 /* Leave scope pushed by push_scope. */
2513 if (TREE_CODE (t) == NAMESPACE_DECL)
2514 pop_decl_namespace ();
2515 else if CLASS_TYPE_P (t)
2516 pop_nested_class ();
2519 /* Do a pushlevel for class declarations. */
2522 pushlevel_class (void)
2524 if (ENABLE_SCOPE_CHECKING)
2527 class_binding_level = begin_scope (sk_class, current_class_type);
2530 /* ...and a poplevel for class declarations. */
2533 poplevel_class (void)
2535 struct cp_binding_level *level = class_binding_level;
2538 timevar_push (TV_NAME_LOOKUP);
2539 my_friendly_assert (level != 0, 354);
2541 /* If we're leaving a toplevel class, don't bother to do the setting
2542 of IDENTIFIER_CLASS_VALUE to NULL_TREE, since first of all this slot
2543 shouldn't even be used when current_class_type isn't set, and second,
2544 if we don't touch it here, we're able to use the cache effect if the
2545 next time we're entering a class scope, it is the same class. */
2546 if (current_class_depth != 1)
2548 struct cp_binding_level* b;
2550 /* Clear out our IDENTIFIER_CLASS_VALUEs. */
2551 for (shadowed = level->class_shadowed;
2553 shadowed = TREE_CHAIN (shadowed))
2554 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed)) = NULL_TREE;
2556 /* Find the next enclosing class, and recreate
2557 IDENTIFIER_CLASS_VALUEs appropriate for that class. */
2558 b = level->level_chain;
2559 while (b && b->kind != sk_class)
2563 for (shadowed = b->class_shadowed;
2565 shadowed = TREE_CHAIN (shadowed))
2567 cxx_binding *binding;
2569 binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
2570 while (binding && binding->scope != b)
2571 binding = binding->previous;
2574 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
2579 /* Remember to save what IDENTIFIER's were bound in this scope so we
2580 can recover from cache misses. */
2582 previous_class_type = current_class_type;
2583 previous_class_values = class_binding_level->class_shadowed;
2585 for (shadowed = level->type_shadowed;
2587 shadowed = TREE_CHAIN (shadowed))
2588 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2590 /* Remove the bindings for all of the class-level declarations. */
2591 for (shadowed = level->class_shadowed;
2593 shadowed = TREE_CHAIN (shadowed))
2594 pop_binding (TREE_PURPOSE (shadowed), TREE_TYPE (shadowed));
2596 /* Now, pop out of the binding level which we created up in the
2597 `pushlevel_class' routine. */
2598 if (ENABLE_SCOPE_CHECKING)
2602 timevar_pop (TV_NAME_LOOKUP);
2605 /* Bind DECL to ID in the class_binding_level. Returns nonzero if the
2606 binding was successful. */
2609 push_class_binding (tree id, tree decl)
2612 cxx_binding *binding = IDENTIFIER_BINDING (id);
2615 timevar_push (TV_NAME_LOOKUP);
2616 /* Note that we declared this value so that we can issue an error if
2617 this is an invalid redeclaration of a name already used for some
2619 note_name_declared_in_class (id, decl);
2621 if (binding && binding->scope == class_binding_level)
2622 /* Supplement the existing binding. */
2623 result = supplement_binding (IDENTIFIER_BINDING (id), decl);
2625 /* Create a new binding. */
2626 push_binding (id, decl, class_binding_level);
2628 /* Update the IDENTIFIER_CLASS_VALUE for this ID to be the
2629 class-level declaration. Note that we do not use DECL here
2630 because of the possibility of the `struct stat' hack; if DECL is
2631 a class-name or enum-name we might prefer a field-name, or some
2633 IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
2635 /* If this is a binding from a base class, mark it as such. */
2636 binding = IDENTIFIER_BINDING (id);
2637 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2639 if (TREE_CODE (decl) == OVERLOAD)
2640 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2643 my_friendly_assert (DECL_P (decl), 0);
2644 context = context_for_name_lookup (decl);
2647 if (is_properly_derived_from (current_class_type, context))
2648 INHERITED_VALUE_BINDING_P (binding) = 1;
2650 INHERITED_VALUE_BINDING_P (binding) = 0;
2652 else if (binding->value == decl)
2653 /* We only encounter a TREE_LIST when push_class_decls detects an
2654 ambiguity. Such an ambiguity can be overridden by a definition
2656 INHERITED_VALUE_BINDING_P (binding) = 1;
2658 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result);
2661 /* We are entering the scope of a class. Clear IDENTIFIER_CLASS_VALUE
2662 for any names in enclosing classes. */
2665 clear_identifier_class_values (void)
2669 if (!class_binding_level)
2672 for (t = class_binding_level->class_shadowed;
2675 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
2678 /* Make the declaration of X appear in CLASS scope. */
2681 pushdecl_class_level (tree x)
2684 bool is_valid = true;
2686 timevar_push (TV_NAME_LOOKUP);
2687 /* Get the name of X. */
2688 if (TREE_CODE (x) == OVERLOAD)
2689 name = DECL_NAME (get_first_fn (x));
2691 name = DECL_NAME (x);
2695 is_valid = push_class_level_binding (name, x);
2696 if (TREE_CODE (x) == TYPE_DECL)
2697 set_identifier_type_value (name, x);
2699 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2701 /* If X is an anonymous aggregate, all of its members are
2702 treated as if they were members of the class containing the
2703 aggregate, for naming purposes. */
2706 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2708 location_t save_location = input_location;
2709 input_location = DECL_SOURCE_LOCATION (f);
2710 if (!pushdecl_class_level (f))
2712 input_location = save_location;
2715 timevar_pop (TV_NAME_LOOKUP);
2720 /* Make the declaration(s) of X appear in CLASS scope under the name
2721 NAME. Returns true if the binding is valid. */
2724 push_class_level_binding (tree name, tree x)
2726 cxx_binding *binding;
2728 timevar_push (TV_NAME_LOOKUP);
2729 /* The class_binding_level will be NULL if x is a template
2730 parameter name in a member template. */
2731 if (!class_binding_level)
2732 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2734 /* Make sure that this new member does not have the same name
2735 as a template parameter. */
2736 if (TYPE_BEING_DEFINED (current_class_type))
2737 check_template_shadow (x);
2741 If T is the name of a class, then each of the following shall
2742 have a name different from T:
2744 -- every static data member of class T;
2746 -- every member of class T that is itself a type;
2748 -- every enumerator of every member of class T that is an
2751 -- every member of every anonymous union that is a member of
2754 (Non-static data members were also forbidden to have the same
2755 name as T until TC1.) */
2756 if ((TREE_CODE (x) == VAR_DECL
2757 || TREE_CODE (x) == CONST_DECL
2758 || (TREE_CODE (x) == TYPE_DECL
2759 && !DECL_SELF_REFERENCE_P (x))
2760 /* A data member of an anonymous union. */
2761 || (TREE_CODE (x) == FIELD_DECL
2762 && DECL_CONTEXT (x) != current_class_type))
2763 && DECL_NAME (x) == constructor_name (current_class_type))
2765 tree scope = context_for_name_lookup (x);
2766 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2768 error ("`%D' has the same name as the class in which it is declared",
2770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2774 /* If this declaration shadows a declaration from an enclosing
2775 class, then we will need to restore IDENTIFIER_CLASS_VALUE when
2776 we leave this class. Record the shadowed declaration here. */
2777 binding = IDENTIFIER_BINDING (name);
2778 if (binding && binding->value)
2780 tree bval = binding->value;
2781 tree old_decl = NULL_TREE;
2783 if (INHERITED_VALUE_BINDING_P (binding))
2785 /* If the old binding was from a base class, and was for a
2786 tag name, slide it over to make room for the new binding.
2787 The old binding is still visible if explicitly qualified
2788 with a class-key. */
2789 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2790 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2792 old_decl = binding->type;
2793 binding->type = bval;
2794 binding->value = NULL_TREE;
2795 INHERITED_VALUE_BINDING_P (binding) = 0;
2800 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2802 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2803 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2804 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2806 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2807 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2813 /* Find the previous binding of name on the class-shadowed
2814 list, and update it. */
2815 for (shadow = class_binding_level->class_shadowed;
2817 shadow = TREE_CHAIN (shadow))
2818 if (TREE_PURPOSE (shadow) == name
2819 && TREE_TYPE (shadow) == old_decl)
2822 INHERITED_VALUE_BINDING_P (binding) = 0;
2823 TREE_TYPE (shadow) = x;
2824 IDENTIFIER_CLASS_VALUE (name) = x;
2825 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2830 /* If we didn't replace an existing binding, put the binding on the
2831 stack of bindings for the identifier, and update the shadowed list. */
2832 if (push_class_binding (name, x))
2834 class_binding_level->class_shadowed
2835 = tree_cons (name, NULL,
2836 class_binding_level->class_shadowed);
2837 /* Record the value we are binding NAME to so that we can know
2838 what to pop later. */
2839 TREE_TYPE (class_binding_level->class_shadowed) = x;
2840 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2843 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2847 do_class_using_decl (tree decl)
2849 tree name, value, scope, type;
2851 if (TREE_CODE (decl) != SCOPE_REF
2852 || !TREE_OPERAND (decl, 0)
2853 || !TYPE_P (TREE_OPERAND (decl, 0)))
2855 error ("using-declaration for non-member at class scope");
2858 scope = TREE_OPERAND (decl, 0);
2859 name = TREE_OPERAND (decl, 1);
2860 if (TREE_CODE (name) == BIT_NOT_EXPR)
2862 error ("using-declaration cannot name destructor");
2865 if (TREE_CODE (name) == TYPE_DECL)
2866 name = DECL_NAME (name);
2867 else if (TREE_CODE (name) == TEMPLATE_DECL)
2868 name = DECL_NAME (name);
2869 else if (BASELINK_P (name))
2871 tree fns = BASELINK_FUNCTIONS (name);
2872 name = DECL_NAME (get_first_fn (fns));
2875 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 980716);
2877 /* Dependent using decls have a NULL type, non-dependent ones have a
2879 type = dependent_type_p (scope) ? NULL_TREE : void_type_node;
2880 value = build_lang_decl (USING_DECL, name, type);
2881 DECL_INITIAL (value) = scope;
2883 if (scope && !processing_template_decl)
2887 r = lookup_qualified_name (scope, name, false, false);
2888 if (r && TREE_CODE (r) != ERROR_MARK)
2889 cp_emit_debug_info_for_using (r, scope);
2895 set_class_shadows (tree shadows)
2897 class_binding_level->class_shadowed = shadows;
2900 /* Return the binding value for name in scope. */
2903 namespace_binding (tree name, tree scope)
2905 cxx_binding *binding;
2908 scope = global_namespace;
2909 scope = ORIGINAL_NAMESPACE (scope);
2910 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2912 return binding ? binding->value : NULL_TREE;
2915 /* Set the binding value for name in scope. */
2918 set_namespace_binding (tree name, tree scope, tree val)
2922 timevar_push (TV_NAME_LOOKUP);
2923 if (scope == NULL_TREE)
2924 scope = global_namespace;
2925 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2926 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2929 supplement_binding (b, val);
2930 timevar_pop (TV_NAME_LOOKUP);
2933 /* Compute the namespace where a declaration is defined. */
2936 decl_namespace (tree decl)
2938 timevar_push (TV_NAME_LOOKUP);
2940 decl = TYPE_STUB_DECL (decl);
2941 while (DECL_CONTEXT (decl))
2943 decl = DECL_CONTEXT (decl);
2944 if (TREE_CODE (decl) == NAMESPACE_DECL)
2945 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2947 decl = TYPE_STUB_DECL (decl);
2948 my_friendly_assert (DECL_P (decl), 390);
2951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, global_namespace);
2954 /* Set the context of a declaration to scope. Complain if we are not
2958 set_decl_namespace (tree decl, tree scope, bool friendp)
2962 /* Get rid of namespace aliases. */
2963 scope = ORIGINAL_NAMESPACE (scope);
2965 /* It is ok for friends to be qualified in parallel space. */
2966 if (!friendp && !is_ancestor (current_namespace, scope))
2967 error ("declaration of `%D' not in a namespace surrounding `%D'",
2969 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2970 if (scope != current_namespace)
2972 /* See whether this has been declared in the namespace. */
2973 old = namespace_binding (DECL_NAME (decl), scope);
2975 /* No old declaration at all. */
2977 /* A template can be explicitly specialized in any namespace. */
2978 if (processing_explicit_instantiation)
2980 if (!is_overloaded_fn (decl))
2981 /* Don't compare non-function decls with decls_match here,
2982 since it can't check for the correct constness at this
2983 point. pushdecl will find those errors later. */
2985 /* Since decl is a function, old should contain a function decl. */
2986 if (!is_overloaded_fn (old))
2988 if (processing_template_decl || processing_specialization)
2989 /* We have not yet called push_template_decl to turn a
2990 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations
2991 won't match. But, we'll check later, when we construct the
2994 if (is_overloaded_fn (old))
2996 for (; old; old = OVL_NEXT (old))
2997 if (decls_match (decl, OVL_CURRENT (old)))
3001 if (decls_match (decl, old))
3007 error ("`%D' should have been declared inside `%D'",
3011 /* Return the namespace where the current declaration is declared. */
3014 current_decl_namespace (void)
3017 /* If we have been pushed into a different namespace, use it. */
3018 if (decl_namespace_list)
3019 return TREE_PURPOSE (decl_namespace_list);
3021 if (current_class_type)
3022 result = decl_namespace (TYPE_STUB_DECL (current_class_type));
3023 else if (current_function_decl)
3024 result = decl_namespace (current_function_decl);
3026 result = current_namespace;
3030 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3031 select a name that is unique to this compilation unit. */
3034 push_namespace (tree name)
3038 int implicit_use = 0;
3041 timevar_push (TV_NAME_LOOKUP);
3043 /* We should not get here if the global_namespace is not yet constructed
3044 nor if NAME designates the global namespace: The global scope is
3045 constructed elsewhere. */
3046 my_friendly_assert (global_namespace != NULL && name != global_scope_name,
3051 /* The name of anonymous namespace is unique for the translation
3053 if (!anonymous_namespace_name)
3054 anonymous_namespace_name = get_file_function_name ('N');
3055 name = anonymous_namespace_name;
3056 d = IDENTIFIER_NAMESPACE_VALUE (name);
3058 /* Reopening anonymous namespace. */
3064 /* Check whether this is an extended namespace definition. */
3065 d = IDENTIFIER_NAMESPACE_VALUE (name);
3066 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3069 if (DECL_NAMESPACE_ALIAS (d))
3071 error ("namespace alias `%D' not allowed here, assuming `%D'",
3072 d, DECL_NAMESPACE_ALIAS (d));
3073 d = DECL_NAMESPACE_ALIAS (d);
3080 /* Make a new namespace, binding the name to it. */
3081 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3082 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3086 /* Clear DECL_NAME for the benefit of debugging back ends. */
3087 SET_DECL_ASSEMBLER_NAME (d, name);
3088 DECL_NAME (d) = NULL_TREE;
3090 begin_scope (sk_namespace, d);
3093 resume_scope (NAMESPACE_LEVEL (d));
3096 do_using_directive (d);
3097 /* Enter the name space. */
3098 current_namespace = d;
3100 timevar_pop (TV_NAME_LOOKUP);
3103 /* Pop from the scope of the current namespace. */
3106 pop_namespace (void)
3108 my_friendly_assert (current_namespace != global_namespace, 20010801);
3109 current_namespace = CP_DECL_CONTEXT (current_namespace);
3110 /* The binding level is not popped, as it might be re-opened later. */
3114 /* Push into the scope of the namespace NS, even if it is deeply
3115 nested within another namespace. */
3118 push_nested_namespace (tree ns)
3120 if (ns == global_namespace)
3121 push_to_top_level ();
3124 push_nested_namespace (CP_DECL_CONTEXT (ns));
3125 push_namespace (DECL_NAME (ns));
3129 /* Pop back from the scope of the namespace NS, which was previously
3130 entered with push_nested_namespace. */
3133 pop_nested_namespace (tree ns)
3135 timevar_push (TV_NAME_LOOKUP);
3136 while (ns != global_namespace)
3139 ns = CP_DECL_CONTEXT (ns);
3142 pop_from_top_level ();
3143 timevar_pop (TV_NAME_LOOKUP);
3146 /* Temporarily set the namespace for the current declaration. */
3149 push_decl_namespace (tree decl)
3151 if (TREE_CODE (decl) != NAMESPACE_DECL)
3152 decl = decl_namespace (decl);
3153 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3154 NULL_TREE, decl_namespace_list);
3157 /* [namespace.memdef]/2 */
3160 pop_decl_namespace (void)
3162 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3165 /* Return the namespace that is the common ancestor
3166 of two given namespaces. */
3169 namespace_ancestor (tree ns1, tree ns2)
3171 timevar_push (TV_NAME_LOOKUP);
3172 if (is_ancestor (ns1, ns2))
3173 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3174 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3175 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3178 /* Process a namespace-alias declaration. */
3181 do_namespace_alias (tree alias, tree namespace)
3183 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3185 /* The parser did not find it, so it's not there. */
3186 error ("unknown namespace `%D'", namespace);
3190 namespace = ORIGINAL_NAMESPACE (namespace);
3192 /* Build the alias. */
3193 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3194 DECL_NAMESPACE_ALIAS (alias) = namespace;
3195 DECL_EXTERNAL (alias) = 1;
3198 /* Emit debug info for namespace alias. */
3199 (*debug_hooks->global_decl) (alias);
3202 /* Like pushdecl, only it places X in the current namespace,
3206 pushdecl_namespace_level (tree x)
3208 struct cp_binding_level *b = current_binding_level;
3211 timevar_push (TV_NAME_LOOKUP);
3212 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3214 /* Now, the type_shadowed stack may screw us. Munge it so it does
3216 if (TREE_CODE (x) == TYPE_DECL)
3218 tree name = DECL_NAME (x);
3220 tree *ptr = (tree *)0;
3221 for (; !global_scope_p (b); b = b->level_chain)
3223 tree shadowed = b->type_shadowed;
3224 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3225 if (TREE_PURPOSE (shadowed) == name)
3227 ptr = &TREE_VALUE (shadowed);
3228 /* Can't break out of the loop here because sometimes
3229 a binding level will have duplicate bindings for
3230 PT names. It's gross, but I haven't time to fix it. */
3233 newval = TREE_TYPE (x);
3234 if (ptr == (tree *)0)
3236 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3237 up here if this is changed to an assertion. --KR */
3238 SET_IDENTIFIER_TYPE_VALUE (name, x);
3245 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3248 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3249 directive is not directly from the source. Also find the common
3250 ancestor and let our users know about the new namespace */
3252 add_using_namespace (tree user, tree used, bool indirect)
3255 timevar_push (TV_NAME_LOOKUP);
3256 /* Using oneself is a no-op. */
3259 timevar_pop (TV_NAME_LOOKUP);
3262 my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
3263 my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
3264 /* Check if we already have this. */
3265 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3269 /* Promote to direct usage. */
3270 TREE_INDIRECT_USING (t) = 0;
3271 timevar_pop (TV_NAME_LOOKUP);
3275 /* Add used to the user's using list. */
3276 DECL_NAMESPACE_USING (user)
3277 = tree_cons (used, namespace_ancestor (user, used),
3278 DECL_NAMESPACE_USING (user));
3280 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3282 /* Add user to the used's users list. */
3283 DECL_NAMESPACE_USERS (used)
3284 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3286 /* Recursively add all namespaces used. */
3287 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3288 /* indirect usage */
3289 add_using_namespace (user, TREE_PURPOSE (t), 1);
3291 /* Tell everyone using us about the new used namespaces. */
3292 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3293 add_using_namespace (TREE_PURPOSE (t), used, 1);
3294 timevar_pop (TV_NAME_LOOKUP);
3297 /* Process a using-declaration not appearing in class or local scope. */
3300 do_toplevel_using_decl (tree decl, tree scope, tree name)
3302 tree oldval, oldtype, newval, newtype;
3303 tree orig_decl = decl;
3304 cxx_binding *binding;
3306 decl = validate_nonmember_using_decl (decl, scope, name);
3307 if (decl == NULL_TREE)
3310 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3312 oldval = binding->value;
3313 oldtype = binding->type;
3315 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3317 /* Emit debug info. */
3318 if (!processing_template_decl)
3319 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3321 /* Copy declarations found. */
3323 binding->value = newval;
3325 binding->type = newtype;
3329 /* Process a using-directive. */
3332 do_using_directive (tree namespace)
3334 tree context = NULL_TREE;
3336 if (building_stmt_tree ())
3337 add_stmt (build_stmt (USING_STMT, namespace));
3339 /* using namespace A::B::C; */
3340 if (TREE_CODE (namespace) == SCOPE_REF)
3341 namespace = TREE_OPERAND (namespace, 1);
3342 if (TREE_CODE (namespace) == IDENTIFIER_NODE)
3344 /* Lookup in lexer did not find a namespace. */
3345 if (!processing_template_decl)
3346 error ("namespace `%T' undeclared", namespace);
3349 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3351 if (!processing_template_decl)
3352 error ("`%T' is not a namespace", namespace);
3355 namespace = ORIGINAL_NAMESPACE (namespace);
3356 if (!toplevel_bindings_p ())
3358 push_using_directive (namespace);
3359 context = current_scope ();
3364 add_using_namespace (current_namespace, namespace, 0);
3365 if (current_namespace != global_namespace)
3366 context = current_namespace;
3369 /* Emit debugging info. */
3370 if (!processing_template_decl)
3371 (*debug_hooks->imported_module_or_decl) (namespace, context);
3374 /* Deal with a using-directive seen by the parser. Currently we only
3375 handle attributes here, since they cannot appear inside a template. */
3378 parse_using_directive (tree namespace, tree attribs)
3382 do_using_directive (namespace);
3384 for (a = attribs; a; a = TREE_CHAIN (a))
3386 tree name = TREE_PURPOSE (a);
3387 if (is_attribute_p ("strong", name))
3389 if (!toplevel_bindings_p ())
3390 error ("strong using only meaningful at namespace scope");
3392 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3393 = tree_cons (current_namespace, 0,
3394 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3397 warning ("`%D' attribute directive ignored", name);
3401 /* Like pushdecl, only it places X in the global scope if appropriate.
3402 Calls cp_finish_decl to register the variable, initializing it with
3403 *INIT, if INIT is non-NULL. */
3406 pushdecl_top_level_1 (tree x, tree *init)
3408 timevar_push (TV_NAME_LOOKUP);
3409 push_to_top_level ();
3410 x = pushdecl_namespace_level (x);
3412 cp_finish_decl (x, *init, NULL_TREE, 0);
3413 pop_from_top_level ();
3414 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3417 /* Like pushdecl, only it places X in the global scope if appropriate. */
3420 pushdecl_top_level (tree x)
3422 return pushdecl_top_level_1 (x, NULL);
3425 /* Like pushdecl, only it places X in the global scope if
3426 appropriate. Calls cp_finish_decl to register the variable,
3427 initializing it with INIT. */
3430 pushdecl_top_level_and_finish (tree x, tree init)
3432 return pushdecl_top_level_1 (x, &init);
3435 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3436 duplicates. The first list becomes the tail of the result.
3438 The algorithm is O(n^2). We could get this down to O(n log n) by
3439 doing a sort on the addresses of the functions, if that becomes
3443 merge_functions (tree s1, tree s2)
3445 for (; s2; s2 = OVL_NEXT (s2))
3447 tree fn2 = OVL_CURRENT (s2);
3450 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3452 tree fn1 = OVL_CURRENT (fns1);
3454 /* If the function from S2 is already in S1, there is no
3455 need to add it again. For `extern "C"' functions, we
3456 might have two FUNCTION_DECLs for the same function, in
3457 different namespaces; again, we only need one of them. */
3459 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3460 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3464 /* If we exhausted all of the functions in S1, FN2 is new. */
3466 s1 = build_overload (fn2, s1);
3471 /* This should return an error not all definitions define functions.
3472 It is not an error if we find two functions with exactly the
3473 same signature, only if these are selected in overload resolution.
3474 old is the current set of bindings, new the freshly-found binding.
3475 XXX Do we want to give *all* candidates in case of ambiguity?
3476 XXX In what way should I treat extern declarations?
3477 XXX I don't want to repeat the entire duplicate_decls here */
3479 static cxx_binding *
3480 ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
3483 my_friendly_assert (old != NULL, 393);
3484 /* Copy the value. */
3487 switch (TREE_CODE (val))
3490 /* If we expect types or namespaces, and not templates,
3491 or this is not a template class. */
3492 if (LOOKUP_QUALIFIERS_ONLY (flags)
3493 && !DECL_CLASS_TEMPLATE_P (val))
3497 if (LOOKUP_NAMESPACES_ONLY (flags))
3500 case NAMESPACE_DECL:
3501 if (LOOKUP_TYPES_ONLY (flags))
3505 /* Ignore built-in functions that are still anticipated. */
3506 if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val))
3510 if (LOOKUP_QUALIFIERS_ONLY (flags))
3516 else if (val && val != old->value)
3518 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3519 old->value = merge_functions (old->value, val);
3522 /* Some declarations are functions, some are not. */
3523 if (flags & LOOKUP_COMPLAIN)
3525 /* If we've already given this error for this lookup,
3526 old->value is error_mark_node, so let's not
3527 repeat ourselves. */
3528 if (old->value != error_mark_node)
3530 error ("use of `%D' is ambiguous", name);
3531 cp_error_at (" first declared as `%#D' here",
3534 cp_error_at (" also declared as `%#D' here", val);
3536 old->value = error_mark_node;
3539 /* ... and copy the type. */
3541 if (LOOKUP_NAMESPACES_ONLY (flags))
3545 else if (type && old->type != type)
3547 if (flags & LOOKUP_COMPLAIN)
3549 error ("`%D' denotes an ambiguous type",name);
3550 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3551 error ("%J other type here", TYPE_MAIN_DECL (type));
3557 /* Return the declarations that are members of the namespace NS. */
3560 cp_namespace_decls (tree ns)
3562 return NAMESPACE_LEVEL (ns)->names;
3565 /* Combine prefer_type and namespaces_only into flags. */
3568 lookup_flags (int prefer_type, int namespaces_only)
3570 if (namespaces_only)
3571 return LOOKUP_PREFER_NAMESPACES;
3572 if (prefer_type > 1)
3573 return LOOKUP_PREFER_TYPES;
3574 if (prefer_type > 0)
3575 return LOOKUP_PREFER_BOTH;
3579 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3580 ignore it or not. Subroutine of lookup_name_real. */
3583 qualify_lookup (tree val, int flags)
3585 if (val == NULL_TREE)
3587 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3589 if ((flags & LOOKUP_PREFER_TYPES)
3590 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3592 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3597 /* Look up NAME in the NAMESPACE. */
3600 lookup_namespace_name (tree namespace, tree name)
3603 tree template_id = NULL_TREE;
3604 cxx_binding binding;
3606 timevar_push (TV_NAME_LOOKUP);
3607 my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
3609 if (TREE_CODE (name) == NAMESPACE_DECL)
3610 /* This happens for A::B<int> when B is a namespace. */
3611 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3612 else if (TREE_CODE (name) == TEMPLATE_DECL)
3614 /* This happens for A::B where B is a template, and there are no
3615 template arguments. */
3616 error ("invalid use of `%D'", name);
3617 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3620 namespace = ORIGINAL_NAMESPACE (namespace);
3622 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3625 name = TREE_OPERAND (name, 0);
3626 if (TREE_CODE (name) == OVERLOAD)
3627 name = DECL_NAME (OVL_CURRENT (name));
3628 else if (DECL_P (name))
3629 name = DECL_NAME (name);
3632 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 373);
3634 cxx_binding_clear (&binding);
3635 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3636 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3640 val = binding.value;
3644 if (DECL_CLASS_TEMPLATE_P (val))
3645 val = lookup_template_class (val,
3646 TREE_OPERAND (template_id, 1),
3647 /*in_decl=*/NULL_TREE,
3648 /*context=*/NULL_TREE,
3649 /*entering_scope=*/0,
3650 tf_error | tf_warning);
3651 else if (DECL_FUNCTION_TEMPLATE_P (val)
3652 || TREE_CODE (val) == OVERLOAD)
3653 val = lookup_template_function (val,
3654 TREE_OPERAND (template_id, 1));
3657 error ("`%D::%D' is not a template",
3659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3663 /* If we have a single function from a using decl, pull it out. */
3664 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3665 val = OVL_FUNCTION (val);
3667 /* Ignore built-in functions that haven't been prototyped yet. */
3668 if (!val || !DECL_P(val)
3669 || !DECL_LANG_SPECIFIC(val)
3670 || !DECL_ANTICIPATED (val))
3671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3674 error ("`%D' undeclared in namespace `%D'", name, namespace);
3675 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3678 /* Select the right _DECL from multiple choices. */
3681 select_decl (cxx_binding *binding, int flags)
3684 val = binding->value;
3686 timevar_push (TV_NAME_LOOKUP);
3687 if (LOOKUP_NAMESPACES_ONLY (flags))
3689 /* We are not interested in types. */
3690 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3691 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3692 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3695 /* If looking for a type, or if there is no non-type binding, select
3696 the value binding. */
3697 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3698 val = binding->type;
3699 /* Don't return non-types if we really prefer types. */
3700 else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
3701 && (TREE_CODE (val) != TEMPLATE_DECL
3702 || !DECL_CLASS_TEMPLATE_P (val)))
3705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3708 /* Unscoped lookup of a global: iterate over current namespaces,
3709 considering using-directives. */
3712 unqualified_namespace_lookup (tree name, int flags)
3714 tree initial = current_decl_namespace ();
3715 tree scope = initial;
3717 struct cp_binding_level *level;
3718 tree val = NULL_TREE;
3719 cxx_binding binding;
3721 timevar_push (TV_NAME_LOOKUP);
3722 cxx_binding_clear (&binding);
3724 for (; !val; scope = CP_DECL_CONTEXT (scope))
3727 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3729 /* Ignore anticipated built-in functions. */
3730 if (b && b->value && DECL_P (b->value)
3731 && DECL_LANG_SPECIFIC (b->value) && DECL_ANTICIPATED (b->value))
3732 /* Keep binding cleared. */;
3735 /* Initialize binding for this context. */
3736 binding.value = b->value;
3737 binding.type = b->type;
3740 /* Add all _DECLs seen through local using-directives. */
3741 for (level = current_binding_level;
3742 level->kind != sk_namespace;
3743 level = level->level_chain)
3744 if (!lookup_using_namespace (name, &binding, level->using_directives,
3746 /* Give up because of error. */
3747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3749 /* Add all _DECLs seen through global using-directives. */
3750 /* XXX local and global using lists should work equally. */
3754 if (!lookup_using_namespace (name, &binding,
3755 DECL_NAMESPACE_USING (siter),
3757 /* Give up because of error. */
3758 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3759 if (siter == scope) break;
3760 siter = CP_DECL_CONTEXT (siter);
3763 val = select_decl (&binding, flags);
3764 if (scope == global_namespace)
3767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3770 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3771 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3774 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3775 declaration found. If no suitable declaration can be found,
3776 ERROR_MARK_NODE is returned. Iif COMPLAIN is true and SCOPE is
3777 neither a class-type nor a namespace a diagnostic is issued. */
3780 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3784 if (TREE_CODE (scope) == NAMESPACE_DECL)
3786 cxx_binding binding;
3788 cxx_binding_clear (&binding);
3789 flags |= LOOKUP_COMPLAIN;
3791 flags |= LOOKUP_PREFER_TYPES;
3792 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3793 return select_decl (&binding, flags);
3795 else if (is_aggr_type (scope, complain))
3798 t = lookup_member (scope, name, 0, is_type_p);
3803 return error_mark_node;
3806 /* Subroutine of unqualified_namespace_lookup:
3807 Add the bindings of NAME in used namespaces to VAL.
3808 We are currently looking for names in namespace SCOPE, so we
3809 look through USINGS for using-directives of namespaces
3810 which have SCOPE as a common ancestor with the current scope.
3811 Returns false on errors. */
3814 lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
3818 timevar_push (TV_NAME_LOOKUP);
3819 /* Iterate over all used namespaces in current, searching for using
3820 directives of scope. */
3821 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3822 if (TREE_VALUE (iter) == scope)
3824 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3826 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3827 /* Resolve ambiguities. */
3829 val = ambiguous_decl (name, val, val1, flags);
3831 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3835 Accepts the NAME to lookup and its qualifying SCOPE.
3836 Returns the name/type pair found into the cxx_binding *RESULT,
3837 or false on error. */
3840 qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
3843 /* Maintain a list of namespaces visited... */
3844 tree seen = NULL_TREE;
3845 /* ... and a list of namespace yet to see. */
3846 tree todo = NULL_TREE;
3847 tree todo_maybe = NULL_TREE;
3849 timevar_push (TV_NAME_LOOKUP);
3850 /* Look through namespace aliases. */
3851 scope = ORIGINAL_NAMESPACE (scope);
3852 while (scope && result->value != error_mark_node)
3854 cxx_binding *binding =
3855 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3856 seen = tree_cons (scope, NULL_TREE, seen);
3858 result = ambiguous_decl (name, result, binding, flags);
3860 /* Consider strong using directives always, and non-strong ones
3861 if we haven't found a binding yet. ??? Shouldn't we consider
3862 non-strong ones if the initial RESULT is non-NULL, but the
3863 binding in the given namespace is? */
3864 for (usings = DECL_NAMESPACE_USING (scope); usings;
3865 usings = TREE_CHAIN (usings))
3866 /* If this was a real directive, and we have not seen it. */
3867 if (!TREE_INDIRECT_USING (usings))
3869 /* Try to avoid queuing the same namespace more than once,
3870 the exception being when a namespace was already
3871 enqueued for todo_maybe and then a strong using is
3872 found for it. We could try to remove it from
3873 todo_maybe, but it's probably not worth the effort. */
3874 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3875 && !purpose_member (TREE_PURPOSE (usings), seen)
3876 && !purpose_member (TREE_PURPOSE (usings), todo))
3877 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3878 else if ((!result->value && !result->type)
3879 && !purpose_member (TREE_PURPOSE (usings), seen)
3880 && !purpose_member (TREE_PURPOSE (usings), todo)
3881 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3882 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3887 scope = TREE_PURPOSE (todo);
3888 todo = TREE_CHAIN (todo);
3891 && (!result->value && !result->type))
3893 scope = TREE_PURPOSE (todo_maybe);
3894 todo = TREE_CHAIN (todo_maybe);
3895 todo_maybe = NULL_TREE;
3898 scope = NULL_TREE; /* If there never was a todo list. */
3900 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3903 /* Look up NAME in the current binding level and its superiors in the
3904 namespace of variables, functions and typedefs. Return a ..._DECL
3905 node of some kind representing its definition if there is only one
3906 such declaration, or return a TREE_LIST with all the overloaded
3907 definitions if there are many, or return 0 if it is undefined.
3909 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3910 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3911 Otherwise we prefer non-TYPE_DECLs.
3913 If NONCLASS is nonzero, we don't look for the NAME in class scope,
3914 using IDENTIFIER_CLASS_VALUE. */
3917 lookup_name_real (tree name, int prefer_type, int nonclass,
3918 int namespaces_only, int flags)
3921 tree val = NULL_TREE;
3923 timevar_push (TV_NAME_LOOKUP);
3924 /* Conversion operators are handled specially because ordinary
3925 unqualified name lookup will not find template conversion
3927 if (IDENTIFIER_TYPENAME_P (name))
3929 struct cp_binding_level *level;
3931 for (level = current_binding_level;
3932 level && level->kind != sk_namespace;
3933 level = level->level_chain)
3938 /* A conversion operator can only be declared in a class
3940 if (level->kind != sk_class)
3943 /* Lookup the conversion operator in the class. */
3944 class_type = level->this_entity;
3945 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3947 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3950 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3953 flags |= lookup_flags (prefer_type, namespaces_only);
3955 /* First, look in non-namespace scopes. */
3957 if (current_class_type == NULL_TREE)
3960 for (iter = IDENTIFIER_BINDING (name); iter; iter = iter->previous)
3964 if (!LOCAL_BINDING_P (iter) && nonclass)
3965 /* We're not looking for class-scoped bindings, so keep going. */
3968 /* If this is the kind of thing we're looking for, we're done. */
3969 if (qualify_lookup (iter->value, flags))
3970 binding = iter->value;
3971 else if ((flags & LOOKUP_PREFER_TYPES)
3972 && qualify_lookup (iter->type, flags))
3973 binding = iter->type;
3975 binding = NULL_TREE;
3984 /* Now lookup in namespace scopes. */
3987 tree t = unqualified_namespace_lookup (name, flags);
3994 /* If we have a single function from a using decl, pull it out. */
3995 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3996 val = OVL_FUNCTION (val);
3999 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4003 lookup_name_nonclass (tree name)
4005 return lookup_name_real (name, 0, 1, 0, LOOKUP_COMPLAIN);
4009 lookup_function_nonclass (tree name, tree args)
4011 return lookup_arg_dependent (name, lookup_name_nonclass (name), args);
4015 lookup_name (tree name, int prefer_type)
4017 return lookup_name_real (name, prefer_type, 0, 0, LOOKUP_COMPLAIN);
4020 /* Similar to `lookup_name' but look only in the innermost non-class
4024 lookup_name_current_level (tree name)
4026 struct cp_binding_level *b;
4029 timevar_push (TV_NAME_LOOKUP);
4030 b = innermost_nonclass_level ();
4032 if (b->kind == sk_namespace)
4034 t = IDENTIFIER_NAMESPACE_VALUE (name);
4036 /* extern "C" function() */
4037 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4040 else if (IDENTIFIER_BINDING (name)
4041 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4045 if (IDENTIFIER_BINDING (name)->scope == b)
4046 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
4048 if (b->kind == sk_cleanup)
4055 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4058 /* Like lookup_name_current_level, but for types. */
4061 lookup_type_current_level (tree name)
4065 timevar_push (TV_NAME_LOOKUP);
4066 my_friendly_assert (current_binding_level->kind != sk_namespace,
4069 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4070 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4072 struct cp_binding_level *b = current_binding_level;
4075 if (purpose_member (name, b->type_shadowed))
4076 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4077 REAL_IDENTIFIER_TYPE_VALUE (name));
4078 if (b->kind == sk_cleanup)
4085 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4088 /* [basic.lookup.koenig] */
4089 /* A nonzero return value in the functions below indicates an error. */
4099 static bool arg_assoc (struct arg_lookup*, tree);
4100 static bool arg_assoc_args (struct arg_lookup*, tree);
4101 static bool arg_assoc_type (struct arg_lookup*, tree);
4102 static bool add_function (struct arg_lookup *, tree);
4103 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4104 static bool arg_assoc_class (struct arg_lookup *, tree);
4105 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4107 /* Add a function to the lookup structure.
4108 Returns true on error. */
4111 add_function (struct arg_lookup *k, tree fn)
4113 /* We used to check here to see if the function was already in the list,
4114 but that's O(n^2), which is just too expensive for function lookup.
4115 Now we deal with the occasional duplicate in joust. In doing this, we
4116 assume that the number of duplicates will be small compared to the
4117 total number of functions being compared, which should usually be the
4120 /* We must find only functions, or exactly one non-function. */
4123 else if (fn == k->functions)
4125 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4126 k->functions = build_overload (fn, k->functions);
4129 tree f1 = OVL_CURRENT (k->functions);
4131 if (is_overloaded_fn (f1))
4133 fn = f1; f1 = f2; f2 = fn;
4135 cp_error_at ("`%D' is not a function,", f1);
4136 cp_error_at (" conflict with `%D'", f2);
4137 error (" in call to `%D'", k->name);
4144 /* Returns true iff CURRENT has declared itself to be an associated
4145 namespace of SCOPE via a strong using-directive (or transitive chain
4146 thereof). Both are namespaces. */
4149 is_associated_namespace (tree current, tree scope)
4151 tree seen = NULL_TREE;
4152 tree todo = NULL_TREE;
4156 if (scope == current)
4158 seen = tree_cons (scope, NULL_TREE, seen);
4159 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4160 if (!purpose_member (TREE_PURPOSE (t), seen))
4161 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4164 scope = TREE_PURPOSE (todo);
4165 todo = TREE_CHAIN (todo);
4172 /* Add functions of a namespace to the lookup structure.
4173 Returns true on error. */
4176 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4180 if (purpose_member (scope, k->namespaces))
4182 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4184 /* Check out our super-users. */
4185 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4186 value = TREE_CHAIN (value))
4187 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4190 value = namespace_binding (k->name, scope);
4194 for (; value; value = OVL_NEXT (value))
4195 if (add_function (k, OVL_CURRENT (value)))
4201 /* Adds everything associated with a template argument to the lookup
4202 structure. Returns true on error. */
4205 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4207 /* [basic.lookup.koenig]
4209 If T is a template-id, its associated namespaces and classes are
4210 ... the namespaces and classes associated with the types of the
4211 template arguments provided for template type parameters
4212 (excluding template template parameters); the namespaces in which
4213 any template template arguments are defined; and the classes in
4214 which any member templates used as template template arguments
4215 are defined. [Note: non-type template arguments do not
4216 contribute to the set of associated namespaces. ] */
4218 /* Consider first template template arguments. */
4219 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4220 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4222 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4224 tree ctx = CP_DECL_CONTEXT (arg);
4226 /* It's not a member template. */
4227 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4228 return arg_assoc_namespace (k, ctx);
4229 /* Otherwise, it must be member template. */
4231 return arg_assoc_class (k, ctx);
4233 /* It's not a template template argument, but it is a type template
4235 else if (TYPE_P (arg))
4236 return arg_assoc_type (k, arg);
4237 /* It's a non-type template argument. */
4242 /* Adds everything associated with class to the lookup structure.
4243 Returns true on error. */
4246 arg_assoc_class (struct arg_lookup *k, tree type)
4248 tree list, friends, context;
4251 /* Backend build structures, such as __builtin_va_list, aren't
4252 affected by all this. */
4253 if (!CLASS_TYPE_P (type))
4256 if (purpose_member (type, k->classes))
4258 k->classes = tree_cons (type, NULL_TREE, k->classes);
4260 context = decl_namespace (TYPE_MAIN_DECL (type));
4261 if (arg_assoc_namespace (k, context))
4264 /* Process baseclasses. */
4265 for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
4266 if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
4269 /* Process friends. */
4270 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4271 list = TREE_CHAIN (list))
4272 if (k->name == FRIEND_NAME (list))
4273 for (friends = FRIEND_DECLS (list); friends;
4274 friends = TREE_CHAIN (friends))
4275 /* Only interested in global functions with potentially hidden
4276 (i.e. unqualified) declarations. */
4277 if (CP_DECL_CONTEXT (TREE_VALUE (friends)) == context)
4278 if (add_function (k, TREE_VALUE (friends)))
4281 /* Process template arguments. */
4282 if (CLASSTYPE_TEMPLATE_INFO (type))
4284 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4285 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4286 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4292 /* Adds everything associated with a given type.
4293 Returns 1 on error. */
4296 arg_assoc_type (struct arg_lookup *k, tree type)
4298 /* As we do not get the type of non-type dependent expressions
4299 right, we can end up with such things without a type. */
4303 if (TYPE_PTRMEM_P (type))
4305 /* Pointer to member: associate class type and value type. */
4306 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4308 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4310 else switch (TREE_CODE (type))
4323 if (TYPE_PTRMEMFUNC_P (type))
4324 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4325 return arg_assoc_class (k, type);
4327 case REFERENCE_TYPE:
4329 return arg_assoc_type (k, TREE_TYPE (type));
4332 return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
4334 /* The basetype is referenced in the first arg type, so just
4337 /* Associate the parameter types. */
4338 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4340 /* Associate the return type. */
4341 return arg_assoc_type (k, TREE_TYPE (type));
4342 case TEMPLATE_TYPE_PARM:
4343 case BOUND_TEMPLATE_TEMPLATE_PARM:
4348 if (type == unknown_type_node)
4350 /* else fall through */
4357 /* Adds everything associated with arguments. Returns true on error. */
4360 arg_assoc_args (struct arg_lookup *k, tree args)
4362 for (; args; args = TREE_CHAIN (args))
4363 if (arg_assoc (k, TREE_VALUE (args)))
4368 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4371 arg_assoc (struct arg_lookup *k, tree n)
4373 if (n == error_mark_node)
4377 return arg_assoc_type (k, n);
4379 if (! type_unknown_p (n))
4380 return arg_assoc_type (k, TREE_TYPE (n));
4382 if (TREE_CODE (n) == ADDR_EXPR)
4383 n = TREE_OPERAND (n, 0);
4384 if (TREE_CODE (n) == COMPONENT_REF)
4385 n = TREE_OPERAND (n, 1);
4386 if (TREE_CODE (n) == OFFSET_REF)
4387 n = TREE_OPERAND (n, 1);
4388 while (TREE_CODE (n) == TREE_LIST)
4390 if (TREE_CODE (n) == BASELINK)
4391 n = BASELINK_FUNCTIONS (n);
4393 if (TREE_CODE (n) == FUNCTION_DECL)
4394 return arg_assoc_type (k, TREE_TYPE (n));
4395 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4397 /* [basic.lookup.koenig]
4399 If T is a template-id, its associated namespaces and classes
4400 are the namespace in which the template is defined; for
4401 member templates, the member template's class... */
4402 tree template = TREE_OPERAND (n, 0);
4403 tree args = TREE_OPERAND (n, 1);
4407 if (TREE_CODE (template) == COMPONENT_REF)
4408 template = TREE_OPERAND (template, 1);
4410 /* First, the template. There may actually be more than one if
4411 this is an overloaded function template. But, in that case,
4412 we only need the first; all the functions will be in the same
4414 template = OVL_CURRENT (template);
4416 ctx = CP_DECL_CONTEXT (template);
4418 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4420 if (arg_assoc_namespace (k, ctx) == 1)
4423 /* It must be a member template. */
4424 else if (arg_assoc_class (k, ctx) == 1)
4427 /* Now the arguments. */
4428 for (ix = TREE_VEC_LENGTH (args); ix--;)
4429 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4434 my_friendly_assert (TREE_CODE (n) == OVERLOAD, 980715);
4436 for (; n; n = OVL_CHAIN (n))
4437 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4444 /* Performs Koenig lookup depending on arguments, where fns
4445 are the functions found in normal lookup. */
4448 lookup_arg_dependent (tree name, tree fns, tree args)
4450 struct arg_lookup k;
4451 tree fn = NULL_TREE;
4453 timevar_push (TV_NAME_LOOKUP);
4456 k.classes = NULL_TREE;
4458 /* We've already looked at some namespaces during normal unqualified
4459 lookup -- but we don't know exactly which ones. If the functions
4460 we found were brought into the current namespace via a using
4461 declaration, we have not really checked the namespace from which
4462 they came. Therefore, we check all namespaces here -- unless the
4463 function we have is from the current namespace. */
4465 fn = OVL_CURRENT (fns);
4466 if (fn && TREE_CODE (fn) == FUNCTION_DECL
4467 && CP_DECL_CONTEXT (fn) != current_decl_namespace ())
4468 k.namespaces = NULL_TREE;
4470 /* Setting NAMESPACES is purely an optimization; it prevents
4471 adding functions which are already in FNS. Adding them would
4472 be safe -- "joust" will eliminate the duplicates -- but
4474 k.namespaces = build_tree_list (current_decl_namespace (), NULL_TREE);
4476 arg_assoc_args (&k, args);
4477 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4480 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4481 changed (i.e. there was already a directive), or the fresh
4482 TREE_LIST otherwise. */
4485 push_using_directive (tree used)
4487 tree ud = current_binding_level->using_directives;
4488 tree iter, ancestor;
4490 timevar_push (TV_NAME_LOOKUP);
4491 /* Check if we already have this. */
4492 if (purpose_member (used, ud) != NULL_TREE)
4493 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4495 ancestor = namespace_ancestor (current_decl_namespace (), used);
4496 ud = current_binding_level->using_directives;
4497 ud = tree_cons (used, ancestor, ud);
4498 current_binding_level->using_directives = ud;
4500 /* Recursively add all namespaces used. */
4501 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4502 push_using_directive (TREE_PURPOSE (iter));
4504 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4507 /* The type TYPE is being declared. If it is a class template, or a
4508 specialization of a class template, do any processing required and
4509 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4510 being declared a friend. B is the binding level at which this TYPE
4513 Returns the TYPE_DECL for TYPE, which may have been altered by this
4517 maybe_process_template_type_declaration (tree type, int globalize,
4520 tree decl = TYPE_NAME (type);
4522 if (processing_template_parmlist)
4523 /* You can't declare a new template type in a template parameter
4524 list. But, you can declare a non-template type:
4526 template <class A*> struct S;
4528 is a forward-declaration of `A'. */
4532 maybe_check_template_type (type);
4534 my_friendly_assert (IS_AGGR_TYPE (type)
4535 || TREE_CODE (type) == ENUMERAL_TYPE, 0);
4538 if (processing_template_decl)
4540 /* This may change after the call to
4541 push_template_decl_real, but we want the original value. */
4542 tree name = DECL_NAME (decl);
4544 decl = push_template_decl_real (decl, globalize);
4545 /* If the current binding level is the binding level for the
4546 template parameters (see the comment in
4547 begin_template_parm_list) and the enclosing level is a class
4548 scope, and we're not looking at a friend, push the
4549 declaration of the member class into the class scope. In the
4550 friend case, push_template_decl will already have put the
4551 friend into global scope, if appropriate. */
4552 if (TREE_CODE (type) != ENUMERAL_TYPE
4553 && !globalize && b->kind == sk_template_parms
4554 && b->level_chain->kind == sk_class)
4556 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4557 /* Put this UDT in the table of UDTs for the class, since
4558 that won't happen below because B is not the class
4559 binding level, but is instead the pseudo-global level. */
4560 if (b->level_chain->type_decls == NULL)
4561 b->level_chain->type_decls =
4562 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4563 binding_table_insert (b->level_chain->type_decls, name, type);
4564 if (!COMPLETE_TYPE_P (current_class_type))
4566 maybe_add_class_template_decl_list (current_class_type,
4567 type, /*friend_p=*/0);
4568 CLASSTYPE_NESTED_UTDS (current_class_type) =
4569 b->level_chain->type_decls;
4578 /* Push a tag name NAME for struct/class/union/enum type TYPE.
4579 Normally put it into the inner-most non-sk_cleanup scope,
4580 but if GLOBALIZE is true, put it in the inner-most non-class scope.
4581 The latter is needed for implicit declarations. */
4584 pushtag (tree name, tree type, int globalize)
4586 struct cp_binding_level *b;
4588 timevar_push (TV_NAME_LOOKUP);
4589 b = current_binding_level;
4590 while (b->kind == sk_cleanup
4591 || (b->kind == sk_class
4593 /* We may be defining a new type in the initializer
4594 of a static member variable. We allow this when
4595 not pedantic, and it is particularly useful for
4596 type punning via an anonymous union. */
4597 || COMPLETE_TYPE_P (b->this_entity))))
4600 if (b->type_decls == NULL)
4601 b->type_decls = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4602 binding_table_insert (b->type_decls, name, type);
4606 /* Do C++ gratuitous typedefing. */
4607 if (IDENTIFIER_TYPE_VALUE (name) != type)
4611 tree context = TYPE_CONTEXT (type);
4615 tree cs = current_scope ();
4619 else if (cs != NULL_TREE && TYPE_P (cs))
4620 /* When declaring a friend class of a local class, we want
4621 to inject the newly named class into the scope
4622 containing the local class, not the namespace scope. */
4623 context = decl_function_context (get_type_decl (cs));
4626 context = current_namespace;
4628 if (b->kind == sk_class
4629 || (b->kind == sk_template_parms
4630 && b->level_chain->kind == sk_class))
4633 if (current_lang_name == lang_name_java)
4634 TYPE_FOR_JAVA (type) = 1;
4636 d = create_implicit_typedef (name, type);
4637 DECL_CONTEXT (d) = FROB_CONTEXT (context);
4639 set_identifier_type_value_with_scope (name, d, b);
4641 d = maybe_process_template_type_declaration (type,
4644 if (b->kind == sk_class)
4646 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4647 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4648 class. But if it's a member template class, we
4649 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4651 finish_member_declaration (d);
4653 pushdecl_class_level (d);
4656 d = pushdecl_with_scope (d, b);
4658 /* FIXME what if it gets a name from typedef? */
4659 if (ANON_AGGRNAME_P (name))
4660 DECL_IGNORED_P (d) = 1;
4662 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
4664 /* If this is a local class, keep track of it. We need this
4665 information for name-mangling, and so that it is possible to find
4666 all function definitions in a translation unit in a convenient
4667 way. (It's otherwise tricky to find a member function definition
4668 it's only pointed to from within a local class.) */
4669 if (TYPE_CONTEXT (type)
4670 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
4671 && !processing_template_decl)
4672 VARRAY_PUSH_TREE (local_classes, type);
4674 if (b->kind == sk_class
4675 && !COMPLETE_TYPE_P (current_class_type))
4677 maybe_add_class_template_decl_list (current_class_type,
4678 type, /*friend_p=*/0);
4679 CLASSTYPE_NESTED_UTDS (current_class_type) = b->type_decls;
4683 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
4684 /* Use the canonical TYPE_DECL for this node. */
4685 TYPE_STUB_DECL (type) = TYPE_NAME (type);
4688 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4689 will be the tagged type we just added to the current
4690 binding level. This fake NULL-named TYPE_DECL node helps
4691 dwarfout.c to know when it needs to output a
4692 representation of a tagged type, and it also gives us a
4693 convenient place to record the "scope start" address for
4696 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
4697 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
4699 timevar_pop (TV_NAME_LOOKUP);
4702 /* Allocate storage for saving a C++ binding. */
4703 #define cxx_saved_binding_make() \
4704 (ggc_alloc (sizeof (cxx_saved_binding)))
4706 struct cxx_saved_binding GTY(())
4708 /* Link that chains saved C++ bindings for a given name into a stack. */
4709 cxx_saved_binding *previous;
4710 /* The name of the current binding. */
4712 /* The binding we're saving. */
4713 cxx_binding *binding;
4715 tree real_type_value;
4718 /* Subroutines for reverting temporarily to top-level for instantiation
4719 of templates and such. We actually need to clear out the class- and
4720 local-value slots of all identifiers, so that only the global values
4721 are at all visible. Simply setting current_binding_level to the global
4722 scope isn't enough, because more binding levels may be pushed. */
4723 struct saved_scope *scope_chain;
4725 static cxx_saved_binding *
4726 store_bindings (tree names, cxx_saved_binding *old_bindings)
4729 cxx_saved_binding *search_bindings = old_bindings;
4731 timevar_push (TV_NAME_LOOKUP);
4732 for (t = names; t; t = TREE_CHAIN (t))
4735 cxx_saved_binding *saved;
4736 cxx_saved_binding *t1;
4738 if (TREE_CODE (t) == TREE_LIST)
4739 id = TREE_PURPOSE (t);
4744 /* Note that we may have an IDENTIFIER_CLASS_VALUE even when
4745 we have no IDENTIFIER_BINDING if we have left the class
4746 scope, but cached the class-level declarations. */
4747 || !(IDENTIFIER_BINDING (id) || IDENTIFIER_CLASS_VALUE (id)))
4750 for (t1 = search_bindings; t1; t1 = t1->previous)
4751 if (t1->identifier == id)
4754 my_friendly_assert (TREE_CODE (id) == IDENTIFIER_NODE, 135);
4755 saved = cxx_saved_binding_make ();
4756 saved->previous = old_bindings;
4757 saved->identifier = id;
4758 saved->binding = IDENTIFIER_BINDING (id);
4759 saved->class_value = IDENTIFIER_CLASS_VALUE (id);;
4760 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4761 IDENTIFIER_BINDING (id) = NULL;
4762 IDENTIFIER_CLASS_VALUE (id) = NULL_TREE;
4763 old_bindings = saved;
4767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, old_bindings);
4771 push_to_top_level (void)
4773 struct saved_scope *s;
4774 struct cp_binding_level *b;
4775 cxx_saved_binding *old_bindings;
4778 timevar_push (TV_NAME_LOOKUP);
4779 s = ggc_alloc_cleared (sizeof (struct saved_scope));
4781 b = scope_chain ? current_binding_level : 0;
4783 /* If we're in the middle of some function, save our state. */
4787 push_function_context_to (NULL_TREE);
4792 old_bindings = NULL;
4793 if (scope_chain && previous_class_type)
4794 old_bindings = store_bindings (previous_class_values, old_bindings);
4796 /* Have to include the global scope, because class-scope decls
4797 aren't listed anywhere useful. */
4798 for (; b; b = b->level_chain)
4802 /* Template IDs are inserted into the global level. If they were
4803 inserted into namespace level, finish_file wouldn't find them
4804 when doing pending instantiations. Therefore, don't stop at
4805 namespace level, but continue until :: . */
4806 if (global_scope_p (b))
4809 old_bindings = store_bindings (b->names, old_bindings);
4810 /* We also need to check class_shadowed to save class-level type
4811 bindings, since pushclass doesn't fill in b->names. */
4812 if (b->kind == sk_class)
4813 old_bindings = store_bindings (b->class_shadowed, old_bindings);
4815 /* Unwind type-value slots back to top level. */
4816 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4817 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4819 s->prev = scope_chain;
4820 s->old_bindings = old_bindings;
4822 s->need_pop_function_context = need_pop;
4823 s->function_decl = current_function_decl;
4824 s->last_parms = last_function_parms;
4827 current_function_decl = NULL_TREE;
4828 VARRAY_TREE_INIT (current_lang_base, 10, "current_lang_base");
4829 current_lang_name = lang_name_cplusplus;
4830 current_namespace = global_namespace;
4831 timevar_pop (TV_NAME_LOOKUP);
4835 pop_from_top_level (void)
4837 struct saved_scope *s = scope_chain;
4838 cxx_saved_binding *saved;
4840 timevar_push (TV_NAME_LOOKUP);
4841 /* Clear out class-level bindings cache. */
4842 if (previous_class_type)
4843 invalidate_class_lookup_cache ();
4845 current_lang_base = 0;
4847 scope_chain = s->prev;
4848 for (saved = s->old_bindings; saved; saved = saved->previous)
4850 tree id = saved->identifier;
4852 IDENTIFIER_BINDING (id) = saved->binding;
4853 IDENTIFIER_CLASS_VALUE (id) = saved->class_value;
4854 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
4857 /* If we were in the middle of compiling a function, restore our
4859 if (s->need_pop_function_context)
4860 pop_function_context_from (NULL_TREE);
4861 current_function_decl = s->function_decl;
4862 last_function_parms = s->last_parms;
4863 timevar_pop (TV_NAME_LOOKUP);
4866 /* Pop off extraneous binding levels left over due to syntax errors.
4868 We don't pop past namespaces, as they might be valid. */
4871 pop_everything (void)
4873 if (ENABLE_SCOPE_CHECKING)
4874 verbatim ("XXX entering pop_everything ()\n");
4875 while (!toplevel_bindings_p ())
4877 if (current_binding_level->kind == sk_class)
4878 pop_nested_class ();
4882 if (ENABLE_SCOPE_CHECKING)
4883 verbatim ("XXX leaving pop_everything ()\n");
4886 /* Emit debugging information for using declarations and directives.
4887 If input tree is overloaded fn then emit debug info for all
4891 cp_emit_debug_info_for_using (tree t, tree context)
4893 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
4894 of a builtin function. */
4895 if (TREE_CODE (t) == FUNCTION_DECL
4896 && DECL_EXTERNAL (t)
4897 && DECL_BUILT_IN (t))
4900 /* Do not supply context to imported_module_or_decl, if
4901 it is a global namespace. */
4902 if (context == global_namespace)
4903 context = NULL_TREE;
4906 t = BASELINK_FUNCTIONS (t);
4908 /* FIXME: Handle TEMPLATE_DECLs. */
4909 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
4910 if (TREE_CODE (t) != TEMPLATE_DECL)
4911 (*debug_hooks->imported_module_or_decl) (t, context);
4914 #include "gt-cp-name-lookup.h"