1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005 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 /* The bindings for a particular name in a particular scope. */
37 struct scope_binding {
41 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
43 static cxx_scope *innermost_nonclass_level (void);
44 static tree select_decl (const struct scope_binding *, int);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree lookup_name_innermost_nonclass_level (tree);
47 static tree push_overloaded_decl (tree, int);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
64 /* Compute the chain index of a binding_entry given the HASH value of its
65 name and the total COUNT of chains. COUNT is assumed to be a power
68 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
70 /* A free list of "binding_entry"s awaiting for re-use. */
72 static GTY((deletable)) binding_entry free_binding_entry = NULL;
74 /* Create a binding_entry object for (NAME, TYPE). */
76 static inline binding_entry
77 binding_entry_make (tree name, tree type)
81 if (free_binding_entry)
83 entry = free_binding_entry;
84 free_binding_entry = entry->chain;
87 entry = GGC_NEW (struct binding_entry_s);
96 /* Put ENTRY back on the free list. */
99 binding_entry_free (binding_entry entry)
103 entry->chain = free_binding_entry;
104 free_binding_entry = entry;
108 /* The datatype used to implement the mapping from names to types at
110 struct binding_table_s GTY(())
112 /* Array of chains of "binding_entry"s */
113 binding_entry * GTY((length ("%h.chain_count"))) chain;
115 /* The number of chains in this table. This is the length of the
116 the member "chain" considered as an array. */
119 /* Number of "binding_entry"s in this table. */
123 /* Construct TABLE with an initial CHAIN_COUNT. */
126 binding_table_construct (binding_table table, size_t chain_count)
128 table->chain_count = chain_count;
129 table->entry_count = 0;
130 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
133 /* Make TABLE's entries ready for reuse. */
136 binding_table_free (binding_table table)
144 for (i = 0, count = table->chain_count; i < count; ++i)
146 binding_entry temp = table->chain[i];
149 binding_entry entry = temp;
151 binding_entry_free (entry);
153 table->chain[i] = NULL;
155 table->entry_count = 0;
159 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
161 static inline binding_table
162 binding_table_new (size_t chain_count)
164 binding_table table = GGC_NEW (struct binding_table_s);
166 binding_table_construct (table, chain_count);
170 /* Expand TABLE to twice its current chain_count. */
173 binding_table_expand (binding_table table)
175 const size_t old_chain_count = table->chain_count;
176 const size_t old_entry_count = table->entry_count;
177 const size_t new_chain_count = 2 * old_chain_count;
178 binding_entry *old_chains = table->chain;
181 binding_table_construct (table, new_chain_count);
182 for (i = 0; i < old_chain_count; ++i)
184 binding_entry entry = old_chains[i];
185 for (; entry != NULL; entry = old_chains[i])
187 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
188 const size_t j = ENTRY_INDEX (hash, new_chain_count);
190 old_chains[i] = entry->chain;
191 entry->chain = table->chain[j];
192 table->chain[j] = entry;
195 table->entry_count = old_entry_count;
198 /* Insert a binding for NAME to TYPE into TABLE. */
201 binding_table_insert (binding_table table, tree name, tree type)
203 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
204 const size_t i = ENTRY_INDEX (hash, table->chain_count);
205 binding_entry entry = binding_entry_make (name, type);
207 entry->chain = table->chain[i];
208 table->chain[i] = entry;
209 ++table->entry_count;
211 if (3 * table->chain_count < 5 * table->entry_count)
212 binding_table_expand (table);
215 /* Return the binding_entry, if any, that maps NAME. */
218 binding_table_find (binding_table table, tree name)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
223 while (entry != NULL && entry->name != name)
224 entry = entry->chain;
229 /* Apply PROC -- with DATA -- to all entries in TABLE. */
232 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
234 const size_t chain_count = table->chain_count;
237 for (i = 0; i < chain_count; ++i)
239 binding_entry entry = table->chain[i];
240 for (; entry != NULL; entry = entry->chain)
245 #ifndef ENABLE_SCOPE_CHECKING
246 # define ENABLE_SCOPE_CHECKING 0
248 # define ENABLE_SCOPE_CHECKING 1
251 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
253 static GTY((deletable)) cxx_binding *free_bindings;
255 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
259 cxx_binding_init (cxx_binding *binding, tree value, tree type)
261 binding->value = value;
262 binding->type = type;
263 binding->previous = NULL;
266 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
269 cxx_binding_make (tree value, tree type)
271 cxx_binding *binding;
274 binding = free_bindings;
275 free_bindings = binding->previous;
278 binding = GGC_NEW (cxx_binding);
280 cxx_binding_init (binding, value, type);
285 /* Put BINDING back on the free list. */
288 cxx_binding_free (cxx_binding *binding)
290 binding->scope = NULL;
291 binding->previous = free_bindings;
292 free_bindings = binding;
295 /* Create a new binding for NAME (with the indicated VALUE and TYPE
296 bindings) in the class scope indicated by SCOPE. */
299 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
301 cp_class_binding *cb;
302 cxx_binding *binding;
304 if (VEC_length (cp_class_binding, scope->class_shadowed))
306 cp_class_binding *old_base;
307 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
308 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
310 /* Fixup the current bindings, as they might have moved. */
314 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
318 b = &IDENTIFIER_BINDING (cb->identifier);
319 while (*b != &old_base[i].base)
320 b = &((*b)->previous);
324 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
327 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
329 cb->identifier = name;
331 binding->scope = scope;
332 cxx_binding_init (binding, value, type);
336 /* Make DECL the innermost binding for ID. The LEVEL is the binding
337 level at which this declaration is being bound. */
340 push_binding (tree id, tree decl, cxx_scope* level)
342 cxx_binding *binding;
344 if (level != class_binding_level)
346 binding = cxx_binding_make (decl, NULL_TREE);
347 binding->scope = level;
350 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
352 /* Now, fill in the binding information. */
353 binding->previous = IDENTIFIER_BINDING (id);
354 INHERITED_VALUE_BINDING_P (binding) = 0;
355 LOCAL_BINDING_P (binding) = (level != class_binding_level);
357 /* And put it on the front of the list of bindings for ID. */
358 IDENTIFIER_BINDING (id) = binding;
361 /* Remove the binding for DECL which should be the innermost binding
365 pop_binding (tree id, tree decl)
367 cxx_binding *binding;
370 /* It's easiest to write the loops that call this function without
371 checking whether or not the entities involved have names. We
372 get here for such an entity. */
375 /* Get the innermost binding for ID. */
376 binding = IDENTIFIER_BINDING (id);
378 /* The name should be bound. */
379 gcc_assert (binding != NULL);
381 /* The DECL will be either the ordinary binding or the type
382 binding for this identifier. Remove that binding. */
383 if (binding->value == decl)
384 binding->value = NULL_TREE;
387 gcc_assert (binding->type == decl);
388 binding->type = NULL_TREE;
391 if (!binding->value && !binding->type)
393 /* We're completely done with the innermost binding for this
394 identifier. Unhook it from the list of bindings. */
395 IDENTIFIER_BINDING (id) = binding->previous;
397 /* Add it to the free list. */
398 cxx_binding_free (binding);
402 /* BINDING records an existing declaration for a namein the current scope.
403 But, DECL is another declaration for that same identifier in the
404 same scope. This is the `struct stat' hack whereby a non-typedef
405 class name or enum-name can be bound at the same level as some other
409 A class name (9.1) or enumeration name (7.2) can be hidden by the
410 name of an object, function, or enumerator declared in the same scope.
411 If a class or enumeration name and an object, function, or enumerator
412 are declared in the same scope (in any order) with the same name, the
413 class or enumeration name is hidden wherever the object, function, or
414 enumerator name is visible.
416 It's the responsibility of the caller to check that
417 inserting this name is valid here. Returns nonzero if the new binding
421 supplement_binding (cxx_binding *binding, tree decl)
423 tree bval = binding->value;
426 timevar_push (TV_NAME_LOOKUP);
427 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
428 /* The new name is the type name. */
429 binding->type = decl;
430 else if (/* BVAL is null when push_class_level_binding moves an
431 inherited type-binding out of the way to make room for a
432 new value binding. */
434 /* BVAL is error_mark_node when DECL's name has been used
435 in a non-class scope prior declaration. In that case,
436 we should have already issued a diagnostic; for graceful
437 error recovery purpose, pretend this was the intended
438 declaration for that name. */
439 || bval == error_mark_node
440 /* If BVAL is a built-in that has not yet been declared,
441 pretend it is not there at all. */
442 || (TREE_CODE (bval) == FUNCTION_DECL
443 && DECL_ANTICIPATED (bval)))
444 binding->value = decl;
445 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
447 /* The old binding was a type name. It was placed in
448 VALUE field because it was thought, at the point it was
449 declared, to be the only entity with such a name. Move the
450 type name into the type slot; it is now hidden by the new
452 binding->type = bval;
453 binding->value = decl;
454 binding->value_is_inherited = false;
456 else if (TREE_CODE (bval) == TYPE_DECL
457 && TREE_CODE (decl) == TYPE_DECL
458 && DECL_NAME (decl) == DECL_NAME (bval)
459 && binding->scope->kind != sk_class
460 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
461 /* If either type involves template parameters, we must
462 wait until instantiation. */
463 || uses_template_parms (TREE_TYPE (decl))
464 || uses_template_parms (TREE_TYPE (bval))))
465 /* We have two typedef-names, both naming the same type to have
466 the same name. In general, this is OK because of:
470 In a given scope, a typedef specifier can be used to redefine
471 the name of any type declared in that scope to refer to the
472 type to which it already refers.
474 However, in class scopes, this rule does not apply due to the
475 stricter language in [class.mem] prohibiting redeclarations of
478 /* There can be two block-scope declarations of the same variable,
479 so long as they are `extern' declarations. However, there cannot
480 be two declarations of the same static data member:
484 A member shall not be declared twice in the
485 member-specification. */
486 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
487 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
488 && !DECL_CLASS_SCOPE_P (decl))
490 duplicate_decls (decl, binding->value);
493 else if (TREE_CODE (decl) == NAMESPACE_DECL
494 && TREE_CODE (bval) == NAMESPACE_DECL
495 && DECL_NAMESPACE_ALIAS (decl)
496 && DECL_NAMESPACE_ALIAS (bval)
497 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
500 In a declarative region, a namespace-alias-definition can be
501 used to redefine a namespace-alias declared in that declarative
502 region to refer only to the namespace to which it already
507 error ("declaration of %q#D", decl);
508 cp_error_at ("conflicts with previous declaration %q#D", bval);
512 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
515 /* Add DECL to the list of things declared in B. */
518 add_decl_to_level (tree decl, cxx_scope *b)
520 if (TREE_CODE (decl) == NAMESPACE_DECL
521 && !DECL_NAMESPACE_ALIAS (decl))
523 TREE_CHAIN (decl) = b->namespaces;
524 b->namespaces = decl;
526 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
528 TREE_CHAIN (decl) = b->vtables;
533 /* We build up the list in reverse order, and reverse it later if
535 TREE_CHAIN (decl) = b->names;
539 /* If appropriate, add decl to separate list of statics. We
540 include extern variables because they might turn out to be
541 static later. It's OK for this list to contain a few false
543 if (b->kind == sk_namespace)
544 if ((TREE_CODE (decl) == VAR_DECL
545 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
546 || (TREE_CODE (decl) == FUNCTION_DECL
547 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
548 VEC_safe_push (tree, gc, b->static_decls, decl);
552 /* Record a decl-node X as belonging to the current lexical scope.
553 Check for errors (such as an incompatible declaration for the same
554 name already seen in the same scope).
556 Returns either X or an old decl for the same name.
557 If an old decl is returned, it may have been smashed
558 to agree with what X says. */
565 int need_new_binding;
567 timevar_push (TV_NAME_LOOKUP);
569 need_new_binding = 1;
571 if (DECL_TEMPLATE_PARM_P (x))
572 /* Template parameters have no context; they are not X::T even
573 when declared within a class or namespace. */
577 if (current_function_decl && x != current_function_decl
578 /* A local declaration for a function doesn't constitute
580 && TREE_CODE (x) != FUNCTION_DECL
581 /* A local declaration for an `extern' variable is in the
582 scope of the current namespace, not the current
584 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
585 && !DECL_CONTEXT (x))
586 DECL_CONTEXT (x) = current_function_decl;
588 /* If this is the declaration for a namespace-scope function,
589 but the declaration itself is in a local scope, mark the
591 if (TREE_CODE (x) == FUNCTION_DECL
592 && DECL_NAMESPACE_SCOPE_P (x)
593 && current_function_decl
594 && x != current_function_decl)
595 DECL_LOCAL_FUNCTION_P (x) = 1;
598 name = DECL_NAME (x);
601 int different_binding_level = 0;
603 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
604 name = TREE_OPERAND (name, 0);
606 /* In case this decl was explicitly namespace-qualified, look it
607 up in its namespace context. */
608 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
609 t = namespace_binding (name, DECL_CONTEXT (x));
611 t = lookup_name_innermost_nonclass_level (name);
613 /* [basic.link] If there is a visible declaration of an entity
614 with linkage having the same name and type, ignoring entities
615 declared outside the innermost enclosing namespace scope, the
616 block scope declaration declares that same entity and
617 receives the linkage of the previous declaration. */
618 if (! t && current_function_decl && x != current_function_decl
619 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
620 && DECL_EXTERNAL (x))
622 /* Look in block scope. */
623 t = innermost_non_namespace_value (name);
624 /* Or in the innermost namespace. */
626 t = namespace_binding (name, DECL_CONTEXT (x));
627 /* Does it have linkage? Note that if this isn't a DECL, it's an
628 OVERLOAD, which is OK. */
629 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
632 different_binding_level = 1;
635 /* If we are declaring a function, and the result of name-lookup
636 was an OVERLOAD, look for an overloaded instance that is
637 actually the same as the function we are declaring. (If
638 there is one, we have to merge our declaration with the
639 previous declaration.) */
640 if (t && TREE_CODE (t) == OVERLOAD)
644 if (TREE_CODE (x) == FUNCTION_DECL)
645 for (match = t; match; match = OVL_NEXT (match))
647 if (decls_match (OVL_CURRENT (match), x))
651 /* Just choose one. */
655 t = OVL_CURRENT (match);
660 if (t && t != error_mark_node)
662 if (different_binding_level)
664 if (decls_match (x, t))
665 /* The standard only says that the local extern
666 inherits linkage from the previous decl; in
667 particular, default args are not shared. We must
668 also tell cgraph to treat these decls as the same,
669 or we may neglect to emit an "unused" static - we
670 do this by making the DECL_UIDs equal, which should
671 be viewed as a kludge. FIXME. */
673 TREE_PUBLIC (x) = TREE_PUBLIC (t);
674 DECL_UID (x) = DECL_UID (t);
677 else if (TREE_CODE (t) == PARM_DECL)
679 gcc_assert (DECL_CONTEXT (t));
681 /* Check for duplicate params. */
682 if (duplicate_decls (x, t))
683 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
685 else if ((DECL_EXTERN_C_FUNCTION_P (x)
686 || DECL_FUNCTION_TEMPLATE_P (x))
687 && is_overloaded_fn (t))
688 /* Don't do anything just yet. */;
689 else if (t == wchar_decl_node)
691 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
692 pedwarn ("redeclaration of %<wchar_t%> as %qT",
695 /* Throw away the redeclaration. */
696 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
700 tree olddecl = duplicate_decls (x, t);
702 /* If the redeclaration failed, we can stop at this
704 if (olddecl == error_mark_node)
705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
709 if (TREE_CODE (t) == TYPE_DECL)
710 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
711 else if (TREE_CODE (t) == FUNCTION_DECL)
712 check_default_args (t);
714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
716 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
718 /* A redeclaration of main, but not a duplicate of the
723 This function shall not be overloaded. */
724 cp_error_at ("invalid redeclaration of %qD", t);
726 /* We don't try to push this declaration since that
728 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
733 check_template_shadow (x);
735 /* If this is a function conjured up by the backend, massage it
736 so it looks friendly. */
737 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
739 retrofit_lang_decl (x);
740 SET_DECL_LANGUAGE (x, lang_c);
743 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
745 t = push_overloaded_decl (x, PUSH_LOCAL);
747 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
748 if (!namespace_bindings_p ())
749 /* We do not need to create a binding for this name;
750 push_overloaded_decl will have already done so if
752 need_new_binding = 0;
754 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
756 t = push_overloaded_decl (x, PUSH_GLOBAL);
758 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
759 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
762 /* If declaring a type as a typedef, copy the type (unless we're
763 at line 0), and install this TYPE_DECL as the new type's typedef
764 name. See the extensive comment in ../c-decl.c (pushdecl). */
765 if (TREE_CODE (x) == TYPE_DECL)
767 tree type = TREE_TYPE (x);
768 if (DECL_IS_BUILTIN (x))
770 if (TYPE_NAME (type) == 0)
771 TYPE_NAME (type) = x;
773 else if (type != error_mark_node && TYPE_NAME (type) != x
774 /* We don't want to copy the type when all we're
775 doing is making a TYPE_DECL for the purposes of
777 && (!TYPE_NAME (type)
778 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
780 DECL_ORIGINAL_TYPE (x) = type;
781 type = build_variant_type_copy (type);
782 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
783 TYPE_NAME (type) = x;
784 TREE_TYPE (x) = type;
787 if (type != error_mark_node
789 && TYPE_IDENTIFIER (type))
790 set_identifier_type_value (DECL_NAME (x), x);
793 /* Multiple external decls of the same identifier ought to match.
795 We get warnings about inline functions where they are defined.
796 We get warnings about other functions from push_overloaded_decl.
798 Avoid duplicate warnings where they are used. */
799 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
803 decl = IDENTIFIER_NAMESPACE_VALUE (name);
804 if (decl && TREE_CODE (decl) == OVERLOAD)
805 decl = OVL_FUNCTION (decl);
807 if (decl && decl != error_mark_node
808 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
809 /* If different sort of thing, we already gave an error. */
810 && TREE_CODE (decl) == TREE_CODE (x)
811 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
813 pedwarn ("type mismatch with previous external decl of %q#D", x);
814 cp_pedwarn_at ("previous external decl of %q#D", decl);
818 /* This name is new in its binding level.
819 Install the new declaration and return it. */
820 if (namespace_bindings_p ())
822 /* Install a global value. */
824 /* If the first global decl has external linkage,
825 warn if we later see static one. */
826 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
827 TREE_PUBLIC (name) = 1;
829 /* Bind the name for the entity. */
830 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
832 && (TREE_CODE (x) == TYPE_DECL
833 || TREE_CODE (x) == VAR_DECL
834 || TREE_CODE (x) == ALIAS_DECL
835 || TREE_CODE (x) == NAMESPACE_DECL
836 || TREE_CODE (x) == CONST_DECL
837 || TREE_CODE (x) == TEMPLATE_DECL))
838 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
840 /* If new decl is `static' and an `extern' was seen previously,
842 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
843 warn_extern_redeclared_static (x, t);
847 /* Here to install a non-global value. */
848 tree oldlocal = innermost_non_namespace_value (name);
849 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
851 if (need_new_binding)
853 push_local_binding (name, x, 0);
854 /* Because push_local_binding will hook X on to the
855 current_binding_level's name list, we don't want to
856 do that again below. */
857 need_new_binding = 0;
860 /* If this is a TYPE_DECL, push it into the type value slot. */
861 if (TREE_CODE (x) == TYPE_DECL)
862 set_identifier_type_value (name, x);
864 /* Clear out any TYPE_DECL shadowed by a namespace so that
865 we won't think this is a type. The C struct hack doesn't
866 go through namespaces. */
867 if (TREE_CODE (x) == NAMESPACE_DECL)
868 set_identifier_type_value (name, NULL_TREE);
875 && TREE_CODE (oldlocal) == VAR_DECL
876 && DECL_DEAD_FOR_LOCAL (oldlocal))
877 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
879 if (oldlocal == NULL_TREE)
880 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
883 /* If this is an extern function declaration, see if we
884 have a global definition or declaration for the function. */
885 if (oldlocal == NULL_TREE
887 && oldglobal != NULL_TREE
888 && TREE_CODE (x) == FUNCTION_DECL
889 && TREE_CODE (oldglobal) == FUNCTION_DECL)
891 /* We have one. Their types must agree. */
892 if (decls_match (x, oldglobal))
896 warning (0, "extern declaration of %q#D doesn't match", x);
897 cp_warning_at ("global declaration %q#D", oldglobal);
900 /* If we have a local external declaration,
901 and no file-scope declaration has yet been seen,
902 then if we later have a file-scope decl it must not be static. */
903 if (oldlocal == NULL_TREE
904 && oldglobal == NULL_TREE
907 TREE_PUBLIC (name) = 1;
909 /* Warn if shadowing an argument at the top level of the body. */
910 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
911 /* Inline decls shadow nothing. */
912 && !DECL_FROM_INLINE (x)
913 && TREE_CODE (oldlocal) == PARM_DECL
914 /* Don't check the `this' parameter. */
915 && !DECL_ARTIFICIAL (oldlocal))
919 /* Don't complain if it's from an enclosing function. */
920 if (DECL_CONTEXT (oldlocal) == current_function_decl
921 && TREE_CODE (x) != PARM_DECL)
923 /* Go to where the parms should be and see if we find
925 struct cp_binding_level *b = current_binding_level->level_chain;
927 /* Skip the ctor/dtor cleanup level. */
931 if (b->kind == sk_function_parms)
933 error ("declaration of %q#D shadows a parameter", x);
938 if (warn_shadow && !err)
940 warning (0, "declaration of %q#D shadows a parameter", x);
941 warning (0, "%Jshadowed declaration is here", oldlocal);
945 /* Maybe warn if shadowing something else. */
946 else if (warn_shadow && !DECL_EXTERNAL (x)
947 /* No shadow warnings for internally generated vars. */
948 && ! DECL_ARTIFICIAL (x)
949 /* No shadow warnings for vars made for inlining. */
950 && ! DECL_FROM_INLINE (x))
954 if (current_class_ptr)
955 member = lookup_member (current_class_type,
958 /*want_type=*/false);
962 if (member && !TREE_STATIC (member))
964 /* Location of previous decl is not useful in this case. */
965 warning (0, "declaration of %qD shadows a member of 'this'",
968 else if (oldlocal != NULL_TREE
969 && TREE_CODE (oldlocal) == VAR_DECL)
971 warning (0, "declaration of %qD shadows a previous local", x);
972 warning (0, "%Jshadowed declaration is here", oldlocal);
974 else if (oldglobal != NULL_TREE
975 && TREE_CODE (oldglobal) == VAR_DECL)
976 /* XXX shadow warnings in outer-more namespaces */
978 warning (0, "declaration of %qD shadows a global declaration",
980 warning (0, "%Jshadowed declaration is here", oldglobal);
985 if (TREE_CODE (x) == FUNCTION_DECL)
986 check_default_args (x);
988 if (TREE_CODE (x) == VAR_DECL)
989 maybe_register_incomplete_var (x);
992 if (need_new_binding)
993 add_decl_to_level (x,
994 DECL_NAMESPACE_SCOPE_P (x)
995 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
996 : current_binding_level);
998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1001 /* Enter DECL into the symbol table, if that's appropriate. Returns
1002 DECL, or a modified version thereof. */
1005 maybe_push_decl (tree decl)
1007 tree type = TREE_TYPE (decl);
1009 /* Add this decl to the current binding level, but not if it comes
1010 from another scope, e.g. a static member variable. TEM may equal
1011 DECL or it may be a previous decl of the same name. */
1012 if (decl == error_mark_node
1013 || (TREE_CODE (decl) != PARM_DECL
1014 && DECL_CONTEXT (decl) != NULL_TREE
1015 /* Definitions of namespace members outside their namespace are
1017 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1018 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1019 || TREE_CODE (type) == UNKNOWN_TYPE
1020 /* The declaration of a template specialization does not affect
1021 the functions available for overload resolution, so we do not
1023 || (TREE_CODE (decl) == FUNCTION_DECL
1024 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1027 return pushdecl (decl);
1030 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1031 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1032 doesn't really belong to this binding level, that it got here
1033 through a using-declaration. */
1036 push_local_binding (tree id, tree decl, int flags)
1038 struct cp_binding_level *b;
1040 /* Skip over any local classes. This makes sense if we call
1041 push_local_binding with a friend decl of a local class. */
1042 b = innermost_nonclass_level ();
1044 if (lookup_name_innermost_nonclass_level (id))
1046 /* Supplement the existing binding. */
1047 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1048 /* It didn't work. Something else must be bound at this
1049 level. Do not add DECL to the list of things to pop
1054 /* Create a new binding. */
1055 push_binding (id, decl, b);
1057 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1058 /* We must put the OVERLOAD into a TREE_LIST since the
1059 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1060 decls that got here through a using-declaration. */
1061 decl = build_tree_list (NULL_TREE, decl);
1063 /* And put DECL on the list of things declared by the current
1065 add_decl_to_level (decl, b);
1068 /* Check to see whether or not DECL is a variable that would have been
1069 in scope under the ARM, but is not in scope under the ANSI/ISO
1070 standard. If so, issue an error message. If name lookup would
1071 work in both cases, but return a different result, this function
1072 returns the result of ANSI/ISO lookup. Otherwise, it returns
1076 check_for_out_of_scope_variable (tree decl)
1080 /* We only care about out of scope variables. */
1081 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1084 shadowed = DECL_SHADOWED_FOR_VAR (decl);
1085 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1086 && DECL_DEAD_FOR_LOCAL (shadowed))
1087 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1089 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1092 if (!DECL_ERROR_REPORTED (decl))
1094 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1095 cp_warning_at (" matches this %qD under ISO standard rules",
1097 cp_warning_at (" matches this %qD under old rules", decl);
1098 DECL_ERROR_REPORTED (decl) = 1;
1103 /* If we have already complained about this declaration, there's no
1104 need to do it again. */
1105 if (DECL_ERROR_REPORTED (decl))
1108 DECL_ERROR_REPORTED (decl) = 1;
1110 if (TREE_TYPE (decl) == error_mark_node)
1113 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1115 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1117 cp_error_at (" cannot use obsolete binding at %qD because "
1118 "it has a destructor", decl);
1119 return error_mark_node;
1123 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1125 cp_pedwarn_at (" using obsolete binding at %qD", decl);
1131 /* true means unconditionally make a BLOCK for the next level pushed. */
1133 static bool keep_next_level_flag;
1135 static int binding_depth = 0;
1136 static int is_class_level = 0;
1143 for (i = 0; i < depth * 2; i++)
1147 /* Return a string describing the kind of SCOPE we have. */
1149 cxx_scope_descriptor (cxx_scope *scope)
1151 /* The order of this table must match the "scope_kind"
1153 static const char* scope_kind_names[] = {
1159 "function-parameter-scope",
1162 "template-parameter-scope",
1163 "template-explicit-spec-scope"
1165 const scope_kind kind = scope->explicit_spec_p
1166 ? sk_template_spec : scope->kind;
1168 return scope_kind_names[kind];
1171 /* Output a debugging information about SCOPE when performing
1174 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1176 const char *desc = cxx_scope_descriptor (scope);
1177 if (scope->this_entity)
1178 verbatim ("%s %s(%E) %p %d\n", action, desc,
1179 scope->this_entity, (void *) scope, line);
1181 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1184 /* Return the estimated initial size of the hashtable of a NAMESPACE
1187 static inline size_t
1188 namespace_scope_ht_size (tree ns)
1190 tree name = DECL_NAME (ns);
1192 return name == std_identifier
1193 ? NAMESPACE_STD_HT_SIZE
1194 : (name == global_scope_name
1195 ? GLOBAL_SCOPE_HT_SIZE
1196 : NAMESPACE_ORDINARY_HT_SIZE);
1199 /* A chain of binding_level structures awaiting reuse. */
1201 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1203 /* Insert SCOPE as the innermost binding level. */
1206 push_binding_level (struct cp_binding_level *scope)
1208 /* Add it to the front of currently active scopes stack. */
1209 scope->level_chain = current_binding_level;
1210 current_binding_level = scope;
1211 keep_next_level_flag = false;
1213 if (ENABLE_SCOPE_CHECKING)
1215 scope->binding_depth = binding_depth;
1216 indent (binding_depth);
1217 cxx_scope_debug (scope, input_line, "push");
1223 /* Create a new KIND scope and make it the top of the active scopes stack.
1224 ENTITY is the scope of the associated C++ entity (namespace, class,
1225 function); it is NULL otherwise. */
1228 begin_scope (scope_kind kind, tree entity)
1232 /* Reuse or create a struct for this binding level. */
1233 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1235 scope = free_binding_level;
1236 free_binding_level = scope->level_chain;
1239 scope = GGC_NEW (cxx_scope);
1240 memset (scope, 0, sizeof (cxx_scope));
1242 scope->this_entity = entity;
1243 scope->more_cleanups_ok = true;
1250 case sk_template_spec:
1251 scope->explicit_spec_p = true;
1252 kind = sk_template_parms;
1254 case sk_template_parms:
1260 case sk_function_parms:
1261 scope->keep = keep_next_level_flag;
1265 NAMESPACE_LEVEL (entity) = scope;
1266 scope->static_decls =
1267 VEC_alloc (tree, gc,
1268 DECL_NAME (entity) == std_identifier
1269 || DECL_NAME (entity) == global_scope_name
1274 /* Should not happen. */
1280 push_binding_level (scope);
1285 /* We're about to leave current scope. Pop the top of the stack of
1286 currently active scopes. Return the enclosing scope, now active. */
1291 cxx_scope *scope = current_binding_level;
1293 if (scope->kind == sk_namespace && class_binding_level)
1294 current_binding_level = class_binding_level;
1296 /* We cannot leave a scope, if there are none left. */
1297 if (NAMESPACE_LEVEL (global_namespace))
1298 gcc_assert (!global_scope_p (scope));
1300 if (ENABLE_SCOPE_CHECKING)
1302 indent (--binding_depth);
1303 cxx_scope_debug (scope, input_line, "leave");
1304 if (is_class_level != (scope == class_binding_level))
1306 indent (binding_depth);
1307 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1312 /* Move one nesting level up. */
1313 current_binding_level = scope->level_chain;
1315 /* Namespace-scopes are left most probably temporarily, not
1316 completely; they can be reopen later, e.g. in namespace-extension
1317 or any name binding activity that requires us to resume a
1318 namespace. For classes, we cache some binding levels. For other
1319 scopes, we just make the structure available for reuse. */
1320 if (scope->kind != sk_namespace
1321 && scope->kind != sk_class)
1323 scope->level_chain = free_binding_level;
1324 gcc_assert (!ENABLE_SCOPE_CHECKING
1325 || scope->binding_depth == binding_depth);
1326 free_binding_level = scope;
1329 /* Find the innermost enclosing class scope, and reset
1330 CLASS_BINDING_LEVEL appropriately. */
1331 if (scope->kind == sk_class)
1333 class_binding_level = NULL;
1334 for (scope = current_binding_level; scope; scope = scope->level_chain)
1335 if (scope->kind == sk_class)
1337 class_binding_level = scope;
1342 return current_binding_level;
1346 resume_scope (struct cp_binding_level* b)
1348 /* Resuming binding levels is meant only for namespaces,
1349 and those cannot nest into classes. */
1350 gcc_assert (!class_binding_level);
1351 /* Also, resuming a non-directly nested namespace is a no-no. */
1352 gcc_assert (b->level_chain == current_binding_level);
1353 current_binding_level = b;
1354 if (ENABLE_SCOPE_CHECKING)
1356 b->binding_depth = binding_depth;
1357 indent (binding_depth);
1358 cxx_scope_debug (b, input_line, "resume");
1364 /* Return the innermost binding level that is not for a class scope. */
1367 innermost_nonclass_level (void)
1371 b = current_binding_level;
1372 while (b->kind == sk_class)
1378 /* We're defining an object of type TYPE. If it needs a cleanup, but
1379 we're not allowed to add any more objects with cleanups to the current
1380 scope, create a new binding level. */
1383 maybe_push_cleanup_level (tree type)
1385 if (type != error_mark_node
1386 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1387 && current_binding_level->more_cleanups_ok == 0)
1389 begin_scope (sk_cleanup, NULL);
1390 current_binding_level->statement_list = push_stmt_list ();
1394 /* Nonzero if we are currently in the global binding level. */
1397 global_bindings_p (void)
1399 return global_scope_p (current_binding_level);
1402 /* True if we are currently in a toplevel binding level. This
1403 means either the global binding level or a namespace in a toplevel
1404 binding level. Since there are no non-toplevel namespace levels,
1405 this really means any namespace or template parameter level. We
1406 also include a class whose context is toplevel. */
1409 toplevel_bindings_p (void)
1411 struct cp_binding_level *b = innermost_nonclass_level ();
1413 return b->kind == sk_namespace || b->kind == sk_template_parms;
1416 /* True if this is a namespace scope, or if we are defining a class
1417 which is itself at namespace scope, or whose enclosing class is
1418 such a class, etc. */
1421 namespace_bindings_p (void)
1423 struct cp_binding_level *b = innermost_nonclass_level ();
1425 return b->kind == sk_namespace;
1428 /* True if the current level needs to have a BLOCK made. */
1433 return (current_binding_level->blocks != NULL_TREE
1434 || current_binding_level->keep
1435 || current_binding_level->kind == sk_cleanup
1436 || current_binding_level->names != NULL_TREE);
1439 /* Returns the kind of the innermost scope. */
1442 innermost_scope_kind (void)
1444 return current_binding_level->kind;
1447 /* Returns true if this scope was created to store template parameters. */
1450 template_parm_scope_p (void)
1452 return innermost_scope_kind () == sk_template_parms;
1455 /* If KEEP is true, make a BLOCK node for the next binding level,
1456 unconditionally. Otherwise, use the normal logic to decide whether
1457 or not to create a BLOCK. */
1460 keep_next_level (bool keep)
1462 keep_next_level_flag = keep;
1465 /* Return the list of declarations of the current level.
1466 Note that this list is in reverse order unless/until
1467 you nreverse it; and when you do nreverse it, you must
1468 store the result back using `storedecls' or you will lose. */
1473 return current_binding_level->names;
1476 /* For debugging. */
1477 static int no_print_functions = 0;
1478 static int no_print_builtins = 0;
1481 print_binding_level (struct cp_binding_level* lvl)
1485 fprintf (stderr, " blocks=" HOST_PTR_PRINTF, (void *) lvl->blocks);
1486 if (lvl->more_cleanups_ok)
1487 fprintf (stderr, " more-cleanups-ok");
1488 if (lvl->have_cleanups)
1489 fprintf (stderr, " have-cleanups");
1490 fprintf (stderr, "\n");
1493 fprintf (stderr, " names:\t");
1494 /* We can probably fit 3 names to a line? */
1495 for (t = lvl->names; t; t = TREE_CHAIN (t))
1497 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1499 if (no_print_builtins
1500 && (TREE_CODE (t) == TYPE_DECL)
1501 && DECL_IS_BUILTIN (t))
1504 /* Function decls tend to have longer names. */
1505 if (TREE_CODE (t) == FUNCTION_DECL)
1512 fprintf (stderr, "\n\t");
1515 print_node_brief (stderr, "", t, 0);
1516 if (t == error_mark_node)
1520 fprintf (stderr, "\n");
1522 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1525 cp_class_binding *b;
1526 fprintf (stderr, " class-shadowed:");
1528 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1530 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1531 fprintf (stderr, "\n");
1533 if (lvl->type_shadowed)
1535 fprintf (stderr, " type-shadowed:");
1536 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1538 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1540 fprintf (stderr, "\n");
1545 print_other_binding_stack (struct cp_binding_level *stack)
1547 struct cp_binding_level *level;
1548 for (level = stack; !global_scope_p (level); level = level->level_chain)
1550 fprintf (stderr, "binding level " HOST_PTR_PRINTF "\n", (void *) level);
1551 print_binding_level (level);
1556 print_binding_stack (void)
1558 struct cp_binding_level *b;
1559 fprintf (stderr, "current_binding_level=" HOST_PTR_PRINTF
1560 "\nclass_binding_level=" HOST_PTR_PRINTF
1561 "\nNAMESPACE_LEVEL (global_namespace)=" HOST_PTR_PRINTF "\n",
1562 (void *) current_binding_level, (void *) class_binding_level,
1563 (void *) NAMESPACE_LEVEL (global_namespace));
1564 if (class_binding_level)
1566 for (b = class_binding_level; b; b = b->level_chain)
1567 if (b == current_binding_level)
1570 b = class_binding_level;
1572 b = current_binding_level;
1575 b = current_binding_level;
1576 print_other_binding_stack (b);
1577 fprintf (stderr, "global:\n");
1578 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1581 /* Return the type associated with id. */
1584 identifier_type_value (tree id)
1586 timevar_push (TV_NAME_LOOKUP);
1587 /* There is no type with that name, anywhere. */
1588 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1590 /* This is not the type marker, but the real thing. */
1591 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1593 /* Have to search for it. It must be on the global level, now.
1594 Ask lookup_name not to return non-types. */
1595 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1597 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1598 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1601 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1602 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1605 identifier_global_value (tree t)
1607 return IDENTIFIER_GLOBAL_VALUE (t);
1610 /* Push a definition of struct, union or enum tag named ID. into
1611 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1612 the tag ID is not already defined. */
1615 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1619 if (b->kind != sk_namespace)
1621 /* Shadow the marker, not the real thing, so that the marker
1622 gets restored later. */
1623 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1625 = tree_cons (id, old_type_value, b->type_shadowed);
1626 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1627 TREE_TYPE (b->type_shadowed) = type;
1631 cxx_binding *binding =
1632 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1635 supplement_binding (binding, decl);
1637 binding->value = decl;
1639 /* Store marker instead of real type. */
1640 type = global_type_node;
1642 SET_IDENTIFIER_TYPE_VALUE (id, type);
1645 /* As set_identifier_type_value_with_scope, but using
1646 current_binding_level. */
1649 set_identifier_type_value (tree id, tree decl)
1651 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1654 /* Return the name for the constructor (or destructor) for the
1655 specified class TYPE. When given a template, this routine doesn't
1656 lose the specialization. */
1659 constructor_name_full (tree type)
1661 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1664 /* Return the name for the constructor (or destructor) for the
1665 specified class. When given a template, return the plain
1666 unspecialized name. */
1669 constructor_name (tree type)
1672 name = constructor_name_full (type);
1673 if (IDENTIFIER_TEMPLATE (name))
1674 name = IDENTIFIER_TEMPLATE (name);
1678 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1681 constructor_name_p (tree name, tree type)
1688 if (TREE_CODE (name) != IDENTIFIER_NODE)
1691 ctor_name = constructor_name_full (type);
1692 if (name == ctor_name)
1694 if (IDENTIFIER_TEMPLATE (ctor_name)
1695 && name == IDENTIFIER_TEMPLATE (ctor_name))
1700 /* Counter used to create anonymous type names. */
1702 static GTY(()) int anon_cnt;
1704 /* Return an IDENTIFIER which can be used as a name for
1705 anonymous structs and unions. */
1708 make_anon_name (void)
1712 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1713 return get_identifier (buf);
1716 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1718 static inline cxx_binding *
1719 find_binding (cxx_scope *scope, cxx_binding *binding)
1721 timevar_push (TV_NAME_LOOKUP);
1723 for (; binding != NULL; binding = binding->previous)
1724 if (binding->scope == scope)
1725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1727 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1730 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1732 static inline cxx_binding *
1733 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1735 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1738 /* Fold-in case where NAME is used only once. */
1739 if (scope == b->scope && b->previous == NULL)
1741 return find_binding (scope, b);
1746 /* Always returns a binding for name in scope. If no binding is
1747 found, make a new one. */
1749 static cxx_binding *
1750 binding_for_name (cxx_scope *scope, tree name)
1752 cxx_binding *result;
1754 result = cxx_scope_find_binding_for_name (scope, name);
1757 /* Not found, make a new one. */
1758 result = cxx_binding_make (NULL, NULL);
1759 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1760 result->scope = scope;
1761 result->is_local = false;
1762 result->value_is_inherited = false;
1763 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1767 /* Insert another USING_DECL into the current binding level, returning
1768 this declaration. If this is a redeclaration, do nothing, and
1769 return NULL_TREE if this not in namespace scope (in namespace
1770 scope, a using decl might extend any previous bindings). */
1773 push_using_decl (tree scope, tree name)
1777 timevar_push (TV_NAME_LOOKUP);
1778 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1779 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1780 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1781 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1784 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1785 namespace_bindings_p () ? decl : NULL_TREE);
1786 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1787 USING_DECL_SCOPE (decl) = scope;
1788 TREE_CHAIN (decl) = current_binding_level->usings;
1789 current_binding_level->usings = decl;
1790 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1793 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1794 caller to set DECL_CONTEXT properly. */
1797 pushdecl_with_scope (tree x, cxx_scope *level)
1799 struct cp_binding_level *b;
1800 tree function_decl = current_function_decl;
1802 timevar_push (TV_NAME_LOOKUP);
1803 current_function_decl = NULL_TREE;
1804 if (level->kind == sk_class)
1806 b = class_binding_level;
1807 class_binding_level = level;
1808 pushdecl_class_level (x);
1809 class_binding_level = b;
1813 b = current_binding_level;
1814 current_binding_level = level;
1816 current_binding_level = b;
1818 current_function_decl = function_decl;
1819 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1822 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1823 other definitions already in place. We get around this by making
1824 the value of the identifier point to a list of all the things that
1825 want to be referenced by that name. It is then up to the users of
1826 that name to decide what to do with that list.
1828 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1829 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1831 FLAGS is a bitwise-or of the following values:
1832 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1834 PUSH_USING: DECL is being pushed as the result of a using
1837 The value returned may be a previous declaration if we guessed wrong
1838 about what language DECL should belong to (C or C++). Otherwise,
1839 it's always DECL (and never something that's not a _DECL). */
1842 push_overloaded_decl (tree decl, int flags)
1844 tree name = DECL_NAME (decl);
1847 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1849 timevar_push (TV_NAME_LOOKUP);
1851 old = namespace_binding (name, DECL_CONTEXT (decl));
1853 old = lookup_name_innermost_nonclass_level (name);
1857 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1859 tree t = TREE_TYPE (old);
1860 if (IS_AGGR_TYPE (t) && warn_shadow
1861 && (! DECL_IN_SYSTEM_HEADER (decl)
1862 || ! DECL_IN_SYSTEM_HEADER (old)))
1863 warning (0, "%q#D hides constructor for %q#T", decl, t);
1866 else if (is_overloaded_fn (old))
1870 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1872 tree fn = OVL_CURRENT (tmp);
1874 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1875 && !(flags & PUSH_USING)
1876 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1877 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1878 && ! decls_match (fn, decl))
1879 error ("%q#D conflicts with previous using declaration %q#D",
1882 if (duplicate_decls (decl, fn) == fn)
1883 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn);
1886 /* We don't overload implicit built-ins. duplicate_decls()
1887 may fail to merge the decls if the new decl is e.g. a
1888 template function. */
1889 if (TREE_CODE (old) == FUNCTION_DECL
1890 && DECL_ANTICIPATED (old))
1893 else if (old == error_mark_node)
1894 /* Ignore the undefined symbol marker. */
1898 cp_error_at ("previous non-function declaration %q#D", old);
1899 error ("conflicts with function declaration %q#D", decl);
1900 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1904 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1905 /* If it's a using declaration, we always need to build an OVERLOAD,
1906 because it's the only way to remember that the declaration comes
1907 from 'using', and have the lookup behave correctly. */
1908 || (flags & PUSH_USING))
1910 if (old && TREE_CODE (old) != OVERLOAD)
1911 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1913 new_binding = ovl_cons (decl, old);
1914 if (flags & PUSH_USING)
1915 OVL_USED (new_binding) = 1;
1918 /* NAME is not ambiguous. */
1922 set_namespace_binding (name, current_namespace, new_binding);
1925 /* We only create an OVERLOAD if there was a previous binding at
1926 this level, or if decl is a template. In the former case, we
1927 need to remove the old binding and replace it with the new
1928 binding. We must also run through the NAMES on the binding
1929 level where the name was bound to update the chain. */
1931 if (TREE_CODE (new_binding) == OVERLOAD && old)
1935 for (d = &IDENTIFIER_BINDING (name)->scope->names;
1937 d = &TREE_CHAIN (*d))
1939 || (TREE_CODE (*d) == TREE_LIST
1940 && TREE_VALUE (*d) == old))
1942 if (TREE_CODE (*d) == TREE_LIST)
1943 /* Just replace the old binding with the new. */
1944 TREE_VALUE (*d) = new_binding;
1946 /* Build a TREE_LIST to wrap the OVERLOAD. */
1947 *d = tree_cons (NULL_TREE, new_binding,
1950 /* And update the cxx_binding node. */
1951 IDENTIFIER_BINDING (name)->value = new_binding;
1952 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1955 /* We should always find a previous binding in this case. */
1959 /* Install the new binding. */
1960 push_local_binding (name, new_binding, flags);
1963 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1966 /* Check a non-member using-declaration. Return the name and scope
1967 being used, and the USING_DECL, or NULL_TREE on failure. */
1970 validate_nonmember_using_decl (tree decl, tree scope, tree name)
1972 /* [namespace.udecl]
1973 A using-declaration for a class member shall be a
1974 member-declaration. */
1977 error ("%qT is not a namespace", scope);
1980 else if (scope == error_mark_node)
1983 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
1986 A using-declaration shall not name a template-id. */
1987 error ("a using-declaration cannot specify a template-id. "
1988 "Try %<using %D%>", name);
1992 if (TREE_CODE (decl) == NAMESPACE_DECL)
1994 error ("namespace %qD not allowed in using-declaration", decl);
1998 if (TREE_CODE (decl) == SCOPE_REF)
2000 /* It's a nested name with template parameter dependent scope.
2001 This can only be using-declaration for class member. */
2002 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2006 if (is_overloaded_fn (decl))
2007 decl = get_first_fn (decl);
2009 gcc_assert (DECL_P (decl));
2011 /* Make a USING_DECL. */
2012 return push_using_decl (scope, name);
2015 /* Process local and global using-declarations. */
2018 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2019 tree *newval, tree *newtype)
2021 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2023 *newval = *newtype = NULL_TREE;
2024 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2028 if (!decls.value && !decls.type)
2030 error ("%qD not declared", name);
2034 /* It is impossible to overload a built-in function; any explicit
2035 declaration eliminates the built-in declaration. So, if OLDVAL
2036 is a built-in, then we can just pretend it isn't there. */
2038 && TREE_CODE (oldval) == FUNCTION_DECL
2039 && DECL_ANTICIPATED (oldval))
2042 /* Check for using functions. */
2043 if (decls.value && is_overloaded_fn (decls.value))
2047 if (oldval && !is_overloaded_fn (oldval))
2049 if (!DECL_IMPLICIT_TYPEDEF_P (oldval))
2050 error ("%qD is already declared in this scope", name);
2055 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2057 tree new_fn = OVL_CURRENT (tmp);
2059 /* [namespace.udecl]
2061 If a function declaration in namespace scope or block
2062 scope has the same name and the same parameter types as a
2063 function introduced by a using declaration the program is
2065 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2067 tree old_fn = OVL_CURRENT (tmp1);
2069 if (new_fn == old_fn)
2070 /* The function already exists in the current namespace. */
2072 else if (OVL_USED (tmp1))
2073 continue; /* this is a using decl */
2074 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2075 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2077 gcc_assert (!DECL_ANTICIPATED (old_fn));
2079 /* There was already a non-using declaration in
2080 this scope with the same parameter types. If both
2081 are the same extern "C" functions, that's ok. */
2082 if (decls_match (new_fn, old_fn))
2086 error ("%qD is already declared in this scope", name);
2092 /* If we broke out of the loop, there's no reason to add
2093 this function to the using declarations for this
2098 /* If we are adding to an existing OVERLOAD, then we no
2099 longer know the type of the set of functions. */
2100 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2101 TREE_TYPE (*newval) = unknown_type_node;
2102 /* Add this new function to the set. */
2103 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2104 /* If there is only one function, then we use its type. (A
2105 using-declaration naming a single function can be used in
2106 contexts where overload resolution cannot be
2108 if (TREE_CODE (*newval) != OVERLOAD)
2110 *newval = ovl_cons (*newval, NULL_TREE);
2111 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2113 OVL_USED (*newval) = 1;
2118 *newval = decls.value;
2119 if (oldval && !decls_match (*newval, oldval))
2120 error ("%qD is already declared in this scope", name);
2123 *newtype = decls.type;
2124 if (oldtype && *newtype && !same_type_p (oldtype, *newtype))
2126 error ("using declaration %qD introduced ambiguous type %qT",
2132 /* Process a using-declaration at function scope. */
2135 do_local_using_decl (tree decl, tree scope, tree name)
2137 tree oldval, oldtype, newval, newtype;
2138 tree orig_decl = decl;
2140 decl = validate_nonmember_using_decl (decl, scope, name);
2141 if (decl == NULL_TREE)
2144 if (building_stmt_tree ()
2145 && at_function_scope_p ())
2146 add_decl_expr (decl);
2148 oldval = lookup_name_innermost_nonclass_level (name);
2149 oldtype = lookup_type_current_level (name);
2151 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2155 if (is_overloaded_fn (newval))
2159 /* We only need to push declarations for those functions
2160 that were not already bound in the current level.
2161 The old value might be NULL_TREE, it might be a single
2162 function, or an OVERLOAD. */
2163 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2164 term = OVL_FUNCTION (oldval);
2167 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2169 push_overloaded_decl (OVL_CURRENT (fn),
2170 PUSH_LOCAL | PUSH_USING);
2173 push_local_binding (name, newval, PUSH_USING);
2177 push_local_binding (name, newtype, PUSH_USING);
2178 set_identifier_type_value (name, newtype);
2181 /* Emit debug info. */
2182 if (!processing_template_decl)
2183 cp_emit_debug_info_for_using (orig_decl, current_scope());
2186 /* Returns true if ROOT (a namespace, class, or function) encloses
2187 CHILD. CHILD may be either a class type or a namespace. */
2190 is_ancestor (tree root, tree child)
2192 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2193 || TREE_CODE (root) == FUNCTION_DECL
2194 || CLASS_TYPE_P (root)));
2195 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2196 || CLASS_TYPE_P (child)));
2198 /* The global namespace encloses everything. */
2199 if (root == global_namespace)
2204 /* If we've run out of scopes, stop. */
2207 /* If we've reached the ROOT, it encloses CHILD. */
2210 /* Go out one level. */
2212 child = TYPE_NAME (child);
2213 child = DECL_CONTEXT (child);
2217 /* Enter the class or namespace scope indicated by T suitable for name
2218 lookup. T can be arbitrary scope, not necessary nested inside the
2219 current scope. Returns a non-null scope to pop iff pop_scope
2220 should be called later to exit this scope. */
2225 if (TREE_CODE (t) == NAMESPACE_DECL)
2226 push_decl_namespace (t);
2227 else if (CLASS_TYPE_P (t))
2229 if (!at_class_scope_p ()
2230 || !same_type_p (current_class_type, t))
2231 push_nested_class (t);
2233 /* T is the same as the current scope. There is therefore no
2234 need to re-enter the scope. Since we are not actually
2235 pushing a new scope, our caller should not call
2243 /* Leave scope pushed by push_scope. */
2248 if (TREE_CODE (t) == NAMESPACE_DECL)
2249 pop_decl_namespace ();
2250 else if CLASS_TYPE_P (t)
2251 pop_nested_class ();
2254 /* Subroutine of push_inner_scope. */
2257 push_inner_scope_r (tree outer, tree inner)
2262 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2265 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2267 push_inner_scope_r (outer, prev);
2268 if (TREE_CODE (inner) == NAMESPACE_DECL)
2270 struct cp_binding_level *save_template_parm = 0;
2271 /* Temporary take out template parameter scopes. They are saved
2272 in reversed order in save_template_parm. */
2273 while (current_binding_level->kind == sk_template_parms)
2275 struct cp_binding_level *b = current_binding_level;
2276 current_binding_level = b->level_chain;
2277 b->level_chain = save_template_parm;
2278 save_template_parm = b;
2281 resume_scope (NAMESPACE_LEVEL (inner));
2282 current_namespace = inner;
2284 /* Restore template parameter scopes. */
2285 while (save_template_parm)
2287 struct cp_binding_level *b = save_template_parm;
2288 save_template_parm = b->level_chain;
2289 b->level_chain = current_binding_level;
2290 current_binding_level = b;
2297 /* Enter the scope INNER from current scope. INNER must be a scope
2298 nested inside current scope. This works with both name lookup and
2299 pushing name into scope. In case a template parameter scope is present,
2300 namespace is pushed under the template parameter scope according to
2301 name lookup rule in 14.6.1/6.
2303 Return the former current scope suitable for pop_inner_scope. */
2306 push_inner_scope (tree inner)
2308 tree outer = current_scope ();
2310 outer = current_namespace;
2312 push_inner_scope_r (outer, inner);
2316 /* Exit the current scope INNER back to scope OUTER. */
2319 pop_inner_scope (tree outer, tree inner)
2322 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2325 while (outer != inner)
2327 if (TREE_CODE (inner) == NAMESPACE_DECL)
2329 struct cp_binding_level *save_template_parm = 0;
2330 /* Temporary take out template parameter scopes. They are saved
2331 in reversed order in save_template_parm. */
2332 while (current_binding_level->kind == sk_template_parms)
2334 struct cp_binding_level *b = current_binding_level;
2335 current_binding_level = b->level_chain;
2336 b->level_chain = save_template_parm;
2337 save_template_parm = b;
2342 /* Restore template parameter scopes. */
2343 while (save_template_parm)
2345 struct cp_binding_level *b = save_template_parm;
2346 save_template_parm = b->level_chain;
2347 b->level_chain = current_binding_level;
2348 current_binding_level = b;
2354 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2358 /* Do a pushlevel for class declarations. */
2361 pushlevel_class (void)
2363 if (ENABLE_SCOPE_CHECKING)
2366 class_binding_level = begin_scope (sk_class, current_class_type);
2369 /* ...and a poplevel for class declarations. */
2372 poplevel_class (void)
2374 struct cp_binding_level *level = class_binding_level;
2375 cp_class_binding *cb;
2379 timevar_push (TV_NAME_LOOKUP);
2380 gcc_assert (level != 0);
2382 /* If we're leaving a toplevel class, cache its binding level. */
2383 if (current_class_depth == 1)
2384 previous_class_level = level;
2385 for (shadowed = level->type_shadowed;
2387 shadowed = TREE_CHAIN (shadowed))
2388 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2390 /* Remove the bindings for all of the class-level declarations. */
2391 if (level->class_shadowed)
2394 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2396 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2397 ggc_free (level->class_shadowed);
2398 level->class_shadowed = NULL;
2401 /* Now, pop out of the binding level which we created up in the
2402 `pushlevel_class' routine. */
2403 if (ENABLE_SCOPE_CHECKING)
2407 timevar_pop (TV_NAME_LOOKUP);
2410 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2411 appropriate. DECL is the value to which a name has just been
2412 bound. CLASS_TYPE is the class in which the lookup occurred. */
2415 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2418 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2422 if (TREE_CODE (decl) == OVERLOAD)
2423 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2426 gcc_assert (DECL_P (decl));
2427 context = context_for_name_lookup (decl);
2430 if (is_properly_derived_from (class_type, context))
2431 INHERITED_VALUE_BINDING_P (binding) = 1;
2433 INHERITED_VALUE_BINDING_P (binding) = 0;
2435 else if (binding->value == decl)
2436 /* We only encounter a TREE_LIST when there is an ambiguity in the
2437 base classes. Such an ambiguity can be overridden by a
2438 definition in this class. */
2439 INHERITED_VALUE_BINDING_P (binding) = 1;
2441 INHERITED_VALUE_BINDING_P (binding) = 0;
2444 /* Make the declaration of X appear in CLASS scope. */
2447 pushdecl_class_level (tree x)
2450 bool is_valid = true;
2452 timevar_push (TV_NAME_LOOKUP);
2453 /* Get the name of X. */
2454 if (TREE_CODE (x) == OVERLOAD)
2455 name = DECL_NAME (get_first_fn (x));
2457 name = DECL_NAME (x);
2461 is_valid = push_class_level_binding (name, x);
2462 if (TREE_CODE (x) == TYPE_DECL)
2463 set_identifier_type_value (name, x);
2465 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2467 /* If X is an anonymous aggregate, all of its members are
2468 treated as if they were members of the class containing the
2469 aggregate, for naming purposes. */
2472 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2474 location_t save_location = input_location;
2475 input_location = DECL_SOURCE_LOCATION (f);
2476 if (!pushdecl_class_level (f))
2478 input_location = save_location;
2481 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2484 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2485 scope. If the value returned is non-NULL, and the PREVIOUS field
2486 is not set, callers must set the PREVIOUS field explicitly. */
2488 static cxx_binding *
2489 get_class_binding (tree name, cxx_scope *scope)
2494 cxx_binding *binding;
2496 class_type = scope->this_entity;
2498 /* Get the type binding. */
2499 type_binding = lookup_member (class_type, name,
2500 /*protect=*/2, /*want_type=*/true);
2501 /* Get the value binding. */
2502 value_binding = lookup_member (class_type, name,
2503 /*protect=*/2, /*want_type=*/false);
2506 && (TREE_CODE (value_binding) == TYPE_DECL
2507 || DECL_CLASS_TEMPLATE_P (value_binding)
2508 || (TREE_CODE (value_binding) == TREE_LIST
2509 && TREE_TYPE (value_binding) == error_mark_node
2510 && (TREE_CODE (TREE_VALUE (value_binding))
2512 /* We found a type binding, even when looking for a non-type
2513 binding. This means that we already processed this binding
2516 else if (value_binding)
2518 if (TREE_CODE (value_binding) == TREE_LIST
2519 && TREE_TYPE (value_binding) == error_mark_node)
2520 /* NAME is ambiguous. */
2522 else if (BASELINK_P (value_binding))
2523 /* NAME is some overloaded functions. */
2524 value_binding = BASELINK_FUNCTIONS (value_binding);
2527 /* If we found either a type binding or a value binding, create a
2528 new binding object. */
2529 if (type_binding || value_binding)
2531 binding = new_class_binding (name,
2535 /* This is a class-scope binding, not a block-scope binding. */
2536 LOCAL_BINDING_P (binding) = 0;
2537 set_inherited_value_binding_p (binding, value_binding, class_type);
2545 /* Make the declaration(s) of X appear in CLASS scope under the name
2546 NAME. Returns true if the binding is valid. */
2549 push_class_level_binding (tree name, tree x)
2551 cxx_binding *binding;
2555 timevar_push (TV_NAME_LOOKUP);
2556 /* The class_binding_level will be NULL if x is a template
2557 parameter name in a member template. */
2558 if (!class_binding_level)
2559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2561 /* Check for invalid member names. */
2562 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2563 /* We could have been passed a tree list if this is an ambiguous
2564 declaration. If so, pull the declaration out because
2565 check_template_shadow will not handle a TREE_LIST. */
2566 if (TREE_CODE (decl) == TREE_LIST
2567 && TREE_TYPE (decl) == error_mark_node)
2568 decl = TREE_VALUE (decl);
2570 check_template_shadow (decl);
2574 If T is the name of a class, then each of the following shall
2575 have a name different from T:
2577 -- every static data member of class T;
2579 -- every member of class T that is itself a type;
2581 -- every enumerator of every member of class T that is an
2584 -- every member of every anonymous union that is a member of
2587 (Non-static data members were also forbidden to have the same
2588 name as T until TC1.) */
2589 if ((TREE_CODE (x) == VAR_DECL
2590 || TREE_CODE (x) == CONST_DECL
2591 || (TREE_CODE (x) == TYPE_DECL
2592 && !DECL_SELF_REFERENCE_P (x))
2593 /* A data member of an anonymous union. */
2594 || (TREE_CODE (x) == FIELD_DECL
2595 && DECL_CONTEXT (x) != current_class_type))
2596 && DECL_NAME (x) == constructor_name (current_class_type))
2598 tree scope = context_for_name_lookup (x);
2599 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2601 error ("%qD has the same name as the class in which it is "
2604 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2608 /* Get the current binding for NAME in this class, if any. */
2609 binding = IDENTIFIER_BINDING (name);
2610 if (!binding || binding->scope != class_binding_level)
2612 binding = get_class_binding (name, class_binding_level);
2613 /* If a new binding was created, put it at the front of the
2614 IDENTIFIER_BINDING list. */
2617 binding->previous = IDENTIFIER_BINDING (name);
2618 IDENTIFIER_BINDING (name) = binding;
2622 /* If there is already a binding, then we may need to update the
2624 if (binding && binding->value)
2626 tree bval = binding->value;
2627 tree old_decl = NULL_TREE;
2629 if (INHERITED_VALUE_BINDING_P (binding))
2631 /* If the old binding was from a base class, and was for a
2632 tag name, slide it over to make room for the new binding.
2633 The old binding is still visible if explicitly qualified
2634 with a class-key. */
2635 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2636 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2638 old_decl = binding->type;
2639 binding->type = bval;
2640 binding->value = NULL_TREE;
2641 INHERITED_VALUE_BINDING_P (binding) = 0;
2646 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2648 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2649 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2650 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2652 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2653 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2655 if (old_decl && binding->scope == class_binding_level)
2658 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2659 here. This function is only used to register bindings
2660 from with the class definition itself. */
2661 INHERITED_VALUE_BINDING_P (binding) = 0;
2662 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2666 /* Note that we declared this value so that we can issue an error if
2667 this is an invalid redeclaration of a name already used for some
2669 note_name_declared_in_class (name, decl);
2671 /* If we didn't replace an existing binding, put the binding on the
2672 stack of bindings for the identifier, and update the shadowed
2674 if (binding && binding->scope == class_binding_level)
2675 /* Supplement the existing binding. */
2676 ok = supplement_binding (binding, decl);
2679 /* Create a new binding. */
2680 push_binding (name, decl, class_binding_level);
2684 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2687 /* Process "using SCOPE::NAME" in a class scope. Return the
2688 USING_DECL created. */
2691 do_class_using_decl (tree scope, tree name)
2693 tree value, decl, binfo;
2697 if (!scope || !TYPE_P (scope))
2699 error ("using-declaration for non-member at class scope");
2703 /* Make sure the scope is a base. */
2704 dependent_p = dependent_type_p (scope);
2706 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2710 if (same_type_p (current_class_type, scope))
2711 b_kind = bk_same_type;
2713 b_kind = bk_proper_base;
2716 if (b_kind < bk_proper_base)
2718 error_not_base_type (scope, current_class_type);
2722 /* Make sure the name is not invalid */
2723 if (TREE_CODE (name) == BIT_NOT_EXPR)
2725 error ("%<%T::%D%> names destructor", scope, name);
2728 if (constructor_name_p (name, scope))
2730 error ("%<%T::%D%> names constructor", scope, name);
2733 if (constructor_name_p (name, current_class_type))
2735 error ("%<%T::%D%> names constructor in %qT",
2736 scope, name, current_class_type);
2741 && IDENTIFIER_OPNAME_P (name) && dependent_type_p (TREE_TYPE (name)))
2744 /* See if there are any members of the base. */
2747 decl = lookup_member (binfo, name, 0, false);
2751 error ("no members matching %<%T::%D%> in %q#T", scope, name, scope);
2755 if (BASELINK_P (decl))
2756 /* Ignore base type this came from. */
2757 decl = BASELINK_FUNCTIONS (decl);
2762 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2763 USING_DECL_DECLS (value) = decl;
2764 USING_DECL_SCOPE (value) = scope;
2765 DECL_DEPENDENT_P (value) = dependent_p;
2771 /* Return the binding value for name in scope. */
2774 namespace_binding (tree name, tree scope)
2776 cxx_binding *binding;
2779 scope = global_namespace;
2781 /* Unnecessary for the global namespace because it can't be an alias. */
2782 scope = ORIGINAL_NAMESPACE (scope);
2784 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2786 return binding ? binding->value : NULL_TREE;
2789 /* Set the binding value for name in scope. */
2792 set_namespace_binding (tree name, tree scope, tree val)
2796 timevar_push (TV_NAME_LOOKUP);
2797 if (scope == NULL_TREE)
2798 scope = global_namespace;
2799 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2800 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2803 supplement_binding (b, val);
2804 timevar_pop (TV_NAME_LOOKUP);
2807 /* Set the context of a declaration to scope. Complain if we are not
2811 set_decl_namespace (tree decl, tree scope, bool friendp)
2815 /* Get rid of namespace aliases. */
2816 scope = ORIGINAL_NAMESPACE (scope);
2818 /* It is ok for friends to be qualified in parallel space. */
2819 if (!friendp && !is_ancestor (current_namespace, scope))
2820 error ("declaration of %qD not in a namespace surrounding %qD",
2822 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2824 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2825 if (scope == current_namespace)
2827 if (at_namespace_scope_p ())
2828 error ("explicit qualification in declaration of `%D'",
2833 /* See whether this has been declared in the namespace. */
2834 old = namespace_binding (DECL_NAME (decl), scope);
2836 /* No old declaration at all. */
2838 /* A template can be explicitly specialized in any namespace. */
2839 if (processing_explicit_instantiation)
2841 if (!is_overloaded_fn (decl))
2842 /* Don't compare non-function decls with decls_match here, since
2843 it can't check for the correct constness at this
2844 point. pushdecl will find those errors later. */
2846 /* Since decl is a function, old should contain a function decl. */
2847 if (!is_overloaded_fn (old))
2849 if (processing_template_decl || processing_specialization)
2850 /* We have not yet called push_template_decl to turn a
2851 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
2852 match. But, we'll check later, when we construct the
2855 if (is_overloaded_fn (old))
2857 for (; old; old = OVL_NEXT (old))
2858 if (decls_match (decl, OVL_CURRENT (old)))
2861 else if (decls_match (decl, old))
2864 error ("%qD should have been declared inside %qD", decl, scope);
2867 /* Return the namespace where the current declaration is declared. */
2870 current_decl_namespace (void)
2873 /* If we have been pushed into a different namespace, use it. */
2874 if (decl_namespace_list)
2875 return TREE_PURPOSE (decl_namespace_list);
2877 if (current_class_type)
2878 result = decl_namespace_context (current_class_type);
2879 else if (current_function_decl)
2880 result = decl_namespace_context (current_function_decl);
2882 result = current_namespace;
2886 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
2887 select a name that is unique to this compilation unit. */
2890 push_namespace (tree name)
2894 int implicit_use = 0;
2897 timevar_push (TV_NAME_LOOKUP);
2899 /* We should not get here if the global_namespace is not yet constructed
2900 nor if NAME designates the global namespace: The global scope is
2901 constructed elsewhere. */
2902 gcc_assert (global_namespace != NULL && name != global_scope_name);
2906 /* The name of anonymous namespace is unique for the translation
2908 if (!anonymous_namespace_name)
2909 anonymous_namespace_name = get_file_function_name ('N');
2910 name = anonymous_namespace_name;
2911 d = IDENTIFIER_NAMESPACE_VALUE (name);
2913 /* Reopening anonymous namespace. */
2919 /* Check whether this is an extended namespace definition. */
2920 d = IDENTIFIER_NAMESPACE_VALUE (name);
2921 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
2924 if (DECL_NAMESPACE_ALIAS (d))
2926 error ("namespace alias %qD not allowed here, assuming %qD",
2927 d, DECL_NAMESPACE_ALIAS (d));
2928 d = DECL_NAMESPACE_ALIAS (d);
2935 /* Make a new namespace, binding the name to it. */
2936 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
2937 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
2941 /* Clear DECL_NAME for the benefit of debugging back ends. */
2942 SET_DECL_ASSEMBLER_NAME (d, name);
2943 DECL_NAME (d) = NULL_TREE;
2945 begin_scope (sk_namespace, d);
2948 resume_scope (NAMESPACE_LEVEL (d));
2951 do_using_directive (d);
2952 /* Enter the name space. */
2953 current_namespace = d;
2955 timevar_pop (TV_NAME_LOOKUP);
2958 /* Pop from the scope of the current namespace. */
2961 pop_namespace (void)
2963 gcc_assert (current_namespace != global_namespace);
2964 current_namespace = CP_DECL_CONTEXT (current_namespace);
2965 /* The binding level is not popped, as it might be re-opened later. */
2969 /* Push into the scope of the namespace NS, even if it is deeply
2970 nested within another namespace. */
2973 push_nested_namespace (tree ns)
2975 if (ns == global_namespace)
2976 push_to_top_level ();
2979 push_nested_namespace (CP_DECL_CONTEXT (ns));
2980 push_namespace (DECL_NAME (ns));
2984 /* Pop back from the scope of the namespace NS, which was previously
2985 entered with push_nested_namespace. */
2988 pop_nested_namespace (tree ns)
2990 timevar_push (TV_NAME_LOOKUP);
2991 while (ns != global_namespace)
2994 ns = CP_DECL_CONTEXT (ns);
2997 pop_from_top_level ();
2998 timevar_pop (TV_NAME_LOOKUP);
3001 /* Temporarily set the namespace for the current declaration. */
3004 push_decl_namespace (tree decl)
3006 if (TREE_CODE (decl) != NAMESPACE_DECL)
3007 decl = decl_namespace_context (decl);
3008 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3009 NULL_TREE, decl_namespace_list);
3012 /* [namespace.memdef]/2 */
3015 pop_decl_namespace (void)
3017 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3020 /* Return the namespace that is the common ancestor
3021 of two given namespaces. */
3024 namespace_ancestor (tree ns1, tree ns2)
3026 timevar_push (TV_NAME_LOOKUP);
3027 if (is_ancestor (ns1, ns2))
3028 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3029 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3030 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3033 /* Process a namespace-alias declaration. */
3036 do_namespace_alias (tree alias, tree namespace)
3038 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3040 /* The parser did not find it, so it's not there. */
3041 error ("unknown namespace %qD", namespace);
3045 namespace = ORIGINAL_NAMESPACE (namespace);
3047 /* Build the alias. */
3048 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3049 DECL_NAMESPACE_ALIAS (alias) = namespace;
3050 DECL_EXTERNAL (alias) = 1;
3051 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3054 /* Emit debug info for namespace alias. */
3055 (*debug_hooks->global_decl) (alias);
3058 /* Like pushdecl, only it places X in the current namespace,
3062 pushdecl_namespace_level (tree x)
3064 struct cp_binding_level *b = current_binding_level;
3067 timevar_push (TV_NAME_LOOKUP);
3068 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));
3070 /* Now, the type_shadowed stack may screw us. Munge it so it does
3072 if (TREE_CODE (t) == TYPE_DECL)
3074 tree name = DECL_NAME (t);
3076 tree *ptr = (tree *)0;
3077 for (; !global_scope_p (b); b = b->level_chain)
3079 tree shadowed = b->type_shadowed;
3080 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3081 if (TREE_PURPOSE (shadowed) == name)
3083 ptr = &TREE_VALUE (shadowed);
3084 /* Can't break out of the loop here because sometimes
3085 a binding level will have duplicate bindings for
3086 PT names. It's gross, but I haven't time to fix it. */
3089 newval = TREE_TYPE (t);
3090 if (ptr == (tree *)0)
3092 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3093 up here if this is changed to an assertion. --KR */
3094 SET_IDENTIFIER_TYPE_VALUE (name, t);
3101 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3104 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3105 directive is not directly from the source. Also find the common
3106 ancestor and let our users know about the new namespace */
3108 add_using_namespace (tree user, tree used, bool indirect)
3111 timevar_push (TV_NAME_LOOKUP);
3112 /* Using oneself is a no-op. */
3115 timevar_pop (TV_NAME_LOOKUP);
3118 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3119 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3120 /* Check if we already have this. */
3121 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3125 /* Promote to direct usage. */
3126 TREE_INDIRECT_USING (t) = 0;
3127 timevar_pop (TV_NAME_LOOKUP);
3131 /* Add used to the user's using list. */
3132 DECL_NAMESPACE_USING (user)
3133 = tree_cons (used, namespace_ancestor (user, used),
3134 DECL_NAMESPACE_USING (user));
3136 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3138 /* Add user to the used's users list. */
3139 DECL_NAMESPACE_USERS (used)
3140 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3142 /* Recursively add all namespaces used. */
3143 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3144 /* indirect usage */
3145 add_using_namespace (user, TREE_PURPOSE (t), 1);
3147 /* Tell everyone using us about the new used namespaces. */
3148 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3149 add_using_namespace (TREE_PURPOSE (t), used, 1);
3150 timevar_pop (TV_NAME_LOOKUP);
3153 /* Process a using-declaration not appearing in class or local scope. */
3156 do_toplevel_using_decl (tree decl, tree scope, tree name)
3158 tree oldval, oldtype, newval, newtype;
3159 tree orig_decl = decl;
3160 cxx_binding *binding;
3162 decl = validate_nonmember_using_decl (decl, scope, name);
3163 if (decl == NULL_TREE)
3166 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3168 oldval = binding->value;
3169 oldtype = binding->type;
3171 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3173 /* Emit debug info. */
3174 if (!processing_template_decl)
3175 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3177 /* Copy declarations found. */
3179 binding->value = newval;
3181 binding->type = newtype;
3185 /* Process a using-directive. */
3188 do_using_directive (tree namespace)
3190 tree context = NULL_TREE;
3192 if (building_stmt_tree ())
3193 add_stmt (build_stmt (USING_STMT, namespace));
3195 /* using namespace A::B::C; */
3196 if (TREE_CODE (namespace) == SCOPE_REF)
3197 namespace = TREE_OPERAND (namespace, 1);
3198 if (TREE_CODE (namespace) == IDENTIFIER_NODE)
3200 /* Lookup in lexer did not find a namespace. */
3201 if (!processing_template_decl)
3202 error ("namespace %qT undeclared", namespace);
3205 if (TREE_CODE (namespace) != NAMESPACE_DECL)
3207 if (!processing_template_decl)
3208 error ("%qT is not a namespace", namespace);
3211 namespace = ORIGINAL_NAMESPACE (namespace);
3212 if (!toplevel_bindings_p ())
3214 push_using_directive (namespace);
3215 context = current_scope ();
3220 add_using_namespace (current_namespace, namespace, 0);
3221 if (current_namespace != global_namespace)
3222 context = current_namespace;
3225 /* Emit debugging info. */
3226 if (!processing_template_decl)
3227 (*debug_hooks->imported_module_or_decl) (namespace, context);
3230 /* Deal with a using-directive seen by the parser. Currently we only
3231 handle attributes here, since they cannot appear inside a template. */
3234 parse_using_directive (tree namespace, tree attribs)
3238 do_using_directive (namespace);
3240 for (a = attribs; a; a = TREE_CHAIN (a))
3242 tree name = TREE_PURPOSE (a);
3243 if (is_attribute_p ("strong", name))
3245 if (!toplevel_bindings_p ())
3246 error ("strong using only meaningful at namespace scope");
3247 else if (namespace != error_mark_node)
3248 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3249 = tree_cons (current_namespace, 0,
3250 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3253 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3257 /* Like pushdecl, only it places X in the global scope if appropriate.
3258 Calls cp_finish_decl to register the variable, initializing it with
3259 *INIT, if INIT is non-NULL. */
3262 pushdecl_top_level_1 (tree x, tree *init)
3264 timevar_push (TV_NAME_LOOKUP);
3265 push_to_top_level ();
3266 x = pushdecl_namespace_level (x);
3268 cp_finish_decl (x, *init, NULL_TREE, 0);
3269 pop_from_top_level ();
3270 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3273 /* Like pushdecl, only it places X in the global scope if appropriate. */
3276 pushdecl_top_level (tree x)
3278 return pushdecl_top_level_1 (x, NULL);
3281 /* Like pushdecl, only it places X in the global scope if
3282 appropriate. Calls cp_finish_decl to register the variable,
3283 initializing it with INIT. */
3286 pushdecl_top_level_and_finish (tree x, tree init)
3288 return pushdecl_top_level_1 (x, &init);
3291 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3292 duplicates. The first list becomes the tail of the result.
3294 The algorithm is O(n^2). We could get this down to O(n log n) by
3295 doing a sort on the addresses of the functions, if that becomes
3299 merge_functions (tree s1, tree s2)
3301 for (; s2; s2 = OVL_NEXT (s2))
3303 tree fn2 = OVL_CURRENT (s2);
3306 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3308 tree fn1 = OVL_CURRENT (fns1);
3310 /* If the function from S2 is already in S1, there is no
3311 need to add it again. For `extern "C"' functions, we
3312 might have two FUNCTION_DECLs for the same function, in
3313 different namespaces; again, we only need one of them. */
3315 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3316 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3320 /* If we exhausted all of the functions in S1, FN2 is new. */
3322 s1 = build_overload (fn2, s1);
3327 /* This should return an error not all definitions define functions.
3328 It is not an error if we find two functions with exactly the
3329 same signature, only if these are selected in overload resolution.
3330 old is the current set of bindings, new the freshly-found binding.
3331 XXX Do we want to give *all* candidates in case of ambiguity?
3332 XXX In what way should I treat extern declarations?
3333 XXX I don't want to repeat the entire duplicate_decls here */
3336 ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new,
3340 gcc_assert (old != NULL);
3341 /* Copy the value. */
3344 switch (TREE_CODE (val))
3347 /* If we expect types or namespaces, and not templates,
3348 or this is not a template class. */
3349 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3350 && !DECL_CLASS_TEMPLATE_P (val))
3351 || hidden_name_p (val))
3355 if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val))
3358 case NAMESPACE_DECL:
3359 if (LOOKUP_TYPES_ONLY (flags))
3363 /* Ignore built-in functions that are still anticipated. */
3364 if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val))
3368 if (LOOKUP_QUALIFIERS_ONLY (flags))
3374 else if (val && val != old->value)
3376 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3377 old->value = merge_functions (old->value, val);
3380 /* Some declarations are functions, some are not. */
3381 if (flags & LOOKUP_COMPLAIN)
3383 /* If we've already given this error for this lookup,
3384 old->value is error_mark_node, so let's not
3385 repeat ourselves. */
3386 if (old->value != error_mark_node)
3388 error ("use of %qD is ambiguous", name);
3389 cp_error_at (" first declared as %q#D here", old->value);
3391 cp_error_at (" also declared as %q#D here", val);
3393 old->value = error_mark_node;
3396 /* ... and copy the type. */
3398 if (LOOKUP_NAMESPACES_ONLY (flags))
3402 else if (type && old->type != type)
3404 if (flags & LOOKUP_COMPLAIN)
3406 error ("%qD denotes an ambiguous type",name);
3407 error ("%J first type here", TYPE_MAIN_DECL (old->type));
3408 error ("%J other type here", TYPE_MAIN_DECL (type));
3413 /* Return the declarations that are members of the namespace NS. */
3416 cp_namespace_decls (tree ns)
3418 return NAMESPACE_LEVEL (ns)->names;
3421 /* Combine prefer_type and namespaces_only into flags. */
3424 lookup_flags (int prefer_type, int namespaces_only)
3426 if (namespaces_only)
3427 return LOOKUP_PREFER_NAMESPACES;
3428 if (prefer_type > 1)
3429 return LOOKUP_PREFER_TYPES;
3430 if (prefer_type > 0)
3431 return LOOKUP_PREFER_BOTH;
3435 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3436 ignore it or not. Subroutine of lookup_name_real and
3437 lookup_type_scope. */
3440 qualify_lookup (tree val, int flags)
3442 if (val == NULL_TREE)
3444 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3446 if ((flags & LOOKUP_PREFER_TYPES)
3447 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3449 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3454 /* Given a lookup that returned VAL, decide if we want to ignore it or
3455 not based on DECL_ANTICIPATED_P. */
3458 hidden_name_p (tree val)
3461 && DECL_LANG_SPECIFIC (val)
3462 && DECL_ANTICIPATED (val))
3467 /* Look up NAME in the NAMESPACE. */
3470 lookup_namespace_name (tree namespace, tree name)
3473 tree template_id = NULL_TREE;
3474 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3476 timevar_push (TV_NAME_LOOKUP);
3477 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3479 if (TREE_CODE (name) == NAMESPACE_DECL)
3480 /* This happens for A::B<int> when B is a namespace. */
3481 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, name);
3482 else if (TREE_CODE (name) == TEMPLATE_DECL)
3484 /* This happens for A::B where B is a template, and there are no
3485 template arguments. */
3486 error ("invalid use of %qD", name);
3487 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3490 namespace = ORIGINAL_NAMESPACE (namespace);
3492 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3495 name = TREE_OPERAND (name, 0);
3496 if (TREE_CODE (name) == OVERLOAD)
3497 name = DECL_NAME (OVL_CURRENT (name));
3498 else if (DECL_P (name))
3499 name = DECL_NAME (name);
3502 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3504 if (!qualified_lookup_using_namespace (name, namespace, &binding, 0))
3505 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3509 val = binding.value;
3513 if (DECL_CLASS_TEMPLATE_P (val))
3514 val = lookup_template_class (val,
3515 TREE_OPERAND (template_id, 1),
3516 /*in_decl=*/NULL_TREE,
3517 /*context=*/NULL_TREE,
3518 /*entering_scope=*/0,
3519 tf_error | tf_warning);
3520 else if (DECL_FUNCTION_TEMPLATE_P (val)
3521 || TREE_CODE (val) == OVERLOAD)
3522 val = lookup_template_function (val,
3523 TREE_OPERAND (template_id, 1));
3526 error ("%<%D::%D%> is not a template", namespace, name);
3527 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3531 /* If we have a single function from a using decl, pull it out. */
3532 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3533 val = OVL_FUNCTION (val);
3535 /* Ignore built-in functions and friends that haven't been declared
3537 if (!val || !hidden_name_p (val))
3538 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3541 error ("%qD undeclared in namespace %qD", name, namespace);
3542 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3545 /* Select the right _DECL from multiple choices. */
3548 select_decl (const struct scope_binding *binding, int flags)
3551 val = binding->value;
3553 timevar_push (TV_NAME_LOOKUP);
3554 if (LOOKUP_NAMESPACES_ONLY (flags))
3556 /* We are not interested in types. */
3557 if (val && TREE_CODE (val) == NAMESPACE_DECL)
3558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3562 /* If looking for a type, or if there is no non-type binding, select
3563 the value binding. */
3564 if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
3565 val = binding->type;
3566 /* Don't return non-types if we really prefer types. */
3567 else if (val && LOOKUP_TYPES_ONLY (flags)
3568 && ! DECL_DECLARES_TYPE_P (val))
3571 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3574 /* Unscoped lookup of a global: iterate over current namespaces,
3575 considering using-directives. */
3578 unqualified_namespace_lookup (tree name, int flags)
3580 tree initial = current_decl_namespace ();
3581 tree scope = initial;
3583 struct cp_binding_level *level;
3584 tree val = NULL_TREE;
3585 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3587 timevar_push (TV_NAME_LOOKUP);
3589 for (; !val; scope = CP_DECL_CONTEXT (scope))
3592 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3596 if (b->value && hidden_name_p (b->value))
3597 /* Ignore anticipated built-in functions and friends. */
3600 binding.value = b->value;
3601 binding.type = b->type;
3604 /* Add all _DECLs seen through local using-directives. */
3605 for (level = current_binding_level;
3606 level->kind != sk_namespace;
3607 level = level->level_chain)
3608 if (!lookup_using_namespace (name, &binding, level->using_directives,
3610 /* Give up because of error. */
3611 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3613 /* Add all _DECLs seen through global using-directives. */
3614 /* XXX local and global using lists should work equally. */
3618 if (!lookup_using_namespace (name, &binding,
3619 DECL_NAMESPACE_USING (siter),
3621 /* Give up because of error. */
3622 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3623 if (siter == scope) break;
3624 siter = CP_DECL_CONTEXT (siter);
3627 val = select_decl (&binding, flags);
3628 if (scope == global_namespace)
3631 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3634 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3635 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3638 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3639 declaration found. If no suitable declaration can be found,
3640 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3641 neither a class-type nor a namespace a diagnostic is issued. */
3644 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3648 if (TREE_CODE (scope) == NAMESPACE_DECL)
3650 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3652 flags |= LOOKUP_COMPLAIN;
3654 flags |= LOOKUP_PREFER_TYPES;
3655 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3656 return select_decl (&binding, flags);
3658 else if (is_aggr_type (scope, complain))
3661 t = lookup_member (scope, name, 2, is_type_p);
3666 return error_mark_node;
3669 /* Subroutine of unqualified_namespace_lookup:
3670 Add the bindings of NAME in used namespaces to VAL.
3671 We are currently looking for names in namespace SCOPE, so we
3672 look through USINGS for using-directives of namespaces
3673 which have SCOPE as a common ancestor with the current scope.
3674 Returns false on errors. */
3677 lookup_using_namespace (tree name, struct scope_binding *val,
3678 tree usings, tree scope, int flags)
3681 timevar_push (TV_NAME_LOOKUP);
3682 /* Iterate over all used namespaces in current, searching for using
3683 directives of scope. */
3684 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3685 if (TREE_VALUE (iter) == scope)
3687 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3689 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3690 /* Resolve ambiguities. */
3692 ambiguous_decl (name, val, val1, flags);
3694 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3698 Accepts the NAME to lookup and its qualifying SCOPE.
3699 Returns the name/type pair found into the cxx_binding *RESULT,
3700 or false on error. */
3703 qualified_lookup_using_namespace (tree name, tree scope,
3704 struct scope_binding *result, int flags)
3706 /* Maintain a list of namespaces visited... */
3707 tree seen = NULL_TREE;
3708 /* ... and a list of namespace yet to see. */
3709 tree todo = NULL_TREE;
3710 tree todo_maybe = NULL_TREE;
3712 timevar_push (TV_NAME_LOOKUP);
3713 /* Look through namespace aliases. */
3714 scope = ORIGINAL_NAMESPACE (scope);
3715 while (scope && result->value != error_mark_node)
3717 cxx_binding *binding =
3718 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3719 seen = tree_cons (scope, NULL_TREE, seen);
3721 ambiguous_decl (name, result, binding, flags);
3723 /* Consider strong using directives always, and non-strong ones
3724 if we haven't found a binding yet. ??? Shouldn't we consider
3725 non-strong ones if the initial RESULT is non-NULL, but the
3726 binding in the given namespace is? */
3727 for (usings = DECL_NAMESPACE_USING (scope); usings;
3728 usings = TREE_CHAIN (usings))
3729 /* If this was a real directive, and we have not seen it. */
3730 if (!TREE_INDIRECT_USING (usings))
3732 /* Try to avoid queuing the same namespace more than once,
3733 the exception being when a namespace was already
3734 enqueued for todo_maybe and then a strong using is
3735 found for it. We could try to remove it from
3736 todo_maybe, but it's probably not worth the effort. */
3737 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3738 && !purpose_member (TREE_PURPOSE (usings), seen)
3739 && !purpose_member (TREE_PURPOSE (usings), todo))
3740 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3741 else if ((!result->value && !result->type)
3742 && !purpose_member (TREE_PURPOSE (usings), seen)
3743 && !purpose_member (TREE_PURPOSE (usings), todo)
3744 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3745 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3750 scope = TREE_PURPOSE (todo);
3751 todo = TREE_CHAIN (todo);
3754 && (!result->value && !result->type))
3756 scope = TREE_PURPOSE (todo_maybe);
3757 todo = TREE_CHAIN (todo_maybe);
3758 todo_maybe = NULL_TREE;
3761 scope = NULL_TREE; /* If there never was a todo list. */
3763 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3766 /* Return the innermost non-namespace binding for NAME from a scope
3767 containing BINDING, or, if BINDING is NULL, the current scope. If
3768 CLASS_P is false, then class bindings are ignored. */
3771 outer_binding (tree name,
3772 cxx_binding *binding,
3777 cxx_scope *outer_scope;
3781 scope = binding->scope->level_chain;
3782 outer = binding->previous;
3786 scope = current_binding_level;
3787 outer = IDENTIFIER_BINDING (name);
3789 outer_scope = outer ? outer->scope : NULL;
3791 /* Because we create class bindings lazily, we might be missing a
3792 class binding for NAME. If there are any class binding levels
3793 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3794 declared, we must lookup NAME in those class scopes. */
3796 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3798 if (scope->kind == sk_class)
3800 cxx_binding *class_binding;
3802 class_binding = get_class_binding (name, scope);
3805 /* Thread this new class-scope binding onto the
3806 IDENTIFIER_BINDING list so that future lookups
3808 class_binding->previous = outer;
3810 binding->previous = class_binding;
3812 IDENTIFIER_BINDING (name) = class_binding;
3813 return class_binding;
3816 scope = scope->level_chain;
3822 /* Return the innermost block-scope or class-scope value binding for
3823 NAME, or NULL_TREE if there is no such binding. */
3826 innermost_non_namespace_value (tree name)
3828 cxx_binding *binding;
3829 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3830 return binding ? binding->value : NULL_TREE;
3833 /* Look up NAME in the current binding level and its superiors in the
3834 namespace of variables, functions and typedefs. Return a ..._DECL
3835 node of some kind representing its definition if there is only one
3836 such declaration, or return a TREE_LIST with all the overloaded
3837 definitions if there are many, or return 0 if it is undefined.
3838 Hidden name, either friend declaration or built-in function, are
3841 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3842 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3843 Otherwise we prefer non-TYPE_DECLs.
3845 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3846 BLOCK_P is false, bindings in block scopes are ignored. */
3849 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3850 int namespaces_only, int flags)
3853 tree val = NULL_TREE;
3855 timevar_push (TV_NAME_LOOKUP);
3856 /* Conversion operators are handled specially because ordinary
3857 unqualified name lookup will not find template conversion
3859 if (IDENTIFIER_TYPENAME_P (name))
3861 struct cp_binding_level *level;
3863 for (level = current_binding_level;
3864 level && level->kind != sk_namespace;
3865 level = level->level_chain)
3870 /* A conversion operator can only be declared in a class
3872 if (level->kind != sk_class)
3875 /* Lookup the conversion operator in the class. */
3876 class_type = level->this_entity;
3877 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3879 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
3882 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
3885 flags |= lookup_flags (prefer_type, namespaces_only);
3887 /* First, look in non-namespace scopes. */
3889 if (current_class_type == NULL_TREE)
3892 if (block_p || !nonclass)
3893 for (iter = outer_binding (name, NULL, !nonclass);
3895 iter = outer_binding (name, iter, !nonclass))
3899 /* Skip entities we don't want. */
3900 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
3903 /* If this is the kind of thing we're looking for, we're done. */
3904 if (qualify_lookup (iter->value, flags)
3905 && !hidden_name_p (iter->value))
3906 binding = iter->value;
3907 else if ((flags & LOOKUP_PREFER_TYPES)
3908 && qualify_lookup (iter->type, flags)
3909 && !hidden_name_p (iter->type))
3910 binding = iter->type;
3912 binding = NULL_TREE;
3921 /* Now lookup in namespace scopes. */
3923 val = unqualified_namespace_lookup (name, flags);
3927 /* If we have a single function from a using decl, pull it out. */
3928 if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val))
3929 val = OVL_FUNCTION (val);
3932 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3936 lookup_name_nonclass (tree name)
3938 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
3942 lookup_function_nonclass (tree name, tree args, bool block_p)
3945 lookup_arg_dependent (name,
3946 lookup_name_real (name, 0, 1, block_p, 0,
3952 lookup_name (tree name, int prefer_type)
3954 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
3955 0, LOOKUP_COMPLAIN);
3958 /* Look up NAME for type used in elaborated name specifier in
3959 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
3960 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
3961 name, more scopes are checked if cleanup or template parameter
3962 scope is encountered.
3964 Unlike lookup_name_real, we make sure that NAME is actually
3965 declared in the desired scope, not from inheritance, nor using
3966 directive. For using declaration, there is DR138 still waiting
3967 to be resolved. Hidden name coming from earlier an friend
3968 declaration is also returned.
3970 A TYPE_DECL best matching the NAME is returned. Catching error
3971 and issuing diagnostics are caller's responsibility. */
3974 lookup_type_scope (tree name, tag_scope scope)
3976 cxx_binding *iter = NULL;
3977 tree val = NULL_TREE;
3979 timevar_push (TV_NAME_LOOKUP);
3981 /* Look in non-namespace scope first. */
3982 if (current_binding_level->kind != sk_namespace)
3983 iter = outer_binding (name, NULL, /*class_p=*/ true);
3984 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
3986 /* Check if this is the kind of thing we're looking for.
3987 If SCOPE is TS_CURRENT, also make sure it doesn't come from
3988 base class. For ITER->VALUE, we can simply use
3989 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
3992 We check ITER->TYPE before ITER->VALUE in order to handle
3993 typedef struct C {} C;
3996 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
3997 && (scope != ts_current
3998 || LOCAL_BINDING_P (iter)
3999 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4001 else if ((scope != ts_current
4002 || !INHERITED_VALUE_BINDING_P (iter))
4003 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4010 /* Look in namespace scope. */
4013 iter = cxx_scope_find_binding_for_name
4014 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4018 /* If this is the kind of thing we're looking for, we're done. */
4019 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4021 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4027 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4028 and template parameter scopes. */
4031 struct cp_binding_level *b = current_binding_level;
4034 if (iter->scope == b)
4035 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4037 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4039 else if (b->kind == sk_class
4040 && scope == ts_within_enclosing_non_class)
4047 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4050 /* Similar to `lookup_name' but look only in the innermost non-class
4054 lookup_name_innermost_nonclass_level (tree name)
4056 struct cp_binding_level *b;
4059 timevar_push (TV_NAME_LOOKUP);
4060 b = innermost_nonclass_level ();
4062 if (b->kind == sk_namespace)
4064 t = IDENTIFIER_NAMESPACE_VALUE (name);
4066 /* extern "C" function() */
4067 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4070 else if (IDENTIFIER_BINDING (name)
4071 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4073 cxx_binding *binding;
4074 binding = IDENTIFIER_BINDING (name);
4077 if (binding->scope == b
4078 && !(TREE_CODE (binding->value) == VAR_DECL
4079 && DECL_DEAD_FOR_LOCAL (binding->value)))
4080 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4082 if (b->kind == sk_cleanup)
4089 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4092 /* Like lookup_name_innermost_nonclass_level, but for types. */
4095 lookup_type_current_level (tree name)
4099 timevar_push (TV_NAME_LOOKUP);
4100 gcc_assert (current_binding_level->kind != sk_namespace);
4102 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4103 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4105 struct cp_binding_level *b = current_binding_level;
4108 if (purpose_member (name, b->type_shadowed))
4109 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4110 REAL_IDENTIFIER_TYPE_VALUE (name));
4111 if (b->kind == sk_cleanup)
4118 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4121 /* [basic.lookup.koenig] */
4122 /* A nonzero return value in the functions below indicates an error. */
4132 static bool arg_assoc (struct arg_lookup*, tree);
4133 static bool arg_assoc_args (struct arg_lookup*, tree);
4134 static bool arg_assoc_type (struct arg_lookup*, tree);
4135 static bool add_function (struct arg_lookup *, tree);
4136 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4137 static bool arg_assoc_class (struct arg_lookup *, tree);
4138 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4140 /* Add a function to the lookup structure.
4141 Returns true on error. */
4144 add_function (struct arg_lookup *k, tree fn)
4146 /* We used to check here to see if the function was already in the list,
4147 but that's O(n^2), which is just too expensive for function lookup.
4148 Now we deal with the occasional duplicate in joust. In doing this, we
4149 assume that the number of duplicates will be small compared to the
4150 total number of functions being compared, which should usually be the
4153 /* We must find only functions, or exactly one non-function. */
4156 else if (fn == k->functions)
4158 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4159 k->functions = build_overload (fn, k->functions);
4162 tree f1 = OVL_CURRENT (k->functions);
4164 if (is_overloaded_fn (f1))
4166 fn = f1; f1 = f2; f2 = fn;
4168 cp_error_at ("%qD is not a function,", f1);
4169 cp_error_at (" conflict with %qD", f2);
4170 error (" in call to %qD", k->name);
4177 /* Returns true iff CURRENT has declared itself to be an associated
4178 namespace of SCOPE via a strong using-directive (or transitive chain
4179 thereof). Both are namespaces. */
4182 is_associated_namespace (tree current, tree scope)
4184 tree seen = NULL_TREE;
4185 tree todo = NULL_TREE;
4189 if (scope == current)
4191 seen = tree_cons (scope, NULL_TREE, seen);
4192 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4193 if (!purpose_member (TREE_PURPOSE (t), seen))
4194 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4197 scope = TREE_PURPOSE (todo);
4198 todo = TREE_CHAIN (todo);
4205 /* Add functions of a namespace to the lookup structure.
4206 Returns true on error. */
4209 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4213 if (purpose_member (scope, k->namespaces))
4215 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4217 /* Check out our super-users. */
4218 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4219 value = TREE_CHAIN (value))
4220 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4223 value = namespace_binding (k->name, scope);
4227 for (; value; value = OVL_NEXT (value))
4228 if (add_function (k, OVL_CURRENT (value)))
4234 /* Adds everything associated with a template argument to the lookup
4235 structure. Returns true on error. */
4238 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4240 /* [basic.lookup.koenig]
4242 If T is a template-id, its associated namespaces and classes are
4243 ... the namespaces and classes associated with the types of the
4244 template arguments provided for template type parameters
4245 (excluding template template parameters); the namespaces in which
4246 any template template arguments are defined; and the classes in
4247 which any member templates used as template template arguments
4248 are defined. [Note: non-type template arguments do not
4249 contribute to the set of associated namespaces. ] */
4251 /* Consider first template template arguments. */
4252 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4253 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4255 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4257 tree ctx = CP_DECL_CONTEXT (arg);
4259 /* It's not a member template. */
4260 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4261 return arg_assoc_namespace (k, ctx);
4262 /* Otherwise, it must be member template. */
4264 return arg_assoc_class (k, ctx);
4266 /* It's not a template template argument, but it is a type template
4268 else if (TYPE_P (arg))
4269 return arg_assoc_type (k, arg);
4270 /* It's a non-type template argument. */
4275 /* Adds everything associated with class to the lookup structure.
4276 Returns true on error. */
4279 arg_assoc_class (struct arg_lookup *k, tree type)
4281 tree list, friends, context;
4284 /* Backend build structures, such as __builtin_va_list, aren't
4285 affected by all this. */
4286 if (!CLASS_TYPE_P (type))
4289 if (purpose_member (type, k->classes))
4291 k->classes = tree_cons (type, NULL_TREE, k->classes);
4293 context = decl_namespace_context (type);
4294 if (arg_assoc_namespace (k, context))
4297 if (TYPE_BINFO (type))
4299 /* Process baseclasses. */
4300 tree binfo, base_binfo;
4302 for (binfo = TYPE_BINFO (type), i = 0;
4303 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4304 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4308 /* Process friends. */
4309 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4310 list = TREE_CHAIN (list))
4311 if (k->name == FRIEND_NAME (list))
4312 for (friends = FRIEND_DECLS (list); friends;
4313 friends = TREE_CHAIN (friends))
4315 tree fn = TREE_VALUE (friends);
4317 /* Only interested in global functions with potentially hidden
4318 (i.e. unqualified) declarations. */
4319 if (CP_DECL_CONTEXT (fn) != context)
4321 /* Template specializations are never found by name lookup.
4322 (Templates themselves can be found, but not template
4323 specializations.) */
4324 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4326 if (add_function (k, fn))
4330 /* Process template arguments. */
4331 if (CLASSTYPE_TEMPLATE_INFO (type)
4332 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4334 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4335 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4336 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4342 /* Adds everything associated with a given type.
4343 Returns 1 on error. */
4346 arg_assoc_type (struct arg_lookup *k, tree type)
4348 /* As we do not get the type of non-type dependent expressions
4349 right, we can end up with such things without a type. */
4353 if (TYPE_PTRMEM_P (type))
4355 /* Pointer to member: associate class type and value type. */
4356 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4358 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4360 else switch (TREE_CODE (type))
4373 if (TYPE_PTRMEMFUNC_P (type))
4374 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4375 return arg_assoc_class (k, type);
4377 case REFERENCE_TYPE:
4379 return arg_assoc_type (k, TREE_TYPE (type));
4382 return arg_assoc_namespace (k, decl_namespace_context (type));
4384 /* The basetype is referenced in the first arg type, so just
4387 /* Associate the parameter types. */
4388 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4390 /* Associate the return type. */
4391 return arg_assoc_type (k, TREE_TYPE (type));
4392 case TEMPLATE_TYPE_PARM:
4393 case BOUND_TEMPLATE_TEMPLATE_PARM:
4398 gcc_assert (type == unknown_type_node);
4406 /* Adds everything associated with arguments. Returns true on error. */
4409 arg_assoc_args (struct arg_lookup *k, tree args)
4411 for (; args; args = TREE_CHAIN (args))
4412 if (arg_assoc (k, TREE_VALUE (args)))
4417 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4420 arg_assoc (struct arg_lookup *k, tree n)
4422 if (n == error_mark_node)
4426 return arg_assoc_type (k, n);
4428 if (! type_unknown_p (n))
4429 return arg_assoc_type (k, TREE_TYPE (n));
4431 if (TREE_CODE (n) == ADDR_EXPR)
4432 n = TREE_OPERAND (n, 0);
4433 if (TREE_CODE (n) == COMPONENT_REF)
4434 n = TREE_OPERAND (n, 1);
4435 if (TREE_CODE (n) == OFFSET_REF)
4436 n = TREE_OPERAND (n, 1);
4437 while (TREE_CODE (n) == TREE_LIST)
4439 if (TREE_CODE (n) == BASELINK)
4440 n = BASELINK_FUNCTIONS (n);
4442 if (TREE_CODE (n) == FUNCTION_DECL)
4443 return arg_assoc_type (k, TREE_TYPE (n));
4444 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4446 /* [basic.lookup.koenig]
4448 If T is a template-id, its associated namespaces and classes
4449 are the namespace in which the template is defined; for
4450 member templates, the member template's class... */
4451 tree template = TREE_OPERAND (n, 0);
4452 tree args = TREE_OPERAND (n, 1);
4456 if (TREE_CODE (template) == COMPONENT_REF)
4457 template = TREE_OPERAND (template, 1);
4459 /* First, the template. There may actually be more than one if
4460 this is an overloaded function template. But, in that case,
4461 we only need the first; all the functions will be in the same
4463 template = OVL_CURRENT (template);
4465 ctx = CP_DECL_CONTEXT (template);
4467 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4469 if (arg_assoc_namespace (k, ctx) == 1)
4472 /* It must be a member template. */
4473 else if (arg_assoc_class (k, ctx) == 1)
4476 /* Now the arguments. */
4477 for (ix = TREE_VEC_LENGTH (args); ix--;)
4478 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4481 else if (TREE_CODE (n) == OVERLOAD)
4483 for (; n; n = OVL_CHAIN (n))
4484 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4491 /* Performs Koenig lookup depending on arguments, where fns
4492 are the functions found in normal lookup. */
4495 lookup_arg_dependent (tree name, tree fns, tree args)
4497 struct arg_lookup k;
4498 tree fn = NULL_TREE;
4500 timevar_push (TV_NAME_LOOKUP);
4503 k.classes = NULL_TREE;
4505 /* We've already looked at some namespaces during normal unqualified
4506 lookup -- but we don't know exactly which ones. If the functions
4507 we found were brought into the current namespace via a using
4508 declaration, we have not really checked the namespace from which
4509 they came. Therefore, we check all namespaces here -- unless the
4510 function we have is from the current namespace. Even then, we
4511 must check all namespaces if the function is a local
4512 declaration; any other declarations present at namespace scope
4513 should be visible during argument-dependent lookup. */
4515 fn = OVL_CURRENT (fns);
4516 if (fn && TREE_CODE (fn) == FUNCTION_DECL
4517 && (CP_DECL_CONTEXT (fn) != current_decl_namespace ()
4518 || DECL_LOCAL_FUNCTION_P (fn)))
4519 k.namespaces = NULL_TREE;
4521 /* Setting NAMESPACES is purely an optimization; it prevents
4522 adding functions which are already in FNS. Adding them would
4523 be safe -- "joust" will eliminate the duplicates -- but
4525 k.namespaces = build_tree_list (current_decl_namespace (), NULL_TREE);
4527 arg_assoc_args (&k, args);
4528 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, k.functions);
4531 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4532 changed (i.e. there was already a directive), or the fresh
4533 TREE_LIST otherwise. */
4536 push_using_directive (tree used)
4538 tree ud = current_binding_level->using_directives;
4539 tree iter, ancestor;
4541 timevar_push (TV_NAME_LOOKUP);
4542 /* Check if we already have this. */
4543 if (purpose_member (used, ud) != NULL_TREE)
4544 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4546 ancestor = namespace_ancestor (current_decl_namespace (), used);
4547 ud = current_binding_level->using_directives;
4548 ud = tree_cons (used, ancestor, ud);
4549 current_binding_level->using_directives = ud;
4551 /* Recursively add all namespaces used. */
4552 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4553 push_using_directive (TREE_PURPOSE (iter));
4555 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4558 /* The type TYPE is being declared. If it is a class template, or a
4559 specialization of a class template, do any processing required and
4560 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4561 being declared a friend. B is the binding level at which this TYPE
4564 Returns the TYPE_DECL for TYPE, which may have been altered by this
4568 maybe_process_template_type_declaration (tree type, int is_friend,
4571 tree decl = TYPE_NAME (type);
4573 if (processing_template_parmlist)
4574 /* You can't declare a new template type in a template parameter
4575 list. But, you can declare a non-template type:
4577 template <class A*> struct S;
4579 is a forward-declaration of `A'. */
4583 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4585 if (processing_template_decl)
4587 /* This may change after the call to
4588 push_template_decl_real, but we want the original value. */
4589 tree name = DECL_NAME (decl);
4591 decl = push_template_decl_real (decl, is_friend);
4592 /* If the current binding level is the binding level for the
4593 template parameters (see the comment in
4594 begin_template_parm_list) and the enclosing level is a class
4595 scope, and we're not looking at a friend, push the
4596 declaration of the member class into the class scope. In the
4597 friend case, push_template_decl will already have put the
4598 friend into global scope, if appropriate. */
4599 if (TREE_CODE (type) != ENUMERAL_TYPE
4600 && !is_friend && b->kind == sk_template_parms
4601 && b->level_chain->kind == sk_class)
4603 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4605 if (!COMPLETE_TYPE_P (current_class_type))
4607 maybe_add_class_template_decl_list (current_class_type,
4608 type, /*friend_p=*/0);
4609 /* Put this UDT in the table of UDTs for the class. */
4610 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4611 CLASSTYPE_NESTED_UTDS (current_class_type) =
4612 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4614 binding_table_insert
4615 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4624 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4625 that the NAME is a class template, the tag is processed but not pushed.
4627 The pushed scope depend on the SCOPE parameter:
4628 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4630 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4631 non-template-parameter scope. This case is needed for forward
4633 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4634 TS_GLOBAL case except that names within template-parameter scopes
4635 are not pushed at all.
4637 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4640 pushtag (tree name, tree type, tag_scope scope)
4642 struct cp_binding_level *b;
4644 timevar_push (TV_NAME_LOOKUP);
4645 b = current_binding_level;
4646 while (/* Cleanup scopes are not scopes from the point of view of
4648 b->kind == sk_cleanup
4649 /* Neither are the scopes used to hold template parameters
4650 for an explicit specialization. For an ordinary template
4651 declaration, these scopes are not scopes from the point of
4652 view of the language. */
4653 || (b->kind == sk_template_parms
4654 && (b->explicit_spec_p || scope == ts_global))
4655 || (b->kind == sk_class
4656 && (scope != ts_current
4657 /* We may be defining a new type in the initializer
4658 of a static member variable. We allow this when
4659 not pedantic, and it is particularly useful for
4660 type punning via an anonymous union. */
4661 || COMPLETE_TYPE_P (b->this_entity))))
4666 /* Do C++ gratuitous typedefing. */
4667 if (IDENTIFIER_TYPE_VALUE (name) != type)
4671 tree context = TYPE_CONTEXT (type);
4675 tree cs = current_scope ();
4677 if (scope == ts_current)
4679 else if (cs != NULL_TREE && TYPE_P (cs))
4680 /* When declaring a friend class of a local class, we want
4681 to inject the newly named class into the scope
4682 containing the local class, not the namespace scope. */
4683 context = decl_function_context (get_type_decl (cs));
4686 context = current_namespace;
4688 if (b->kind == sk_class
4689 || (b->kind == sk_template_parms
4690 && b->level_chain->kind == sk_class))
4693 if (current_lang_name == lang_name_java)
4694 TYPE_FOR_JAVA (type) = 1;
4696 d = create_implicit_typedef (name, type);
4697 DECL_CONTEXT (d) = FROB_CONTEXT (context);
4698 if (scope == ts_within_enclosing_non_class)
4700 /* This is a friend. Make this TYPE_DECL node hidden from
4701 ordinary name lookup. Its corresponding TEMPLATE_DECL
4702 will be marked in push_template_decl_real. */
4703 retrofit_lang_decl (d);
4704 DECL_ANTICIPATED (d) = 1;
4705 DECL_FRIEND_P (d) = 1;
4709 set_identifier_type_value_with_scope (name, d, b);
4711 d = maybe_process_template_type_declaration
4712 (type, scope == ts_within_enclosing_non_class, b);
4713 if (d == error_mark_node)
4714 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4716 if (b->kind == sk_class)
4718 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4719 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4720 class. But if it's a member template class, we
4721 want the TEMPLATE_DECL, not the TYPE_DECL, so this
4723 finish_member_declaration (d);
4725 pushdecl_class_level (d);
4727 else if (b->kind != sk_template_parms)
4728 d = pushdecl_with_scope (d, b);
4730 if (d == error_mark_node)
4731 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
4733 /* FIXME what if it gets a name from typedef? */
4734 if (ANON_AGGRNAME_P (name))
4735 DECL_IGNORED_P (d) = 1;
4737 TYPE_CONTEXT (type) = DECL_CONTEXT (d);
4739 /* If this is a local class, keep track of it. We need this
4740 information for name-mangling, and so that it is possible to find
4741 all function definitions in a translation unit in a convenient
4742 way. (It's otherwise tricky to find a member function definition
4743 it's only pointed to from within a local class.) */
4744 if (TYPE_CONTEXT (type)
4745 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4746 VEC_safe_push (tree, gc, local_classes, type);
4748 if (b->kind == sk_class
4749 && !COMPLETE_TYPE_P (current_class_type))
4751 maybe_add_class_template_decl_list (current_class_type,
4752 type, /*friend_p=*/0);
4754 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4755 CLASSTYPE_NESTED_UTDS (current_class_type)
4756 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4758 binding_table_insert
4759 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4763 if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
4764 /* Use the canonical TYPE_DECL for this node. */
4765 TYPE_STUB_DECL (type) = TYPE_NAME (type);
4768 /* Create a fake NULL-named TYPE_DECL node whose TREE_TYPE
4769 will be the tagged type we just added to the current
4770 binding level. This fake NULL-named TYPE_DECL node helps
4771 dwarfout.c to know when it needs to output a
4772 representation of a tagged type, and it also gives us a
4773 convenient place to record the "scope start" address for
4776 tree d = build_decl (TYPE_DECL, NULL_TREE, type);
4777 TYPE_STUB_DECL (type) = pushdecl_with_scope (d, b);
4779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
4782 /* Subroutines for reverting temporarily to top-level for instantiation
4783 of templates and such. We actually need to clear out the class- and
4784 local-value slots of all identifiers, so that only the global values
4785 are at all visible. Simply setting current_binding_level to the global
4786 scope isn't enough, because more binding levels may be pushed. */
4787 struct saved_scope *scope_chain;
4789 /* If ID has not already been marked, add an appropriate binding to
4793 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
4795 cxx_saved_binding *saved;
4797 if (!id || !IDENTIFIER_BINDING (id))
4800 if (IDENTIFIER_MARKED (id))
4803 IDENTIFIER_MARKED (id) = 1;
4805 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
4806 saved->identifier = id;
4807 saved->binding = IDENTIFIER_BINDING (id);
4808 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
4809 IDENTIFIER_BINDING (id) = NULL;
4813 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
4817 timevar_push (TV_NAME_LOOKUP);
4818 for (t = names; t; t = TREE_CHAIN (t))
4822 if (TREE_CODE (t) == TREE_LIST)
4823 id = TREE_PURPOSE (t);
4827 store_binding (id, old_bindings);
4829 timevar_pop (TV_NAME_LOOKUP);
4832 /* Like store_bindings, but NAMES is a vector of cp_class_binding
4833 objects, rather than a TREE_LIST. */
4836 store_class_bindings (VEC(cp_class_binding,gc) *names,
4837 VEC(cxx_saved_binding,gc) **old_bindings)
4840 cp_class_binding *cb;
4842 timevar_push (TV_NAME_LOOKUP);
4843 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
4844 store_binding (cb->identifier, old_bindings);
4845 timevar_pop (TV_NAME_LOOKUP);
4849 push_to_top_level (void)
4851 struct saved_scope *s;
4852 struct cp_binding_level *b;
4853 cxx_saved_binding *sb;
4857 timevar_push (TV_NAME_LOOKUP);
4858 s = GGC_CNEW (struct saved_scope);
4860 b = scope_chain ? current_binding_level : 0;
4862 /* If we're in the middle of some function, save our state. */
4866 push_function_context_to (NULL_TREE);
4871 if (scope_chain && previous_class_level)
4872 store_class_bindings (previous_class_level->class_shadowed,
4875 /* Have to include the global scope, because class-scope decls
4876 aren't listed anywhere useful. */
4877 for (; b; b = b->level_chain)
4881 /* Template IDs are inserted into the global level. If they were
4882 inserted into namespace level, finish_file wouldn't find them
4883 when doing pending instantiations. Therefore, don't stop at
4884 namespace level, but continue until :: . */
4885 if (global_scope_p (b))
4888 store_bindings (b->names, &s->old_bindings);
4889 /* We also need to check class_shadowed to save class-level type
4890 bindings, since pushclass doesn't fill in b->names. */
4891 if (b->kind == sk_class)
4892 store_class_bindings (b->class_shadowed, &s->old_bindings);
4894 /* Unwind type-value slots back to top level. */
4895 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
4896 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
4899 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
4900 IDENTIFIER_MARKED (sb->identifier) = 0;
4902 s->prev = scope_chain;
4904 s->need_pop_function_context = need_pop;
4905 s->function_decl = current_function_decl;
4908 current_function_decl = NULL_TREE;
4909 current_lang_base = VEC_alloc (tree, gc, 10);
4910 current_lang_name = lang_name_cplusplus;
4911 current_namespace = global_namespace;
4912 timevar_pop (TV_NAME_LOOKUP);
4916 pop_from_top_level (void)
4918 struct saved_scope *s = scope_chain;
4919 cxx_saved_binding *saved;
4922 timevar_push (TV_NAME_LOOKUP);
4923 /* Clear out class-level bindings cache. */
4924 if (previous_class_level)
4925 invalidate_class_lookup_cache ();
4927 current_lang_base = 0;
4929 scope_chain = s->prev;
4930 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
4932 tree id = saved->identifier;
4934 IDENTIFIER_BINDING (id) = saved->binding;
4935 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
4938 /* If we were in the middle of compiling a function, restore our
4940 if (s->need_pop_function_context)
4941 pop_function_context_from (NULL_TREE);
4942 current_function_decl = s->function_decl;
4943 timevar_pop (TV_NAME_LOOKUP);
4946 /* Pop off extraneous binding levels left over due to syntax errors.
4948 We don't pop past namespaces, as they might be valid. */
4951 pop_everything (void)
4953 if (ENABLE_SCOPE_CHECKING)
4954 verbatim ("XXX entering pop_everything ()\n");
4955 while (!toplevel_bindings_p ())
4957 if (current_binding_level->kind == sk_class)
4958 pop_nested_class ();
4962 if (ENABLE_SCOPE_CHECKING)
4963 verbatim ("XXX leaving pop_everything ()\n");
4966 /* Emit debugging information for using declarations and directives.
4967 If input tree is overloaded fn then emit debug info for all
4971 cp_emit_debug_info_for_using (tree t, tree context)
4973 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
4974 of a builtin function. */
4975 if (TREE_CODE (t) == FUNCTION_DECL
4976 && DECL_EXTERNAL (t)
4977 && DECL_BUILT_IN (t))
4980 /* Do not supply context to imported_module_or_decl, if
4981 it is a global namespace. */
4982 if (context == global_namespace)
4983 context = NULL_TREE;
4986 t = BASELINK_FUNCTIONS (t);
4988 /* FIXME: Handle TEMPLATE_DECLs. */
4989 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
4990 if (TREE_CODE (t) != TEMPLATE_DECL)
4991 (*debug_hooks->imported_module_or_decl) (t, context);
4994 #include "gt-cp-name-lookup.h"