1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
4 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "name-lookup.h"
32 #include "diagnostic.h"
36 /* The bindings for a particular name in a particular scope. */
38 struct scope_binding {
42 #define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
44 static cxx_scope *innermost_nonclass_level (void);
45 static cxx_binding *binding_for_name (cxx_scope *, tree);
46 static tree push_overloaded_decl (tree, int, bool);
47 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
49 static bool qualified_lookup_using_namespace (tree, tree,
50 struct scope_binding *, int);
51 static tree lookup_type_current_level (tree);
52 static tree push_using_directive (tree);
53 static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (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;
63 /* Initialize anonymous_namespace_name if necessary, and return it. */
66 get_anonymous_namespace_name(void)
68 if (!anonymous_namespace_name)
70 /* The anonymous namespace has to have a unique name
71 if typeinfo objects are being compared by name. */
72 if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73 anonymous_namespace_name = get_file_function_name ("N");
75 /* The demangler expects anonymous namespaces to be called
76 something starting with '_GLOBAL__N_'. */
77 anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
79 return anonymous_namespace_name;
82 /* Compute the chain index of a binding_entry given the HASH value of its
83 name and the total COUNT of chains. COUNT is assumed to be a power
86 #define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
88 /* A free list of "binding_entry"s awaiting for re-use. */
90 static GTY((deletable)) binding_entry free_binding_entry = NULL;
92 /* Create a binding_entry object for (NAME, TYPE). */
94 static inline binding_entry
95 binding_entry_make (tree name, tree type)
99 if (free_binding_entry)
101 entry = free_binding_entry;
102 free_binding_entry = entry->chain;
105 entry = GGC_NEW (struct binding_entry_s);
114 /* Put ENTRY back on the free list. */
117 binding_entry_free (binding_entry entry)
121 entry->chain = free_binding_entry;
122 free_binding_entry = entry;
126 /* The datatype used to implement the mapping from names to types at
128 struct GTY(()) binding_table_s {
129 /* Array of chains of "binding_entry"s */
130 binding_entry * GTY((length ("%h.chain_count"))) chain;
132 /* The number of chains in this table. This is the length of the
133 member "chain" considered as an array. */
136 /* Number of "binding_entry"s in this table. */
140 /* Construct TABLE with an initial CHAIN_COUNT. */
143 binding_table_construct (binding_table table, size_t chain_count)
145 table->chain_count = chain_count;
146 table->entry_count = 0;
147 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
150 /* Make TABLE's entries ready for reuse. */
153 binding_table_free (binding_table table)
161 for (i = 0, count = table->chain_count; i < count; ++i)
163 binding_entry temp = table->chain[i];
166 binding_entry entry = temp;
168 binding_entry_free (entry);
170 table->chain[i] = NULL;
172 table->entry_count = 0;
176 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
178 static inline binding_table
179 binding_table_new (size_t chain_count)
181 binding_table table = GGC_NEW (struct binding_table_s);
183 binding_table_construct (table, chain_count);
187 /* Expand TABLE to twice its current chain_count. */
190 binding_table_expand (binding_table table)
192 const size_t old_chain_count = table->chain_count;
193 const size_t old_entry_count = table->entry_count;
194 const size_t new_chain_count = 2 * old_chain_count;
195 binding_entry *old_chains = table->chain;
198 binding_table_construct (table, new_chain_count);
199 for (i = 0; i < old_chain_count; ++i)
201 binding_entry entry = old_chains[i];
202 for (; entry != NULL; entry = old_chains[i])
204 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
205 const size_t j = ENTRY_INDEX (hash, new_chain_count);
207 old_chains[i] = entry->chain;
208 entry->chain = table->chain[j];
209 table->chain[j] = entry;
212 table->entry_count = old_entry_count;
215 /* Insert a binding for NAME to TYPE into TABLE. */
218 binding_table_insert (binding_table table, tree name, tree type)
220 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221 const size_t i = ENTRY_INDEX (hash, table->chain_count);
222 binding_entry entry = binding_entry_make (name, type);
224 entry->chain = table->chain[i];
225 table->chain[i] = entry;
226 ++table->entry_count;
228 if (3 * table->chain_count < 5 * table->entry_count)
229 binding_table_expand (table);
232 /* Return the binding_entry, if any, that maps NAME. */
235 binding_table_find (binding_table table, tree name)
237 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
238 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
240 while (entry != NULL && entry->name != name)
241 entry = entry->chain;
246 /* Apply PROC -- with DATA -- to all entries in TABLE. */
249 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
251 const size_t chain_count = table->chain_count;
254 for (i = 0; i < chain_count; ++i)
256 binding_entry entry = table->chain[i];
257 for (; entry != NULL; entry = entry->chain)
262 #ifndef ENABLE_SCOPE_CHECKING
263 # define ENABLE_SCOPE_CHECKING 0
265 # define ENABLE_SCOPE_CHECKING 1
268 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
270 static GTY((deletable)) cxx_binding *free_bindings;
272 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
276 cxx_binding_init (cxx_binding *binding, tree value, tree type)
278 binding->value = value;
279 binding->type = type;
280 binding->previous = NULL;
283 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
286 cxx_binding_make (tree value, tree type)
288 cxx_binding *binding;
291 binding = free_bindings;
292 free_bindings = binding->previous;
295 binding = GGC_NEW (cxx_binding);
297 cxx_binding_init (binding, value, type);
302 /* Put BINDING back on the free list. */
305 cxx_binding_free (cxx_binding *binding)
307 binding->scope = NULL;
308 binding->previous = free_bindings;
309 free_bindings = binding;
312 /* Create a new binding for NAME (with the indicated VALUE and TYPE
313 bindings) in the class scope indicated by SCOPE. */
316 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
318 cp_class_binding *cb;
319 cxx_binding *binding;
321 if (VEC_length (cp_class_binding, scope->class_shadowed))
323 cp_class_binding *old_base;
324 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
325 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
327 /* Fixup the current bindings, as they might have moved. */
331 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
335 b = &IDENTIFIER_BINDING (cb->identifier);
336 while (*b != &old_base[i].base)
337 b = &((*b)->previous);
341 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
344 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
346 cb->identifier = name;
348 binding->scope = scope;
349 cxx_binding_init (binding, value, type);
353 /* Make DECL the innermost binding for ID. The LEVEL is the binding
354 level at which this declaration is being bound. */
357 push_binding (tree id, tree decl, cxx_scope* level)
359 cxx_binding *binding;
361 if (level != class_binding_level)
363 binding = cxx_binding_make (decl, NULL_TREE);
364 binding->scope = level;
367 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
369 /* Now, fill in the binding information. */
370 binding->previous = IDENTIFIER_BINDING (id);
371 INHERITED_VALUE_BINDING_P (binding) = 0;
372 LOCAL_BINDING_P (binding) = (level != class_binding_level);
374 /* And put it on the front of the list of bindings for ID. */
375 IDENTIFIER_BINDING (id) = binding;
378 /* Remove the binding for DECL which should be the innermost binding
382 pop_binding (tree id, tree decl)
384 cxx_binding *binding;
387 /* It's easiest to write the loops that call this function without
388 checking whether or not the entities involved have names. We
389 get here for such an entity. */
392 /* Get the innermost binding for ID. */
393 binding = IDENTIFIER_BINDING (id);
395 /* The name should be bound. */
396 gcc_assert (binding != NULL);
398 /* The DECL will be either the ordinary binding or the type
399 binding for this identifier. Remove that binding. */
400 if (binding->value == decl)
401 binding->value = NULL_TREE;
404 gcc_assert (binding->type == decl);
405 binding->type = NULL_TREE;
408 if (!binding->value && !binding->type)
410 /* We're completely done with the innermost binding for this
411 identifier. Unhook it from the list of bindings. */
412 IDENTIFIER_BINDING (id) = binding->previous;
414 /* Add it to the free list. */
415 cxx_binding_free (binding);
419 /* BINDING records an existing declaration for a name in the current scope.
420 But, DECL is another declaration for that same identifier in the
421 same scope. This is the `struct stat' hack whereby a non-typedef
422 class name or enum-name can be bound at the same level as some other
426 A class name (9.1) or enumeration name (7.2) can be hidden by the
427 name of an object, function, or enumerator declared in the same scope.
428 If a class or enumeration name and an object, function, or enumerator
429 are declared in the same scope (in any order) with the same name, the
430 class or enumeration name is hidden wherever the object, function, or
431 enumerator name is visible.
433 It's the responsibility of the caller to check that
434 inserting this name is valid here. Returns nonzero if the new binding
438 supplement_binding (cxx_binding *binding, tree decl)
440 tree bval = binding->value;
443 timevar_push (TV_NAME_LOOKUP);
444 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
445 /* The new name is the type name. */
446 binding->type = decl;
447 else if (/* BVAL is null when push_class_level_binding moves an
448 inherited type-binding out of the way to make room for a
449 new value binding. */
451 /* BVAL is error_mark_node when DECL's name has been used
452 in a non-class scope prior declaration. In that case,
453 we should have already issued a diagnostic; for graceful
454 error recovery purpose, pretend this was the intended
455 declaration for that name. */
456 || bval == error_mark_node
457 /* If BVAL is anticipated but has not yet been declared,
458 pretend it is not there at all. */
459 || (TREE_CODE (bval) == FUNCTION_DECL
460 && DECL_ANTICIPATED (bval)
461 && !DECL_HIDDEN_FRIEND_P (bval)))
462 binding->value = decl;
463 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
465 /* The old binding was a type name. It was placed in
466 VALUE field because it was thought, at the point it was
467 declared, to be the only entity with such a name. Move the
468 type name into the type slot; it is now hidden by the new
470 binding->type = bval;
471 binding->value = decl;
472 binding->value_is_inherited = false;
474 else if (TREE_CODE (bval) == TYPE_DECL
475 && TREE_CODE (decl) == TYPE_DECL
476 && DECL_NAME (decl) == DECL_NAME (bval)
477 && binding->scope->kind != sk_class
478 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
479 /* If either type involves template parameters, we must
480 wait until instantiation. */
481 || uses_template_parms (TREE_TYPE (decl))
482 || uses_template_parms (TREE_TYPE (bval))))
483 /* We have two typedef-names, both naming the same type to have
484 the same name. In general, this is OK because of:
488 In a given scope, a typedef specifier can be used to redefine
489 the name of any type declared in that scope to refer to the
490 type to which it already refers.
492 However, in class scopes, this rule does not apply due to the
493 stricter language in [class.mem] prohibiting redeclarations of
496 /* There can be two block-scope declarations of the same variable,
497 so long as they are `extern' declarations. However, there cannot
498 be two declarations of the same static data member:
502 A member shall not be declared twice in the
503 member-specification. */
504 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
505 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
506 && !DECL_CLASS_SCOPE_P (decl))
508 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
511 else if (TREE_CODE (decl) == NAMESPACE_DECL
512 && TREE_CODE (bval) == NAMESPACE_DECL
513 && DECL_NAMESPACE_ALIAS (decl)
514 && DECL_NAMESPACE_ALIAS (bval)
515 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
518 In a declarative region, a namespace-alias-definition can be
519 used to redefine a namespace-alias declared in that declarative
520 region to refer only to the namespace to which it already
525 error ("declaration of %q#D", decl);
526 error ("conflicts with previous declaration %q+#D", bval);
530 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
533 /* Add DECL to the list of things declared in B. */
536 add_decl_to_level (tree decl, cxx_scope *b)
538 /* We used to record virtual tables as if they were ordinary
539 variables, but no longer do so. */
540 gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
542 if (TREE_CODE (decl) == NAMESPACE_DECL
543 && !DECL_NAMESPACE_ALIAS (decl))
545 TREE_CHAIN (decl) = b->namespaces;
546 b->namespaces = decl;
550 /* We build up the list in reverse order, and reverse it later if
552 TREE_CHAIN (decl) = b->names;
556 /* If appropriate, add decl to separate list of statics. We
557 include extern variables because they might turn out to be
558 static later. It's OK for this list to contain a few false
560 if (b->kind == sk_namespace)
561 if ((TREE_CODE (decl) == VAR_DECL
562 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
563 || (TREE_CODE (decl) == FUNCTION_DECL
564 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
565 VEC_safe_push (tree, gc, b->static_decls, decl);
569 /* Record a decl-node X as belonging to the current lexical scope.
570 Check for errors (such as an incompatible declaration for the same
571 name already seen in the same scope). IS_FRIEND is true if X is
572 declared as a friend.
574 Returns either X or an old decl for the same name.
575 If an old decl is returned, it may have been smashed
576 to agree with what X says. */
579 pushdecl_maybe_friend (tree x, bool is_friend)
583 int need_new_binding;
585 timevar_push (TV_NAME_LOOKUP);
587 if (x == error_mark_node)
588 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
590 need_new_binding = 1;
592 if (DECL_TEMPLATE_PARM_P (x))
593 /* Template parameters have no context; they are not X::T even
594 when declared within a class or namespace. */
598 if (current_function_decl && x != current_function_decl
599 /* A local declaration for a function doesn't constitute
601 && TREE_CODE (x) != FUNCTION_DECL
602 /* A local declaration for an `extern' variable is in the
603 scope of the current namespace, not the current
605 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
606 /* When parsing the parameter list of a function declarator,
607 don't set DECL_CONTEXT to an enclosing function. When we
608 push the PARM_DECLs in order to process the function body,
609 current_binding_level->this_entity will be set. */
610 && !(TREE_CODE (x) == PARM_DECL
611 && current_binding_level->kind == sk_function_parms
612 && current_binding_level->this_entity == NULL)
613 && !DECL_CONTEXT (x))
614 DECL_CONTEXT (x) = current_function_decl;
616 /* If this is the declaration for a namespace-scope function,
617 but the declaration itself is in a local scope, mark the
619 if (TREE_CODE (x) == FUNCTION_DECL
620 && DECL_NAMESPACE_SCOPE_P (x)
621 && current_function_decl
622 && x != current_function_decl)
623 DECL_LOCAL_FUNCTION_P (x) = 1;
626 name = DECL_NAME (x);
629 int different_binding_level = 0;
631 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
632 name = TREE_OPERAND (name, 0);
634 /* In case this decl was explicitly namespace-qualified, look it
635 up in its namespace context. */
636 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
637 t = namespace_binding (name, DECL_CONTEXT (x));
639 t = lookup_name_innermost_nonclass_level (name);
641 /* [basic.link] If there is a visible declaration of an entity
642 with linkage having the same name and type, ignoring entities
643 declared outside the innermost enclosing namespace scope, the
644 block scope declaration declares that same entity and
645 receives the linkage of the previous declaration. */
646 if (! t && current_function_decl && x != current_function_decl
647 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
648 && DECL_EXTERNAL (x))
650 /* Look in block scope. */
651 t = innermost_non_namespace_value (name);
652 /* Or in the innermost namespace. */
654 t = namespace_binding (name, DECL_CONTEXT (x));
655 /* Does it have linkage? Note that if this isn't a DECL, it's an
656 OVERLOAD, which is OK. */
657 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
660 different_binding_level = 1;
663 /* If we are declaring a function, and the result of name-lookup
664 was an OVERLOAD, look for an overloaded instance that is
665 actually the same as the function we are declaring. (If
666 there is one, we have to merge our declaration with the
667 previous declaration.) */
668 if (t && TREE_CODE (t) == OVERLOAD)
672 if (TREE_CODE (x) == FUNCTION_DECL)
673 for (match = t; match; match = OVL_NEXT (match))
675 if (decls_match (OVL_CURRENT (match), x))
679 /* Just choose one. */
683 t = OVL_CURRENT (match);
688 if (t && t != error_mark_node)
690 if (different_binding_level)
692 if (decls_match (x, t))
693 /* The standard only says that the local extern
694 inherits linkage from the previous decl; in
695 particular, default args are not shared. Add
696 the decl into a hash table to make sure only
697 the previous decl in this case is seen by the
700 struct cxx_int_tree_map *h;
703 TREE_PUBLIC (x) = TREE_PUBLIC (t);
705 if (cp_function_chain->extern_decl_map == NULL)
706 cp_function_chain->extern_decl_map
707 = htab_create_ggc (20, cxx_int_tree_map_hash,
708 cxx_int_tree_map_eq, NULL);
710 h = GGC_NEW (struct cxx_int_tree_map);
711 h->uid = DECL_UID (x);
713 loc = htab_find_slot_with_hash
714 (cp_function_chain->extern_decl_map, h,
716 *(struct cxx_int_tree_map **) loc = h;
719 else if (TREE_CODE (t) == PARM_DECL)
721 /* Check for duplicate params. */
722 tree d = duplicate_decls (x, t, is_friend);
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
726 else if ((DECL_EXTERN_C_FUNCTION_P (x)
727 || DECL_FUNCTION_TEMPLATE_P (x))
728 && is_overloaded_fn (t))
729 /* Don't do anything just yet. */;
730 else if (t == wchar_decl_node)
732 if (! DECL_IN_SYSTEM_HEADER (x))
733 pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
736 /* Throw away the redeclaration. */
737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
741 tree olddecl = duplicate_decls (x, t, is_friend);
743 /* If the redeclaration failed, we can stop at this
745 if (olddecl == error_mark_node)
746 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
750 if (TREE_CODE (t) == TYPE_DECL)
751 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
753 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
755 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
757 /* A redeclaration of main, but not a duplicate of the
762 This function shall not be overloaded. */
763 error ("invalid redeclaration of %q+D", t);
765 /* We don't try to push this declaration since that
767 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
772 /* If x has C linkage-specification, (extern "C"),
773 lookup its binding, in case it's already bound to an object.
774 The lookup is done in all namespaces.
775 If we find an existing binding, make sure it has the same
776 exception specification as x, otherwise, bail in error [7.5, 7.6]. */
777 if ((TREE_CODE (x) == FUNCTION_DECL)
778 && DECL_EXTERN_C_P (x)
779 /* We should ignore declarations happening in system headers. */
780 && !DECL_ARTIFICIAL (x)
781 && !DECL_IN_SYSTEM_HEADER (x))
783 cxx_binding *function_binding =
784 lookup_extern_c_fun_binding_in_all_ns (x);
785 tree previous = (function_binding
786 ? function_binding->value
789 && !DECL_ARTIFICIAL (previous)
790 && !DECL_IN_SYSTEM_HEADER (previous)
791 && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
793 tree previous = function_binding->value;
795 /* In case either x or previous is declared to throw an exception,
796 make sure both exception specifications are equal. */
797 if (decls_match (x, previous))
799 tree x_exception_spec = NULL_TREE;
800 tree previous_exception_spec = NULL_TREE;
803 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
804 previous_exception_spec =
805 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
806 if (!comp_except_specs (previous_exception_spec,
810 pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
812 pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
814 pedwarn (input_location, 0, "due to different exception specifications");
815 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
820 pedwarn (input_location, 0,
821 "declaration of %q#D with C language linkage", x);
822 pedwarn (input_location, 0,
823 "conflicts with previous declaration %q+#D",
829 check_template_shadow (x);
831 /* If this is a function conjured up by the back end, massage it
832 so it looks friendly. */
833 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
835 retrofit_lang_decl (x);
836 SET_DECL_LANGUAGE (x, lang_c);
840 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
842 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
843 if (!namespace_bindings_p ())
844 /* We do not need to create a binding for this name;
845 push_overloaded_decl will have already done so if
847 need_new_binding = 0;
849 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
851 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
853 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
856 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
857 check_default_args (x);
859 if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
862 /* If declaring a type as a typedef, copy the type (unless we're
863 at line 0), and install this TYPE_DECL as the new type's typedef
864 name. See the extensive comment of set_underlying_type (). */
865 if (TREE_CODE (x) == TYPE_DECL)
867 tree type = TREE_TYPE (x);
869 if (DECL_IS_BUILTIN (x)
870 || (TREE_TYPE (x) != error_mark_node
871 && TYPE_NAME (type) != x
872 /* We don't want to copy the type when all we're
873 doing is making a TYPE_DECL for the purposes of
875 && (!TYPE_NAME (type)
876 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
877 set_underlying_type (x);
879 if (type != error_mark_node
881 && TYPE_IDENTIFIER (type))
882 set_identifier_type_value (DECL_NAME (x), x);
885 /* Multiple external decls of the same identifier ought to match.
887 We get warnings about inline functions where they are defined.
888 We get warnings about other functions from push_overloaded_decl.
890 Avoid duplicate warnings where they are used. */
891 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
895 decl = IDENTIFIER_NAMESPACE_VALUE (name);
896 if (decl && TREE_CODE (decl) == OVERLOAD)
897 decl = OVL_FUNCTION (decl);
899 if (decl && decl != error_mark_node
900 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
901 /* If different sort of thing, we already gave an error. */
902 && TREE_CODE (decl) == TREE_CODE (x)
903 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
905 permerror (input_location, "type mismatch with previous external decl of %q#D", x);
906 permerror (input_location, "previous external decl of %q+#D", decl);
910 if (TREE_CODE (x) == FUNCTION_DECL
912 && !flag_friend_injection)
914 /* This is a new declaration of a friend function, so hide
915 it from ordinary function lookup. */
916 DECL_ANTICIPATED (x) = 1;
917 DECL_HIDDEN_FRIEND_P (x) = 1;
920 /* This name is new in its binding level.
921 Install the new declaration and return it. */
922 if (namespace_bindings_p ())
924 /* Install a global value. */
926 /* If the first global decl has external linkage,
927 warn if we later see static one. */
928 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
929 TREE_PUBLIC (name) = 1;
931 /* Bind the name for the entity. */
932 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
934 && (TREE_CODE (x) == TYPE_DECL
935 || TREE_CODE (x) == VAR_DECL
936 || TREE_CODE (x) == NAMESPACE_DECL
937 || TREE_CODE (x) == CONST_DECL
938 || TREE_CODE (x) == TEMPLATE_DECL))
939 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
941 /* If new decl is `static' and an `extern' was seen previously,
943 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
944 warn_extern_redeclared_static (x, t);
948 /* Here to install a non-global value. */
949 tree oldlocal = innermost_non_namespace_value (name);
950 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
952 if (need_new_binding)
954 push_local_binding (name, x, 0);
955 /* Because push_local_binding will hook X on to the
956 current_binding_level's name list, we don't want to
957 do that again below. */
958 need_new_binding = 0;
961 /* If this is a TYPE_DECL, push it into the type value slot. */
962 if (TREE_CODE (x) == TYPE_DECL)
963 set_identifier_type_value (name, x);
965 /* Clear out any TYPE_DECL shadowed by a namespace so that
966 we won't think this is a type. The C struct hack doesn't
967 go through namespaces. */
968 if (TREE_CODE (x) == NAMESPACE_DECL)
969 set_identifier_type_value (name, NULL_TREE);
976 && TREE_CODE (oldlocal) == VAR_DECL
977 && DECL_DEAD_FOR_LOCAL (oldlocal))
978 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
980 if (oldlocal == NULL_TREE)
981 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
984 /* If this is an extern function declaration, see if we
985 have a global definition or declaration for the function. */
986 if (oldlocal == NULL_TREE
988 && oldglobal != NULL_TREE
989 && TREE_CODE (x) == FUNCTION_DECL
990 && TREE_CODE (oldglobal) == FUNCTION_DECL)
992 /* We have one. Their types must agree. */
993 if (decls_match (x, oldglobal))
997 warning (0, "extern declaration of %q#D doesn't match", x);
998 warning (0, "global declaration %q+#D", oldglobal);
1001 /* If we have a local external declaration,
1002 and no file-scope declaration has yet been seen,
1003 then if we later have a file-scope decl it must not be static. */
1004 if (oldlocal == NULL_TREE
1005 && oldglobal == NULL_TREE
1006 && DECL_EXTERNAL (x)
1008 TREE_PUBLIC (name) = 1;
1010 /* Don't complain about the parms we push and then pop
1011 while tentatively parsing a function declarator. */
1012 if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1015 /* Warn if shadowing an argument at the top level of the body. */
1016 else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1017 /* Inline decls shadow nothing. */
1018 && !DECL_FROM_INLINE (x)
1019 && TREE_CODE (oldlocal) == PARM_DECL
1020 /* Don't check the `this' parameter. */
1021 && !DECL_ARTIFICIAL (oldlocal))
1025 /* Don't complain if it's from an enclosing function. */
1026 if (DECL_CONTEXT (oldlocal) == current_function_decl
1027 && TREE_CODE (x) != PARM_DECL)
1029 /* Go to where the parms should be and see if we find
1031 struct cp_binding_level *b = current_binding_level->level_chain;
1033 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1034 /* Skip the ctor/dtor cleanup level. */
1038 if (b->kind == sk_function_parms)
1040 error ("declaration of %q#D shadows a parameter", x);
1045 if (warn_shadow && !err)
1047 warning_at (input_location, OPT_Wshadow,
1048 "declaration of %q#D shadows a parameter", x);
1049 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1050 "shadowed declaration is here");
1054 /* Maybe warn if shadowing something else. */
1055 else if (warn_shadow && !DECL_EXTERNAL (x)
1056 /* No shadow warnings for internally generated vars. */
1057 && ! DECL_ARTIFICIAL (x)
1058 /* No shadow warnings for vars made for inlining. */
1059 && ! DECL_FROM_INLINE (x))
1063 if (current_class_ptr)
1064 member = lookup_member (current_class_type,
1067 /*want_type=*/false);
1071 if (member && !TREE_STATIC (member))
1073 /* Location of previous decl is not useful in this case. */
1074 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1077 else if (oldlocal != NULL_TREE
1078 && TREE_CODE (oldlocal) == VAR_DECL)
1080 warning_at (input_location, OPT_Wshadow,
1081 "declaration of %qD shadows a previous local", x);
1082 warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1083 "shadowed declaration is here");
1085 else if (oldglobal != NULL_TREE
1086 && TREE_CODE (oldglobal) == VAR_DECL)
1087 /* XXX shadow warnings in outer-more namespaces */
1089 warning_at (input_location, OPT_Wshadow,
1090 "declaration of %qD shadows a global declaration", x);
1091 warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1092 "shadowed declaration is here");
1097 if (TREE_CODE (x) == VAR_DECL)
1098 maybe_register_incomplete_var (x);
1101 if (need_new_binding)
1102 add_decl_to_level (x,
1103 DECL_NAMESPACE_SCOPE_P (x)
1104 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1105 : current_binding_level);
1107 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1110 /* Record a decl-node X as belonging to the current lexical scope. */
1115 return pushdecl_maybe_friend (x, false);
1118 /* Enter DECL into the symbol table, if that's appropriate. Returns
1119 DECL, or a modified version thereof. */
1122 maybe_push_decl (tree decl)
1124 tree type = TREE_TYPE (decl);
1126 /* Add this decl to the current binding level, but not if it comes
1127 from another scope, e.g. a static member variable. TEM may equal
1128 DECL or it may be a previous decl of the same name. */
1129 if (decl == error_mark_node
1130 || (TREE_CODE (decl) != PARM_DECL
1131 && DECL_CONTEXT (decl) != NULL_TREE
1132 /* Definitions of namespace members outside their namespace are
1134 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1135 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1136 || TREE_CODE (type) == UNKNOWN_TYPE
1137 /* The declaration of a template specialization does not affect
1138 the functions available for overload resolution, so we do not
1140 || (TREE_CODE (decl) == FUNCTION_DECL
1141 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1144 return pushdecl (decl);
1147 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1148 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1149 doesn't really belong to this binding level, that it got here
1150 through a using-declaration. */
1153 push_local_binding (tree id, tree decl, int flags)
1155 struct cp_binding_level *b;
1157 /* Skip over any local classes. This makes sense if we call
1158 push_local_binding with a friend decl of a local class. */
1159 b = innermost_nonclass_level ();
1161 if (lookup_name_innermost_nonclass_level (id))
1163 /* Supplement the existing binding. */
1164 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1165 /* It didn't work. Something else must be bound at this
1166 level. Do not add DECL to the list of things to pop
1171 /* Create a new binding. */
1172 push_binding (id, decl, b);
1174 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1175 /* We must put the OVERLOAD into a TREE_LIST since the
1176 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1177 decls that got here through a using-declaration. */
1178 decl = build_tree_list (NULL_TREE, decl);
1180 /* And put DECL on the list of things declared by the current
1182 add_decl_to_level (decl, b);
1185 /* Check to see whether or not DECL is a variable that would have been
1186 in scope under the ARM, but is not in scope under the ANSI/ISO
1187 standard. If so, issue an error message. If name lookup would
1188 work in both cases, but return a different result, this function
1189 returns the result of ANSI/ISO lookup. Otherwise, it returns
1193 check_for_out_of_scope_variable (tree decl)
1197 /* We only care about out of scope variables. */
1198 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1201 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1202 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1203 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1204 && DECL_DEAD_FOR_LOCAL (shadowed))
1205 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1206 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1208 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1211 if (!DECL_ERROR_REPORTED (decl))
1213 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1214 warning (0, " matches this %q+D under ISO standard rules",
1216 warning (0, " matches this %q+D under old rules", decl);
1217 DECL_ERROR_REPORTED (decl) = 1;
1222 /* If we have already complained about this declaration, there's no
1223 need to do it again. */
1224 if (DECL_ERROR_REPORTED (decl))
1227 DECL_ERROR_REPORTED (decl) = 1;
1229 if (TREE_TYPE (decl) == error_mark_node)
1232 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1234 error ("name lookup of %qD changed for ISO %<for%> scoping",
1236 error (" cannot use obsolete binding at %q+D because "
1237 "it has a destructor", decl);
1238 return error_mark_node;
1242 permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1244 if (flag_permissive)
1245 permerror (input_location, " using obsolete binding at %q+D", decl);
1251 inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1260 /* true means unconditionally make a BLOCK for the next level pushed. */
1262 static bool keep_next_level_flag;
1264 static int binding_depth = 0;
1265 static int is_class_level = 0;
1272 for (i = 0; i < depth * 2; i++)
1276 /* Return a string describing the kind of SCOPE we have. */
1278 cxx_scope_descriptor (cxx_scope *scope)
1280 /* The order of this table must match the "scope_kind"
1282 static const char* scope_kind_names[] = {
1288 "function-parameter-scope",
1291 "template-parameter-scope",
1292 "template-explicit-spec-scope"
1294 const scope_kind kind = scope->explicit_spec_p
1295 ? sk_template_spec : scope->kind;
1297 return scope_kind_names[kind];
1300 /* Output a debugging information about SCOPE when performing
1303 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1305 const char *desc = cxx_scope_descriptor (scope);
1306 if (scope->this_entity)
1307 verbatim ("%s %s(%E) %p %d\n", action, desc,
1308 scope->this_entity, (void *) scope, line);
1310 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1313 /* Return the estimated initial size of the hashtable of a NAMESPACE
1316 static inline size_t
1317 namespace_scope_ht_size (tree ns)
1319 tree name = DECL_NAME (ns);
1321 return name == std_identifier
1322 ? NAMESPACE_STD_HT_SIZE
1323 : (name == global_scope_name
1324 ? GLOBAL_SCOPE_HT_SIZE
1325 : NAMESPACE_ORDINARY_HT_SIZE);
1328 /* A chain of binding_level structures awaiting reuse. */
1330 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1332 /* Insert SCOPE as the innermost binding level. */
1335 push_binding_level (struct cp_binding_level *scope)
1337 /* Add it to the front of currently active scopes stack. */
1338 scope->level_chain = current_binding_level;
1339 current_binding_level = scope;
1340 keep_next_level_flag = false;
1342 if (ENABLE_SCOPE_CHECKING)
1344 scope->binding_depth = binding_depth;
1345 indent (binding_depth);
1346 cxx_scope_debug (scope, input_line, "push");
1352 /* Create a new KIND scope and make it the top of the active scopes stack.
1353 ENTITY is the scope of the associated C++ entity (namespace, class,
1354 function, C++0x enumeration); it is NULL otherwise. */
1357 begin_scope (scope_kind kind, tree entity)
1361 /* Reuse or create a struct for this binding level. */
1362 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1364 scope = free_binding_level;
1365 memset (scope, 0, sizeof (cxx_scope));
1366 free_binding_level = scope->level_chain;
1369 scope = GGC_CNEW (cxx_scope);
1371 scope->this_entity = entity;
1372 scope->more_cleanups_ok = true;
1379 case sk_template_spec:
1380 scope->explicit_spec_p = true;
1381 kind = sk_template_parms;
1383 case sk_template_parms:
1389 case sk_scoped_enum:
1390 case sk_function_parms:
1392 scope->keep = keep_next_level_flag;
1396 NAMESPACE_LEVEL (entity) = scope;
1397 scope->static_decls =
1398 VEC_alloc (tree, gc,
1399 DECL_NAME (entity) == std_identifier
1400 || DECL_NAME (entity) == global_scope_name
1405 /* Should not happen. */
1411 push_binding_level (scope);
1416 /* We're about to leave current scope. Pop the top of the stack of
1417 currently active scopes. Return the enclosing scope, now active. */
1422 cxx_scope *scope = current_binding_level;
1424 if (scope->kind == sk_namespace && class_binding_level)
1425 current_binding_level = class_binding_level;
1427 /* We cannot leave a scope, if there are none left. */
1428 if (NAMESPACE_LEVEL (global_namespace))
1429 gcc_assert (!global_scope_p (scope));
1431 if (ENABLE_SCOPE_CHECKING)
1433 indent (--binding_depth);
1434 cxx_scope_debug (scope, input_line, "leave");
1435 if (is_class_level != (scope == class_binding_level))
1437 indent (binding_depth);
1438 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1443 /* Move one nesting level up. */
1444 current_binding_level = scope->level_chain;
1446 /* Namespace-scopes are left most probably temporarily, not
1447 completely; they can be reopened later, e.g. in namespace-extension
1448 or any name binding activity that requires us to resume a
1449 namespace. For classes, we cache some binding levels. For other
1450 scopes, we just make the structure available for reuse. */
1451 if (scope->kind != sk_namespace
1452 && scope->kind != sk_class)
1454 scope->level_chain = free_binding_level;
1455 gcc_assert (!ENABLE_SCOPE_CHECKING
1456 || scope->binding_depth == binding_depth);
1457 free_binding_level = scope;
1460 /* Find the innermost enclosing class scope, and reset
1461 CLASS_BINDING_LEVEL appropriately. */
1462 if (scope->kind == sk_class)
1464 class_binding_level = NULL;
1465 for (scope = current_binding_level; scope; scope = scope->level_chain)
1466 if (scope->kind == sk_class)
1468 class_binding_level = scope;
1473 return current_binding_level;
1477 resume_scope (struct cp_binding_level* b)
1479 /* Resuming binding levels is meant only for namespaces,
1480 and those cannot nest into classes. */
1481 gcc_assert (!class_binding_level);
1482 /* Also, resuming a non-directly nested namespace is a no-no. */
1483 gcc_assert (b->level_chain == current_binding_level);
1484 current_binding_level = b;
1485 if (ENABLE_SCOPE_CHECKING)
1487 b->binding_depth = binding_depth;
1488 indent (binding_depth);
1489 cxx_scope_debug (b, input_line, "resume");
1495 /* Return the innermost binding level that is not for a class scope. */
1498 innermost_nonclass_level (void)
1502 b = current_binding_level;
1503 while (b->kind == sk_class)
1509 /* We're defining an object of type TYPE. If it needs a cleanup, but
1510 we're not allowed to add any more objects with cleanups to the current
1511 scope, create a new binding level. */
1514 maybe_push_cleanup_level (tree type)
1516 if (type != error_mark_node
1517 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1518 && current_binding_level->more_cleanups_ok == 0)
1520 begin_scope (sk_cleanup, NULL);
1521 current_binding_level->statement_list = push_stmt_list ();
1525 /* Nonzero if we are currently in the global binding level. */
1528 global_bindings_p (void)
1530 return global_scope_p (current_binding_level);
1533 /* True if we are currently in a toplevel binding level. This
1534 means either the global binding level or a namespace in a toplevel
1535 binding level. Since there are no non-toplevel namespace levels,
1536 this really means any namespace or template parameter level. We
1537 also include a class whose context is toplevel. */
1540 toplevel_bindings_p (void)
1542 struct cp_binding_level *b = innermost_nonclass_level ();
1544 return b->kind == sk_namespace || b->kind == sk_template_parms;
1547 /* True if this is a namespace scope, or if we are defining a class
1548 which is itself at namespace scope, or whose enclosing class is
1549 such a class, etc. */
1552 namespace_bindings_p (void)
1554 struct cp_binding_level *b = innermost_nonclass_level ();
1556 return b->kind == sk_namespace;
1559 /* True if the current level needs to have a BLOCK made. */
1564 return (current_binding_level->blocks != NULL_TREE
1565 || current_binding_level->keep
1566 || current_binding_level->kind == sk_cleanup
1567 || current_binding_level->names != NULL_TREE
1568 || current_binding_level->using_directives);
1571 /* Returns the kind of the innermost scope. */
1574 innermost_scope_kind (void)
1576 return current_binding_level->kind;
1579 /* Returns true if this scope was created to store template parameters. */
1582 template_parm_scope_p (void)
1584 return innermost_scope_kind () == sk_template_parms;
1587 /* If KEEP is true, make a BLOCK node for the next binding level,
1588 unconditionally. Otherwise, use the normal logic to decide whether
1589 or not to create a BLOCK. */
1592 keep_next_level (bool keep)
1594 keep_next_level_flag = keep;
1597 /* Return the list of declarations of the current level.
1598 Note that this list is in reverse order unless/until
1599 you nreverse it; and when you do nreverse it, you must
1600 store the result back using `storedecls' or you will lose. */
1605 return current_binding_level->names;
1608 /* For debugging. */
1609 static int no_print_functions = 0;
1610 static int no_print_builtins = 0;
1613 print_binding_level (struct cp_binding_level* lvl)
1617 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1618 if (lvl->more_cleanups_ok)
1619 fprintf (stderr, " more-cleanups-ok");
1620 if (lvl->have_cleanups)
1621 fprintf (stderr, " have-cleanups");
1622 fprintf (stderr, "\n");
1625 fprintf (stderr, " names:\t");
1626 /* We can probably fit 3 names to a line? */
1627 for (t = lvl->names; t; t = TREE_CHAIN (t))
1629 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1631 if (no_print_builtins
1632 && (TREE_CODE (t) == TYPE_DECL)
1633 && DECL_IS_BUILTIN (t))
1636 /* Function decls tend to have longer names. */
1637 if (TREE_CODE (t) == FUNCTION_DECL)
1644 fprintf (stderr, "\n\t");
1647 print_node_brief (stderr, "", t, 0);
1648 if (t == error_mark_node)
1652 fprintf (stderr, "\n");
1654 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1657 cp_class_binding *b;
1658 fprintf (stderr, " class-shadowed:");
1660 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1662 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1663 fprintf (stderr, "\n");
1665 if (lvl->type_shadowed)
1667 fprintf (stderr, " type-shadowed:");
1668 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1670 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1672 fprintf (stderr, "\n");
1677 print_other_binding_stack (struct cp_binding_level *stack)
1679 struct cp_binding_level *level;
1680 for (level = stack; !global_scope_p (level); level = level->level_chain)
1682 fprintf (stderr, "binding level %p\n", (void *) level);
1683 print_binding_level (level);
1688 print_binding_stack (void)
1690 struct cp_binding_level *b;
1691 fprintf (stderr, "current_binding_level=%p\n"
1692 "class_binding_level=%p\n"
1693 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1694 (void *) current_binding_level, (void *) class_binding_level,
1695 (void *) NAMESPACE_LEVEL (global_namespace));
1696 if (class_binding_level)
1698 for (b = class_binding_level; b; b = b->level_chain)
1699 if (b == current_binding_level)
1702 b = class_binding_level;
1704 b = current_binding_level;
1707 b = current_binding_level;
1708 print_other_binding_stack (b);
1709 fprintf (stderr, "global:\n");
1710 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1713 /* Return the type associated with id. */
1716 identifier_type_value (tree id)
1718 timevar_push (TV_NAME_LOOKUP);
1719 /* There is no type with that name, anywhere. */
1720 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1721 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1722 /* This is not the type marker, but the real thing. */
1723 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1725 /* Have to search for it. It must be on the global level, now.
1726 Ask lookup_name not to return non-types. */
1727 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1729 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1733 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1734 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1737 identifier_global_value (tree t)
1739 return IDENTIFIER_GLOBAL_VALUE (t);
1742 /* Push a definition of struct, union or enum tag named ID. into
1743 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1744 the tag ID is not already defined. */
1747 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1751 if (b->kind != sk_namespace)
1753 /* Shadow the marker, not the real thing, so that the marker
1754 gets restored later. */
1755 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1757 = tree_cons (id, old_type_value, b->type_shadowed);
1758 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1759 TREE_TYPE (b->type_shadowed) = type;
1763 cxx_binding *binding =
1764 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1767 supplement_binding (binding, decl);
1769 binding->value = decl;
1771 /* Store marker instead of real type. */
1772 type = global_type_node;
1774 SET_IDENTIFIER_TYPE_VALUE (id, type);
1777 /* As set_identifier_type_value_with_scope, but using
1778 current_binding_level. */
1781 set_identifier_type_value (tree id, tree decl)
1783 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1786 /* Return the name for the constructor (or destructor) for the
1787 specified class TYPE. When given a template, this routine doesn't
1788 lose the specialization. */
1791 constructor_name_full (tree type)
1793 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1796 /* Return the name for the constructor (or destructor) for the
1797 specified class. When given a template, return the plain
1798 unspecialized name. */
1801 constructor_name (tree type)
1804 name = constructor_name_full (type);
1805 if (IDENTIFIER_TEMPLATE (name))
1806 name = IDENTIFIER_TEMPLATE (name);
1810 /* Returns TRUE if NAME is the name for the constructor for TYPE,
1811 which must be a class type. */
1814 constructor_name_p (tree name, tree type)
1818 gcc_assert (MAYBE_CLASS_TYPE_P (type));
1823 if (TREE_CODE (name) != IDENTIFIER_NODE)
1826 ctor_name = constructor_name_full (type);
1827 if (name == ctor_name)
1829 if (IDENTIFIER_TEMPLATE (ctor_name)
1830 && name == IDENTIFIER_TEMPLATE (ctor_name))
1835 /* Counter used to create anonymous type names. */
1837 static GTY(()) int anon_cnt;
1839 /* Return an IDENTIFIER which can be used as a name for
1840 anonymous structs and unions. */
1843 make_anon_name (void)
1847 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1848 return get_identifier (buf);
1851 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1853 static inline cxx_binding *
1854 find_binding (cxx_scope *scope, cxx_binding *binding)
1856 timevar_push (TV_NAME_LOOKUP);
1858 for (; binding != NULL; binding = binding->previous)
1859 if (binding->scope == scope)
1860 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1862 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1865 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1867 static inline cxx_binding *
1868 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1870 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1873 /* Fold-in case where NAME is used only once. */
1874 if (scope == b->scope && b->previous == NULL)
1876 return find_binding (scope, b);
1881 /* Always returns a binding for name in scope. If no binding is
1882 found, make a new one. */
1884 static cxx_binding *
1885 binding_for_name (cxx_scope *scope, tree name)
1887 cxx_binding *result;
1889 result = cxx_scope_find_binding_for_name (scope, name);
1892 /* Not found, make a new one. */
1893 result = cxx_binding_make (NULL, NULL);
1894 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1895 result->scope = scope;
1896 result->is_local = false;
1897 result->value_is_inherited = false;
1898 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1902 /* Walk through the bindings associated to the name of FUNCTION,
1903 and return the first binding that declares a function with a
1904 "C" linkage specification, a.k.a 'extern "C"'.
1905 This function looks for the binding, regardless of which scope it
1906 has been defined in. It basically looks in all the known scopes.
1907 Note that this function does not lookup for bindings of builtin functions
1908 or for functions declared in system headers. */
1910 lookup_extern_c_fun_binding_in_all_ns (tree function)
1915 gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1917 name = DECL_NAME (function);
1918 gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1920 for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1922 iter = iter->previous)
1925 && TREE_CODE (iter->value) == FUNCTION_DECL
1926 && DECL_EXTERN_C_P (iter->value)
1927 && !DECL_ARTIFICIAL (iter->value))
1935 /* Insert another USING_DECL into the current binding level, returning
1936 this declaration. If this is a redeclaration, do nothing, and
1937 return NULL_TREE if this not in namespace scope (in namespace
1938 scope, a using decl might extend any previous bindings). */
1941 push_using_decl (tree scope, tree name)
1945 timevar_push (TV_NAME_LOOKUP);
1946 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1947 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1948 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1949 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1952 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1953 namespace_bindings_p () ? decl : NULL_TREE);
1954 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1955 USING_DECL_SCOPE (decl) = scope;
1956 TREE_CHAIN (decl) = current_binding_level->usings;
1957 current_binding_level->usings = decl;
1958 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1961 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1962 caller to set DECL_CONTEXT properly. */
1965 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1967 struct cp_binding_level *b;
1968 tree function_decl = current_function_decl;
1970 timevar_push (TV_NAME_LOOKUP);
1971 current_function_decl = NULL_TREE;
1972 if (level->kind == sk_class)
1974 b = class_binding_level;
1975 class_binding_level = level;
1976 pushdecl_class_level (x);
1977 class_binding_level = b;
1981 b = current_binding_level;
1982 current_binding_level = level;
1983 x = pushdecl_maybe_friend (x, is_friend);
1984 current_binding_level = b;
1986 current_function_decl = function_decl;
1987 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1990 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1991 other definitions already in place. We get around this by making
1992 the value of the identifier point to a list of all the things that
1993 want to be referenced by that name. It is then up to the users of
1994 that name to decide what to do with that list.
1996 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1997 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1999 FLAGS is a bitwise-or of the following values:
2000 PUSH_LOCAL: Bind DECL in the current scope, rather than at
2002 PUSH_USING: DECL is being pushed as the result of a using
2005 IS_FRIEND is true if this is a friend declaration.
2007 The value returned may be a previous declaration if we guessed wrong
2008 about what language DECL should belong to (C or C++). Otherwise,
2009 it's always DECL (and never something that's not a _DECL). */
2012 push_overloaded_decl (tree decl, int flags, bool is_friend)
2014 tree name = DECL_NAME (decl);
2017 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2019 timevar_push (TV_NAME_LOOKUP);
2021 old = namespace_binding (name, DECL_CONTEXT (decl));
2023 old = lookup_name_innermost_nonclass_level (name);
2027 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2029 tree t = TREE_TYPE (old);
2030 if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2031 && (! DECL_IN_SYSTEM_HEADER (decl)
2032 || ! DECL_IN_SYSTEM_HEADER (old)))
2033 warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2036 else if (is_overloaded_fn (old))
2040 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2042 tree fn = OVL_CURRENT (tmp);
2045 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2046 && !(flags & PUSH_USING)
2047 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2048 TYPE_ARG_TYPES (TREE_TYPE (decl)))
2049 && ! decls_match (fn, decl))
2050 error ("%q#D conflicts with previous using declaration %q#D",
2053 dup = duplicate_decls (decl, fn, is_friend);
2054 /* If DECL was a redeclaration of FN -- even an invalid
2055 one -- pass that information along to our caller. */
2056 if (dup == fn || dup == error_mark_node)
2057 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2060 /* We don't overload implicit built-ins. duplicate_decls()
2061 may fail to merge the decls if the new decl is e.g. a
2062 template function. */
2063 if (TREE_CODE (old) == FUNCTION_DECL
2064 && DECL_ANTICIPATED (old)
2065 && !DECL_HIDDEN_FRIEND_P (old))
2068 else if (old == error_mark_node)
2069 /* Ignore the undefined symbol marker. */
2073 error ("previous non-function declaration %q+#D", old);
2074 error ("conflicts with function declaration %q#D", decl);
2075 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2079 if (old || TREE_CODE (decl) == TEMPLATE_DECL
2080 /* If it's a using declaration, we always need to build an OVERLOAD,
2081 because it's the only way to remember that the declaration comes
2082 from 'using', and have the lookup behave correctly. */
2083 || (flags & PUSH_USING))
2085 if (old && TREE_CODE (old) != OVERLOAD)
2086 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2088 new_binding = ovl_cons (decl, old);
2089 if (flags & PUSH_USING)
2090 OVL_USED (new_binding) = 1;
2093 /* NAME is not ambiguous. */
2097 set_namespace_binding (name, current_namespace, new_binding);
2100 /* We only create an OVERLOAD if there was a previous binding at
2101 this level, or if decl is a template. In the former case, we
2102 need to remove the old binding and replace it with the new
2103 binding. We must also run through the NAMES on the binding
2104 level where the name was bound to update the chain. */
2106 if (TREE_CODE (new_binding) == OVERLOAD && old)
2110 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2112 d = &TREE_CHAIN (*d))
2114 || (TREE_CODE (*d) == TREE_LIST
2115 && TREE_VALUE (*d) == old))
2117 if (TREE_CODE (*d) == TREE_LIST)
2118 /* Just replace the old binding with the new. */
2119 TREE_VALUE (*d) = new_binding;
2121 /* Build a TREE_LIST to wrap the OVERLOAD. */
2122 *d = tree_cons (NULL_TREE, new_binding,
2125 /* And update the cxx_binding node. */
2126 IDENTIFIER_BINDING (name)->value = new_binding;
2127 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2130 /* We should always find a previous binding in this case. */
2134 /* Install the new binding. */
2135 push_local_binding (name, new_binding, flags);
2138 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2141 /* Check a non-member using-declaration. Return the name and scope
2142 being used, and the USING_DECL, or NULL_TREE on failure. */
2145 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2147 /* [namespace.udecl]
2148 A using-declaration for a class member shall be a
2149 member-declaration. */
2152 error ("%qT is not a namespace", scope);
2155 else if (scope == error_mark_node)
2158 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2161 A using-declaration shall not name a template-id. */
2162 error ("a using-declaration cannot specify a template-id. "
2163 "Try %<using %D%>", name);
2167 if (TREE_CODE (decl) == NAMESPACE_DECL)
2169 error ("namespace %qD not allowed in using-declaration", decl);
2173 if (TREE_CODE (decl) == SCOPE_REF)
2175 /* It's a nested name with template parameter dependent scope.
2176 This can only be using-declaration for class member. */
2177 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2181 if (is_overloaded_fn (decl))
2182 decl = get_first_fn (decl);
2184 gcc_assert (DECL_P (decl));
2186 /* Make a USING_DECL. */
2187 return push_using_decl (scope, name);
2190 /* Process local and global using-declarations. */
2193 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2194 tree *newval, tree *newtype)
2196 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2198 *newval = *newtype = NULL_TREE;
2199 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2203 if (!decls.value && !decls.type)
2205 error ("%qD not declared", name);
2209 /* Shift the old and new bindings around so we're comparing class and
2210 enumeration names to each other. */
2211 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2217 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2219 decls.type = decls.value;
2220 decls.value = NULL_TREE;
2223 /* It is impossible to overload a built-in function; any explicit
2224 declaration eliminates the built-in declaration. So, if OLDVAL
2225 is a built-in, then we can just pretend it isn't there. */
2227 && TREE_CODE (oldval) == FUNCTION_DECL
2228 && DECL_ANTICIPATED (oldval)
2229 && !DECL_HIDDEN_FRIEND_P (oldval))
2234 /* Check for using functions. */
2235 if (is_overloaded_fn (decls.value))
2239 if (oldval && !is_overloaded_fn (oldval))
2241 error ("%qD is already declared in this scope", name);
2246 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2248 tree new_fn = OVL_CURRENT (tmp);
2250 /* [namespace.udecl]
2252 If a function declaration in namespace scope or block
2253 scope has the same name and the same parameter types as a
2254 function introduced by a using declaration the program is
2256 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2258 tree old_fn = OVL_CURRENT (tmp1);
2260 if (new_fn == old_fn)
2261 /* The function already exists in the current namespace. */
2263 else if (OVL_USED (tmp1))
2264 continue; /* this is a using decl */
2265 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2266 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2268 gcc_assert (!DECL_ANTICIPATED (old_fn)
2269 || DECL_HIDDEN_FRIEND_P (old_fn));
2271 /* There was already a non-using declaration in
2272 this scope with the same parameter types. If both
2273 are the same extern "C" functions, that's ok. */
2274 if (decls_match (new_fn, old_fn))
2278 error ("%qD is already declared in this scope", name);
2284 /* If we broke out of the loop, there's no reason to add
2285 this function to the using declarations for this
2290 /* If we are adding to an existing OVERLOAD, then we no
2291 longer know the type of the set of functions. */
2292 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2293 TREE_TYPE (*newval) = unknown_type_node;
2294 /* Add this new function to the set. */
2295 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2296 /* If there is only one function, then we use its type. (A
2297 using-declaration naming a single function can be used in
2298 contexts where overload resolution cannot be
2300 if (TREE_CODE (*newval) != OVERLOAD)
2302 *newval = ovl_cons (*newval, NULL_TREE);
2303 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2305 OVL_USED (*newval) = 1;
2310 *newval = decls.value;
2311 if (oldval && !decls_match (*newval, oldval))
2312 error ("%qD is already declared in this scope", name);
2318 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2320 error ("reference to %qD is ambiguous", name);
2321 print_candidates (decls.type);
2325 *newtype = decls.type;
2326 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2327 error ("%qD is already declared in this scope", name);
2330 /* If *newval is empty, shift any class or enumeration name down. */
2334 *newtype = NULL_TREE;
2338 /* Process a using-declaration at function scope. */
2341 do_local_using_decl (tree decl, tree scope, tree name)
2343 tree oldval, oldtype, newval, newtype;
2344 tree orig_decl = decl;
2346 decl = validate_nonmember_using_decl (decl, scope, name);
2347 if (decl == NULL_TREE)
2350 if (building_stmt_tree ()
2351 && at_function_scope_p ())
2352 add_decl_expr (decl);
2354 oldval = lookup_name_innermost_nonclass_level (name);
2355 oldtype = lookup_type_current_level (name);
2357 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2361 if (is_overloaded_fn (newval))
2365 /* We only need to push declarations for those functions
2366 that were not already bound in the current level.
2367 The old value might be NULL_TREE, it might be a single
2368 function, or an OVERLOAD. */
2369 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2370 term = OVL_FUNCTION (oldval);
2373 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2375 push_overloaded_decl (OVL_CURRENT (fn),
2376 PUSH_LOCAL | PUSH_USING,
2380 push_local_binding (name, newval, PUSH_USING);
2384 push_local_binding (name, newtype, PUSH_USING);
2385 set_identifier_type_value (name, newtype);
2388 /* Emit debug info. */
2389 if (!processing_template_decl)
2390 cp_emit_debug_info_for_using (orig_decl, current_scope());
2393 /* Returns true if ROOT (a namespace, class, or function) encloses
2394 CHILD. CHILD may be either a class type or a namespace. */
2397 is_ancestor (tree root, tree child)
2399 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2400 || TREE_CODE (root) == FUNCTION_DECL
2401 || CLASS_TYPE_P (root)));
2402 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2403 || CLASS_TYPE_P (child)));
2405 /* The global namespace encloses everything. */
2406 if (root == global_namespace)
2411 /* If we've run out of scopes, stop. */
2414 /* If we've reached the ROOT, it encloses CHILD. */
2417 /* Go out one level. */
2419 child = TYPE_NAME (child);
2420 child = DECL_CONTEXT (child);
2424 /* Enter the class or namespace scope indicated by T suitable for name
2425 lookup. T can be arbitrary scope, not necessary nested inside the
2426 current scope. Returns a non-null scope to pop iff pop_scope
2427 should be called later to exit this scope. */
2432 if (TREE_CODE (t) == NAMESPACE_DECL)
2433 push_decl_namespace (t);
2434 else if (CLASS_TYPE_P (t))
2436 if (!at_class_scope_p ()
2437 || !same_type_p (current_class_type, t))
2438 push_nested_class (t);
2440 /* T is the same as the current scope. There is therefore no
2441 need to re-enter the scope. Since we are not actually
2442 pushing a new scope, our caller should not call
2450 /* Leave scope pushed by push_scope. */
2455 if (TREE_CODE (t) == NAMESPACE_DECL)
2456 pop_decl_namespace ();
2457 else if CLASS_TYPE_P (t)
2458 pop_nested_class ();
2461 /* Subroutine of push_inner_scope. */
2464 push_inner_scope_r (tree outer, tree inner)
2469 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2472 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2474 push_inner_scope_r (outer, prev);
2475 if (TREE_CODE (inner) == NAMESPACE_DECL)
2477 struct cp_binding_level *save_template_parm = 0;
2478 /* Temporary take out template parameter scopes. They are saved
2479 in reversed order in save_template_parm. */
2480 while (current_binding_level->kind == sk_template_parms)
2482 struct cp_binding_level *b = current_binding_level;
2483 current_binding_level = b->level_chain;
2484 b->level_chain = save_template_parm;
2485 save_template_parm = b;
2488 resume_scope (NAMESPACE_LEVEL (inner));
2489 current_namespace = inner;
2491 /* Restore template parameter scopes. */
2492 while (save_template_parm)
2494 struct cp_binding_level *b = save_template_parm;
2495 save_template_parm = b->level_chain;
2496 b->level_chain = current_binding_level;
2497 current_binding_level = b;
2504 /* Enter the scope INNER from current scope. INNER must be a scope
2505 nested inside current scope. This works with both name lookup and
2506 pushing name into scope. In case a template parameter scope is present,
2507 namespace is pushed under the template parameter scope according to
2508 name lookup rule in 14.6.1/6.
2510 Return the former current scope suitable for pop_inner_scope. */
2513 push_inner_scope (tree inner)
2515 tree outer = current_scope ();
2517 outer = current_namespace;
2519 push_inner_scope_r (outer, inner);
2523 /* Exit the current scope INNER back to scope OUTER. */
2526 pop_inner_scope (tree outer, tree inner)
2529 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2532 while (outer != inner)
2534 if (TREE_CODE (inner) == NAMESPACE_DECL)
2536 struct cp_binding_level *save_template_parm = 0;
2537 /* Temporary take out template parameter scopes. They are saved
2538 in reversed order in save_template_parm. */
2539 while (current_binding_level->kind == sk_template_parms)
2541 struct cp_binding_level *b = current_binding_level;
2542 current_binding_level = b->level_chain;
2543 b->level_chain = save_template_parm;
2544 save_template_parm = b;
2549 /* Restore template parameter scopes. */
2550 while (save_template_parm)
2552 struct cp_binding_level *b = save_template_parm;
2553 save_template_parm = b->level_chain;
2554 b->level_chain = current_binding_level;
2555 current_binding_level = b;
2561 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2565 /* Do a pushlevel for class declarations. */
2568 pushlevel_class (void)
2570 if (ENABLE_SCOPE_CHECKING)
2573 class_binding_level = begin_scope (sk_class, current_class_type);
2576 /* ...and a poplevel for class declarations. */
2579 poplevel_class (void)
2581 struct cp_binding_level *level = class_binding_level;
2582 cp_class_binding *cb;
2586 timevar_push (TV_NAME_LOOKUP);
2587 gcc_assert (level != 0);
2589 /* If we're leaving a toplevel class, cache its binding level. */
2590 if (current_class_depth == 1)
2591 previous_class_level = level;
2592 for (shadowed = level->type_shadowed;
2594 shadowed = TREE_CHAIN (shadowed))
2595 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2597 /* Remove the bindings for all of the class-level declarations. */
2598 if (level->class_shadowed)
2601 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2603 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2604 ggc_free (level->class_shadowed);
2605 level->class_shadowed = NULL;
2608 /* Now, pop out of the binding level which we created up in the
2609 `pushlevel_class' routine. */
2610 if (ENABLE_SCOPE_CHECKING)
2614 timevar_pop (TV_NAME_LOOKUP);
2617 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2618 appropriate. DECL is the value to which a name has just been
2619 bound. CLASS_TYPE is the class in which the lookup occurred. */
2622 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2625 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2629 if (TREE_CODE (decl) == OVERLOAD)
2630 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2633 gcc_assert (DECL_P (decl));
2634 context = context_for_name_lookup (decl);
2637 if (is_properly_derived_from (class_type, context))
2638 INHERITED_VALUE_BINDING_P (binding) = 1;
2640 INHERITED_VALUE_BINDING_P (binding) = 0;
2642 else if (binding->value == decl)
2643 /* We only encounter a TREE_LIST when there is an ambiguity in the
2644 base classes. Such an ambiguity can be overridden by a
2645 definition in this class. */
2646 INHERITED_VALUE_BINDING_P (binding) = 1;
2648 INHERITED_VALUE_BINDING_P (binding) = 0;
2651 /* Make the declaration of X appear in CLASS scope. */
2654 pushdecl_class_level (tree x)
2657 bool is_valid = true;
2659 timevar_push (TV_NAME_LOOKUP);
2660 /* Get the name of X. */
2661 if (TREE_CODE (x) == OVERLOAD)
2662 name = DECL_NAME (get_first_fn (x));
2664 name = DECL_NAME (x);
2668 is_valid = push_class_level_binding (name, x);
2669 if (TREE_CODE (x) == TYPE_DECL)
2670 set_identifier_type_value (name, x);
2672 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2674 /* If X is an anonymous aggregate, all of its members are
2675 treated as if they were members of the class containing the
2676 aggregate, for naming purposes. */
2679 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2681 location_t save_location = input_location;
2682 input_location = DECL_SOURCE_LOCATION (f);
2683 if (!pushdecl_class_level (f))
2685 input_location = save_location;
2688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2691 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2692 scope. If the value returned is non-NULL, and the PREVIOUS field
2693 is not set, callers must set the PREVIOUS field explicitly. */
2695 static cxx_binding *
2696 get_class_binding (tree name, cxx_scope *scope)
2701 cxx_binding *binding;
2703 class_type = scope->this_entity;
2705 /* Get the type binding. */
2706 type_binding = lookup_member (class_type, name,
2707 /*protect=*/2, /*want_type=*/true);
2708 /* Get the value binding. */
2709 value_binding = lookup_member (class_type, name,
2710 /*protect=*/2, /*want_type=*/false);
2713 && (TREE_CODE (value_binding) == TYPE_DECL
2714 || DECL_CLASS_TEMPLATE_P (value_binding)
2715 || (TREE_CODE (value_binding) == TREE_LIST
2716 && TREE_TYPE (value_binding) == error_mark_node
2717 && (TREE_CODE (TREE_VALUE (value_binding))
2719 /* We found a type binding, even when looking for a non-type
2720 binding. This means that we already processed this binding
2723 else if (value_binding)
2725 if (TREE_CODE (value_binding) == TREE_LIST
2726 && TREE_TYPE (value_binding) == error_mark_node)
2727 /* NAME is ambiguous. */
2729 else if (BASELINK_P (value_binding))
2730 /* NAME is some overloaded functions. */
2731 value_binding = BASELINK_FUNCTIONS (value_binding);
2734 /* If we found either a type binding or a value binding, create a
2735 new binding object. */
2736 if (type_binding || value_binding)
2738 binding = new_class_binding (name,
2742 /* This is a class-scope binding, not a block-scope binding. */
2743 LOCAL_BINDING_P (binding) = 0;
2744 set_inherited_value_binding_p (binding, value_binding, class_type);
2752 /* Make the declaration(s) of X appear in CLASS scope under the name
2753 NAME. Returns true if the binding is valid. */
2756 push_class_level_binding (tree name, tree x)
2758 cxx_binding *binding;
2762 timevar_push (TV_NAME_LOOKUP);
2763 /* The class_binding_level will be NULL if x is a template
2764 parameter name in a member template. */
2765 if (!class_binding_level)
2766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2768 if (name == error_mark_node)
2769 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2771 /* Check for invalid member names. */
2772 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2773 /* We could have been passed a tree list if this is an ambiguous
2774 declaration. If so, pull the declaration out because
2775 check_template_shadow will not handle a TREE_LIST. */
2776 if (TREE_CODE (decl) == TREE_LIST
2777 && TREE_TYPE (decl) == error_mark_node)
2778 decl = TREE_VALUE (decl);
2780 if (!check_template_shadow (decl))
2781 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2785 If T is the name of a class, then each of the following shall
2786 have a name different from T:
2788 -- every static data member of class T;
2790 -- every member of class T that is itself a type;
2792 -- every enumerator of every member of class T that is an
2795 -- every member of every anonymous union that is a member of
2798 (Non-static data members were also forbidden to have the same
2799 name as T until TC1.) */
2800 if ((TREE_CODE (x) == VAR_DECL
2801 || TREE_CODE (x) == CONST_DECL
2802 || (TREE_CODE (x) == TYPE_DECL
2803 && !DECL_SELF_REFERENCE_P (x))
2804 /* A data member of an anonymous union. */
2805 || (TREE_CODE (x) == FIELD_DECL
2806 && DECL_CONTEXT (x) != current_class_type))
2807 && DECL_NAME (x) == constructor_name (current_class_type))
2809 tree scope = context_for_name_lookup (x);
2810 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2812 error ("%qD has the same name as the class in which it is "
2815 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2819 /* Get the current binding for NAME in this class, if any. */
2820 binding = IDENTIFIER_BINDING (name);
2821 if (!binding || binding->scope != class_binding_level)
2823 binding = get_class_binding (name, class_binding_level);
2824 /* If a new binding was created, put it at the front of the
2825 IDENTIFIER_BINDING list. */
2828 binding->previous = IDENTIFIER_BINDING (name);
2829 IDENTIFIER_BINDING (name) = binding;
2833 /* If there is already a binding, then we may need to update the
2835 if (binding && binding->value)
2837 tree bval = binding->value;
2838 tree old_decl = NULL_TREE;
2840 if (INHERITED_VALUE_BINDING_P (binding))
2842 /* If the old binding was from a base class, and was for a
2843 tag name, slide it over to make room for the new binding.
2844 The old binding is still visible if explicitly qualified
2845 with a class-key. */
2846 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2847 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2849 old_decl = binding->type;
2850 binding->type = bval;
2851 binding->value = NULL_TREE;
2852 INHERITED_VALUE_BINDING_P (binding) = 0;
2857 /* Any inherited type declaration is hidden by the type
2858 declaration in the derived class. */
2859 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2860 binding->type = NULL_TREE;
2863 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2865 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2866 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2867 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2869 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2872 if (old_decl && binding->scope == class_binding_level)
2875 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2876 here. This function is only used to register bindings
2877 from with the class definition itself. */
2878 INHERITED_VALUE_BINDING_P (binding) = 0;
2879 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2883 /* Note that we declared this value so that we can issue an error if
2884 this is an invalid redeclaration of a name already used for some
2886 note_name_declared_in_class (name, decl);
2888 /* If we didn't replace an existing binding, put the binding on the
2889 stack of bindings for the identifier, and update the shadowed
2891 if (binding && binding->scope == class_binding_level)
2892 /* Supplement the existing binding. */
2893 ok = supplement_binding (binding, decl);
2896 /* Create a new binding. */
2897 push_binding (name, decl, class_binding_level);
2901 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2904 /* Process "using SCOPE::NAME" in a class scope. Return the
2905 USING_DECL created. */
2908 do_class_using_decl (tree scope, tree name)
2910 /* The USING_DECL returned by this function. */
2912 /* The declaration (or declarations) name by this using
2913 declaration. NULL if we are in a template and cannot figure out
2914 what has been named. */
2916 /* True if SCOPE is a dependent type. */
2917 bool scope_dependent_p;
2918 /* True if SCOPE::NAME is dependent. */
2919 bool name_dependent_p;
2920 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2921 bool bases_dependent_p;
2926 if (name == error_mark_node)
2929 if (!scope || !TYPE_P (scope))
2931 error ("using-declaration for non-member at class scope");
2935 /* Make sure the name is not invalid */
2936 if (TREE_CODE (name) == BIT_NOT_EXPR)
2938 error ("%<%T::%D%> names destructor", scope, name);
2941 if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2943 error ("%<%T::%D%> names constructor", scope, name);
2946 if (constructor_name_p (name, current_class_type))
2948 error ("%<%T::%D%> names constructor in %qT",
2949 scope, name, current_class_type);
2953 scope_dependent_p = dependent_type_p (scope);
2954 name_dependent_p = (scope_dependent_p
2955 || (IDENTIFIER_TYPENAME_P (name)
2956 && dependent_type_p (TREE_TYPE (name))));
2958 bases_dependent_p = false;
2959 if (processing_template_decl)
2960 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2961 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2963 if (dependent_type_p (TREE_TYPE (base_binfo)))
2965 bases_dependent_p = true;
2971 /* From [namespace.udecl]:
2973 A using-declaration used as a member-declaration shall refer to a
2974 member of a base class of the class being defined.
2976 In general, we cannot check this constraint in a template because
2977 we do not know the entire set of base classes of the current
2978 class type. However, if all of the base classes are
2979 non-dependent, then we can avoid delaying the check until
2981 if (!scope_dependent_p)
2984 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2985 if (b_kind < bk_proper_base)
2987 if (!bases_dependent_p)
2989 error_not_base_type (scope, current_class_type);
2993 else if (!name_dependent_p)
2995 decl = lookup_member (binfo, name, 0, false);
2998 error ("no members matching %<%T::%D%> in %q#T", scope, name,
3002 /* The binfo from which the functions came does not matter. */
3003 if (BASELINK_P (decl))
3004 decl = BASELINK_FUNCTIONS (decl);
3008 value = build_lang_decl (USING_DECL, name, NULL_TREE);
3009 USING_DECL_DECLS (value) = decl;
3010 USING_DECL_SCOPE (value) = scope;
3011 DECL_DEPENDENT_P (value) = !decl;
3017 /* Return the binding value for name in scope. */
3020 namespace_binding (tree name, tree scope)
3022 cxx_binding *binding;
3025 scope = global_namespace;
3027 /* Unnecessary for the global namespace because it can't be an alias. */
3028 scope = ORIGINAL_NAMESPACE (scope);
3030 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3032 return binding ? binding->value : NULL_TREE;
3035 /* Set the binding value for name in scope. */
3038 set_namespace_binding (tree name, tree scope, tree val)
3042 timevar_push (TV_NAME_LOOKUP);
3043 if (scope == NULL_TREE)
3044 scope = global_namespace;
3045 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3046 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3049 supplement_binding (b, val);
3050 timevar_pop (TV_NAME_LOOKUP);
3053 /* Set the context of a declaration to scope. Complain if we are not
3057 set_decl_namespace (tree decl, tree scope, bool friendp)
3061 /* Get rid of namespace aliases. */
3062 scope = ORIGINAL_NAMESPACE (scope);
3064 /* It is ok for friends to be qualified in parallel space. */
3065 if (!friendp && !is_ancestor (current_namespace, scope))
3066 error ("declaration of %qD not in a namespace surrounding %qD",
3068 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3070 /* Writing "int N::i" to declare a variable within "N" is invalid. */
3071 if (scope == current_namespace)
3073 if (at_namespace_scope_p ())
3074 error ("explicit qualification in declaration of %qD",
3079 /* See whether this has been declared in the namespace. */
3080 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3081 if (old == error_mark_node)
3082 /* No old declaration at all. */
3084 if (!is_overloaded_fn (decl))
3085 /* Don't compare non-function decls with decls_match here, since
3086 it can't check for the correct constness at this
3087 point. pushdecl will find those errors later. */
3089 /* Since decl is a function, old should contain a function decl. */
3090 if (!is_overloaded_fn (old))
3092 fn = OVL_CURRENT (old);
3093 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
3095 /* A template can be explicitly specialized in any namespace. */
3096 if (processing_explicit_instantiation)
3098 if (processing_template_decl || processing_specialization)
3099 /* We have not yet called push_template_decl to turn a
3100 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3101 match. But, we'll check later, when we construct the
3104 /* Instantiations or specializations of templates may be declared as
3105 friends in any namespace. */
3106 if (friendp && DECL_USE_TEMPLATE (decl))
3108 if (is_overloaded_fn (old))
3110 for (; old; old = OVL_NEXT (old))
3111 if (decls_match (decl, OVL_CURRENT (old)))
3114 else if (decls_match (decl, old))
3117 error ("%qD should have been declared inside %qD", decl, scope);
3120 /* Return the namespace where the current declaration is declared. */
3123 current_decl_namespace (void)
3126 /* If we have been pushed into a different namespace, use it. */
3127 if (decl_namespace_list)
3128 return TREE_PURPOSE (decl_namespace_list);
3130 if (current_class_type)
3131 result = decl_namespace_context (current_class_type);
3132 else if (current_function_decl)
3133 result = decl_namespace_context (current_function_decl);
3135 result = current_namespace;
3139 /* Process any ATTRIBUTES on a namespace definition. Currently only
3140 attribute visibility is meaningful, which is a property of the syntactic
3141 block rather than the namespace as a whole, so we don't touch the
3142 NAMESPACE_DECL at all. Returns true if attribute visibility is seen. */
3145 handle_namespace_attrs (tree ns, tree attributes)
3148 bool saw_vis = false;
3150 for (d = attributes; d; d = TREE_CHAIN (d))
3152 tree name = TREE_PURPOSE (d);
3153 tree args = TREE_VALUE (d);
3155 #ifdef HANDLE_PRAGMA_VISIBILITY
3156 if (is_attribute_p ("visibility", name))
3158 tree x = args ? TREE_VALUE (args) : NULL_TREE;
3159 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3161 warning (OPT_Wattributes,
3162 "%qD attribute requires a single NTBS argument",
3167 if (!TREE_PUBLIC (ns))
3168 warning (OPT_Wattributes,
3169 "%qD attribute is meaningless since members of the "
3170 "anonymous namespace get local symbols", name);
3172 push_visibility (TREE_STRING_POINTER (x));
3178 warning (OPT_Wattributes, "%qD attribute directive ignored",
3187 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3188 select a name that is unique to this compilation unit. */
3191 push_namespace (tree name)
3195 int implicit_use = 0;
3198 timevar_push (TV_NAME_LOOKUP);
3200 /* We should not get here if the global_namespace is not yet constructed
3201 nor if NAME designates the global namespace: The global scope is
3202 constructed elsewhere. */
3203 gcc_assert (global_namespace != NULL && name != global_scope_name);
3207 name = get_anonymous_namespace_name();
3208 d = IDENTIFIER_NAMESPACE_VALUE (name);
3210 /* Reopening anonymous namespace. */
3216 /* Check whether this is an extended namespace definition. */
3217 d = IDENTIFIER_NAMESPACE_VALUE (name);
3218 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3221 if (DECL_NAMESPACE_ALIAS (d))
3223 error ("namespace alias %qD not allowed here, assuming %qD",
3224 d, DECL_NAMESPACE_ALIAS (d));
3225 d = DECL_NAMESPACE_ALIAS (d);
3232 /* Make a new namespace, binding the name to it. */
3233 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3234 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3235 /* The name of this namespace is not visible to other translation
3236 units if it is an anonymous namespace or member thereof. */
3237 if (anon || decl_anon_ns_mem_p (current_namespace))
3238 TREE_PUBLIC (d) = 0;
3240 TREE_PUBLIC (d) = 1;
3244 /* Clear DECL_NAME for the benefit of debugging back ends. */
3245 SET_DECL_ASSEMBLER_NAME (d, name);
3246 DECL_NAME (d) = NULL_TREE;
3248 begin_scope (sk_namespace, d);
3251 resume_scope (NAMESPACE_LEVEL (d));
3254 do_using_directive (d);
3255 /* Enter the name space. */
3256 current_namespace = d;
3258 timevar_pop (TV_NAME_LOOKUP);
3261 /* Pop from the scope of the current namespace. */
3264 pop_namespace (void)
3266 gcc_assert (current_namespace != global_namespace);
3267 current_namespace = CP_DECL_CONTEXT (current_namespace);
3268 /* The binding level is not popped, as it might be re-opened later. */
3272 /* Push into the scope of the namespace NS, even if it is deeply
3273 nested within another namespace. */
3276 push_nested_namespace (tree ns)
3278 if (ns == global_namespace)
3279 push_to_top_level ();
3282 push_nested_namespace (CP_DECL_CONTEXT (ns));
3283 push_namespace (DECL_NAME (ns));
3287 /* Pop back from the scope of the namespace NS, which was previously
3288 entered with push_nested_namespace. */
3291 pop_nested_namespace (tree ns)
3293 timevar_push (TV_NAME_LOOKUP);
3294 while (ns != global_namespace)
3297 ns = CP_DECL_CONTEXT (ns);
3300 pop_from_top_level ();
3301 timevar_pop (TV_NAME_LOOKUP);
3304 /* Temporarily set the namespace for the current declaration. */
3307 push_decl_namespace (tree decl)
3309 if (TREE_CODE (decl) != NAMESPACE_DECL)
3310 decl = decl_namespace_context (decl);
3311 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3312 NULL_TREE, decl_namespace_list);
3315 /* [namespace.memdef]/2 */
3318 pop_decl_namespace (void)
3320 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3323 /* Return the namespace that is the common ancestor
3324 of two given namespaces. */
3327 namespace_ancestor (tree ns1, tree ns2)
3329 timevar_push (TV_NAME_LOOKUP);
3330 if (is_ancestor (ns1, ns2))
3331 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3332 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3333 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3336 /* Process a namespace-alias declaration. */
3339 do_namespace_alias (tree alias, tree name_space)
3341 if (name_space == error_mark_node)
3344 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3346 name_space = ORIGINAL_NAMESPACE (name_space);
3348 /* Build the alias. */
3349 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3350 DECL_NAMESPACE_ALIAS (alias) = name_space;
3351 DECL_EXTERNAL (alias) = 1;
3352 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3355 /* Emit debug info for namespace alias. */
3356 if (!building_stmt_tree ())
3357 (*debug_hooks->global_decl) (alias);
3360 /* Like pushdecl, only it places X in the current namespace,
3364 pushdecl_namespace_level (tree x, bool is_friend)
3366 struct cp_binding_level *b = current_binding_level;
3369 timevar_push (TV_NAME_LOOKUP);
3370 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3372 /* Now, the type_shadowed stack may screw us. Munge it so it does
3374 if (TREE_CODE (t) == TYPE_DECL)
3376 tree name = DECL_NAME (t);
3378 tree *ptr = (tree *)0;
3379 for (; !global_scope_p (b); b = b->level_chain)
3381 tree shadowed = b->type_shadowed;
3382 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3383 if (TREE_PURPOSE (shadowed) == name)
3385 ptr = &TREE_VALUE (shadowed);
3386 /* Can't break out of the loop here because sometimes
3387 a binding level will have duplicate bindings for
3388 PT names. It's gross, but I haven't time to fix it. */
3391 newval = TREE_TYPE (t);
3392 if (ptr == (tree *)0)
3394 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3395 up here if this is changed to an assertion. --KR */
3396 SET_IDENTIFIER_TYPE_VALUE (name, t);
3403 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3406 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3407 directive is not directly from the source. Also find the common
3408 ancestor and let our users know about the new namespace */
3410 add_using_namespace (tree user, tree used, bool indirect)
3413 timevar_push (TV_NAME_LOOKUP);
3414 /* Using oneself is a no-op. */
3417 timevar_pop (TV_NAME_LOOKUP);
3420 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3421 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3422 /* Check if we already have this. */
3423 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3427 /* Promote to direct usage. */
3428 TREE_INDIRECT_USING (t) = 0;
3429 timevar_pop (TV_NAME_LOOKUP);
3433 /* Add used to the user's using list. */
3434 DECL_NAMESPACE_USING (user)
3435 = tree_cons (used, namespace_ancestor (user, used),
3436 DECL_NAMESPACE_USING (user));
3438 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3440 /* Add user to the used's users list. */
3441 DECL_NAMESPACE_USERS (used)
3442 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3444 /* Recursively add all namespaces used. */
3445 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3446 /* indirect usage */
3447 add_using_namespace (user, TREE_PURPOSE (t), 1);
3449 /* Tell everyone using us about the new used namespaces. */
3450 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3451 add_using_namespace (TREE_PURPOSE (t), used, 1);
3452 timevar_pop (TV_NAME_LOOKUP);
3455 /* Process a using-declaration not appearing in class or local scope. */
3458 do_toplevel_using_decl (tree decl, tree scope, tree name)
3460 tree oldval, oldtype, newval, newtype;
3461 tree orig_decl = decl;
3462 cxx_binding *binding;
3464 decl = validate_nonmember_using_decl (decl, scope, name);
3465 if (decl == NULL_TREE)
3468 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3470 oldval = binding->value;
3471 oldtype = binding->type;
3473 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3475 /* Emit debug info. */
3476 if (!processing_template_decl)
3477 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3479 /* Copy declarations found. */
3481 binding->value = newval;
3483 binding->type = newtype;
3486 /* Process a using-directive. */
3489 do_using_directive (tree name_space)
3491 tree context = NULL_TREE;
3493 if (name_space == error_mark_node)
3496 gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3498 if (building_stmt_tree ())
3499 add_stmt (build_stmt (input_location, USING_STMT, name_space));
3500 name_space = ORIGINAL_NAMESPACE (name_space);
3502 if (!toplevel_bindings_p ())
3504 push_using_directive (name_space);
3509 add_using_namespace (current_namespace, name_space, 0);
3510 if (current_namespace != global_namespace)
3511 context = current_namespace;
3513 /* Emit debugging info. */
3514 if (!processing_template_decl)
3515 (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3520 /* Deal with a using-directive seen by the parser. Currently we only
3521 handle attributes here, since they cannot appear inside a template. */
3524 parse_using_directive (tree name_space, tree attribs)
3528 do_using_directive (name_space);
3530 for (a = attribs; a; a = TREE_CHAIN (a))
3532 tree name = TREE_PURPOSE (a);
3533 if (is_attribute_p ("strong", name))
3535 if (!toplevel_bindings_p ())
3536 error ("strong using only meaningful at namespace scope");
3537 else if (name_space != error_mark_node)
3539 if (!is_ancestor (current_namespace, name_space))
3540 error ("current namespace %qD does not enclose strongly used namespace %qD",
3541 current_namespace, name_space);
3542 DECL_NAMESPACE_ASSOCIATIONS (name_space)
3543 = tree_cons (current_namespace, 0,
3544 DECL_NAMESPACE_ASSOCIATIONS (name_space));
3548 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3552 /* Like pushdecl, only it places X in the global scope if appropriate.
3553 Calls cp_finish_decl to register the variable, initializing it with
3554 *INIT, if INIT is non-NULL. */
3557 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3559 timevar_push (TV_NAME_LOOKUP);
3560 push_to_top_level ();
3561 x = pushdecl_namespace_level (x, is_friend);
3563 cp_finish_decl (x, *init, false, NULL_TREE, 0);
3564 pop_from_top_level ();
3565 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3568 /* Like pushdecl, only it places X in the global scope if appropriate. */
3571 pushdecl_top_level (tree x)
3573 return pushdecl_top_level_1 (x, NULL, false);
3576 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3579 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3581 return pushdecl_top_level_1 (x, NULL, is_friend);
3584 /* Like pushdecl, only it places X in the global scope if
3585 appropriate. Calls cp_finish_decl to register the variable,
3586 initializing it with INIT. */
3589 pushdecl_top_level_and_finish (tree x, tree init)
3591 return pushdecl_top_level_1 (x, &init, false);
3594 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3595 duplicates. The first list becomes the tail of the result.
3597 The algorithm is O(n^2). We could get this down to O(n log n) by
3598 doing a sort on the addresses of the functions, if that becomes
3602 merge_functions (tree s1, tree s2)
3604 for (; s2; s2 = OVL_NEXT (s2))
3606 tree fn2 = OVL_CURRENT (s2);
3609 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3611 tree fn1 = OVL_CURRENT (fns1);
3613 /* If the function from S2 is already in S1, there is no
3614 need to add it again. For `extern "C"' functions, we
3615 might have two FUNCTION_DECLs for the same function, in
3616 different namespaces, but let's leave them in in case
3617 they have different default arguments. */
3622 /* If we exhausted all of the functions in S1, FN2 is new. */
3624 s1 = build_overload (fn2, s1);
3629 /* This should return an error not all definitions define functions.
3630 It is not an error if we find two functions with exactly the
3631 same signature, only if these are selected in overload resolution.
3632 old is the current set of bindings, new_binding the freshly-found binding.
3633 XXX Do we want to give *all* candidates in case of ambiguity?
3634 XXX In what way should I treat extern declarations?
3635 XXX I don't want to repeat the entire duplicate_decls here */
3638 ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3641 gcc_assert (old != NULL);
3643 /* Copy the type. */
3644 type = new_binding->type;
3645 if (LOOKUP_NAMESPACES_ONLY (flags)
3646 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3649 /* Copy the value. */
3650 val = new_binding->value;
3653 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3656 switch (TREE_CODE (val))
3659 /* If we expect types or namespaces, and not templates,
3660 or this is not a template class. */
3661 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3662 && !DECL_CLASS_TEMPLATE_P (val)))
3666 if (LOOKUP_NAMESPACES_ONLY (flags)
3667 || (type && (flags & LOOKUP_PREFER_TYPES)))
3670 case NAMESPACE_DECL:
3671 if (LOOKUP_TYPES_ONLY (flags))
3675 /* Ignore built-in functions that are still anticipated. */
3676 if (LOOKUP_QUALIFIERS_ONLY (flags))
3680 if (LOOKUP_QUALIFIERS_ONLY (flags))
3685 /* If val is hidden, shift down any class or enumeration name. */
3694 else if (val && val != old->value)
3696 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3697 old->value = merge_functions (old->value, val);
3700 old->value = tree_cons (NULL_TREE, old->value,
3701 build_tree_list (NULL_TREE, val));
3702 TREE_TYPE (old->value) = error_mark_node;
3708 else if (type && old->type != type)
3710 old->type = tree_cons (NULL_TREE, old->type,
3711 build_tree_list (NULL_TREE, type));
3712 TREE_TYPE (old->type) = error_mark_node;
3716 /* Return the declarations that are members of the namespace NS. */
3719 cp_namespace_decls (tree ns)
3721 return NAMESPACE_LEVEL (ns)->names;
3724 /* Combine prefer_type and namespaces_only into flags. */
3727 lookup_flags (int prefer_type, int namespaces_only)
3729 if (namespaces_only)
3730 return LOOKUP_PREFER_NAMESPACES;
3731 if (prefer_type > 1)
3732 return LOOKUP_PREFER_TYPES;
3733 if (prefer_type > 0)
3734 return LOOKUP_PREFER_BOTH;
3738 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3739 ignore it or not. Subroutine of lookup_name_real and
3740 lookup_type_scope. */
3743 qualify_lookup (tree val, int flags)
3745 if (val == NULL_TREE)
3747 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3749 if ((flags & LOOKUP_PREFER_TYPES)
3750 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3752 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3757 /* Given a lookup that returned VAL, decide if we want to ignore it or
3758 not based on DECL_ANTICIPATED. */
3761 hidden_name_p (tree val)
3764 && DECL_LANG_SPECIFIC (val)
3765 && DECL_ANTICIPATED (val))
3770 /* Remove any hidden friend functions from a possibly overloaded set
3774 remove_hidden_names (tree fns)
3779 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3781 else if (TREE_CODE (fns) == OVERLOAD)
3785 for (o = fns; o; o = OVL_NEXT (o))
3786 if (hidden_name_p (OVL_CURRENT (o)))
3792 for (o = fns; o; o = OVL_NEXT (o))
3793 if (!hidden_name_p (OVL_CURRENT (o)))
3794 n = build_overload (OVL_CURRENT (o), n);
3802 /* Unscoped lookup of a global: iterate over current namespaces,
3803 considering using-directives. */
3806 unqualified_namespace_lookup (tree name, int flags)
3808 tree initial = current_decl_namespace ();
3809 tree scope = initial;
3811 struct cp_binding_level *level;
3812 tree val = NULL_TREE;
3814 timevar_push (TV_NAME_LOOKUP);
3816 for (; !val; scope = CP_DECL_CONTEXT (scope))
3818 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3820 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3823 ambiguous_decl (&binding, b, flags);
3825 /* Add all _DECLs seen through local using-directives. */
3826 for (level = current_binding_level;
3827 level->kind != sk_namespace;
3828 level = level->level_chain)
3829 if (!lookup_using_namespace (name, &binding, level->using_directives,
3831 /* Give up because of error. */
3832 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3834 /* Add all _DECLs seen through global using-directives. */
3835 /* XXX local and global using lists should work equally. */
3839 if (!lookup_using_namespace (name, &binding,
3840 DECL_NAMESPACE_USING (siter),
3842 /* Give up because of error. */
3843 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3844 if (siter == scope) break;
3845 siter = CP_DECL_CONTEXT (siter);
3848 val = binding.value;
3849 if (scope == global_namespace)
3852 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3855 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3856 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3859 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3860 declaration found. If no suitable declaration can be found,
3861 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3862 neither a class-type nor a namespace a diagnostic is issued. */
3865 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3870 if (TREE_CODE (scope) == NAMESPACE_DECL)
3872 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3874 flags |= LOOKUP_COMPLAIN;
3876 flags |= LOOKUP_PREFER_TYPES;
3877 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3880 else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3881 t = lookup_enumerator (scope, name);
3882 else if (is_class_type (scope, complain))
3883 t = lookup_member (scope, name, 2, is_type_p);
3886 return error_mark_node;
3890 /* Subroutine of unqualified_namespace_lookup:
3891 Add the bindings of NAME in used namespaces to VAL.
3892 We are currently looking for names in namespace SCOPE, so we
3893 look through USINGS for using-directives of namespaces
3894 which have SCOPE as a common ancestor with the current scope.
3895 Returns false on errors. */
3898 lookup_using_namespace (tree name, struct scope_binding *val,
3899 tree usings, tree scope, int flags)
3902 timevar_push (TV_NAME_LOOKUP);
3903 /* Iterate over all used namespaces in current, searching for using
3904 directives of scope. */
3905 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3906 if (TREE_VALUE (iter) == scope)
3908 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3910 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3911 /* Resolve ambiguities. */
3913 ambiguous_decl (val, val1, flags);
3915 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3919 Accepts the NAME to lookup and its qualifying SCOPE.
3920 Returns the name/type pair found into the cxx_binding *RESULT,
3921 or false on error. */
3924 qualified_lookup_using_namespace (tree name, tree scope,
3925 struct scope_binding *result, int flags)
3927 /* Maintain a list of namespaces visited... */
3928 tree seen = NULL_TREE;
3929 /* ... and a list of namespace yet to see. */
3930 tree todo = NULL_TREE;
3931 tree todo_maybe = NULL_TREE;
3932 tree *todo_weak = &todo_maybe;
3934 timevar_push (TV_NAME_LOOKUP);
3935 /* Look through namespace aliases. */
3936 scope = ORIGINAL_NAMESPACE (scope);
3937 while (scope && result->value != error_mark_node)
3939 cxx_binding *binding =
3940 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3941 seen = tree_cons (scope, NULL_TREE, seen);
3943 ambiguous_decl (result, binding, flags);
3945 /* Consider strong using directives always, and non-strong ones
3946 if we haven't found a binding yet. */
3947 for (usings = DECL_NAMESPACE_USING (scope); usings;
3948 usings = TREE_CHAIN (usings))
3949 /* If this was a real directive, and we have not seen it. */
3950 if (!TREE_INDIRECT_USING (usings))
3952 /* Try to avoid queuing the same namespace more than once,
3953 the exception being when a namespace was already
3954 enqueued for todo_maybe and then a strong using is
3955 found for it. We could try to remove it from
3956 todo_maybe, but it's probably not worth the effort. */
3957 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3958 && !purpose_member (TREE_PURPOSE (usings), seen)
3959 && !purpose_member (TREE_PURPOSE (usings), todo))
3960 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3962 && !purpose_member (TREE_PURPOSE (usings), seen)
3963 && !purpose_member (TREE_PURPOSE (usings), todo)
3964 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3965 *todo_weak = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3970 scope = TREE_PURPOSE (todo);
3971 todo = TREE_CHAIN (todo);
3974 && (!result->value && !result->type))
3976 scope = TREE_PURPOSE (todo_maybe);
3977 todo = TREE_CHAIN (todo_maybe);
3978 todo_maybe = NULL_TREE;
3982 scope = NULL_TREE; /* If there never was a todo list. */
3984 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3987 /* Subroutine of outer_binding.
3988 Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
3992 binding_to_template_parms_of_scope_p (cxx_binding *binding,
3997 if (!binding || !scope)
4000 binding_value = binding->value ? binding->value : binding->type;
4003 && scope->this_entity
4004 && get_template_info (scope->this_entity)
4005 && parameter_of_template_p (binding_value,
4006 TI_TEMPLATE (get_template_info \
4007 (scope->this_entity))));
4010 /* Return the innermost non-namespace binding for NAME from a scope
4011 containing BINDING, or, if BINDING is NULL, the current scope.
4012 Please note that for a given template, the template parameters are
4013 considered to be in the scope containing the current scope.
4014 If CLASS_P is false, then class bindings are ignored. */
4017 outer_binding (tree name,
4018 cxx_binding *binding,
4023 cxx_scope *outer_scope;
4027 scope = binding->scope->level_chain;
4028 outer = binding->previous;
4032 scope = current_binding_level;
4033 outer = IDENTIFIER_BINDING (name);
4035 outer_scope = outer ? outer->scope : NULL;
4037 /* Because we create class bindings lazily, we might be missing a
4038 class binding for NAME. If there are any class binding levels
4039 between the LAST_BINDING_LEVEL and the scope in which OUTER was
4040 declared, we must lookup NAME in those class scopes. */
4042 while (scope && scope != outer_scope && scope->kind != sk_namespace)
4044 if (scope->kind == sk_class)
4046 cxx_binding *class_binding;
4048 class_binding = get_class_binding (name, scope);
4051 /* Thread this new class-scope binding onto the
4052 IDENTIFIER_BINDING list so that future lookups
4054 class_binding->previous = outer;
4056 binding->previous = class_binding;
4058 IDENTIFIER_BINDING (name) = class_binding;
4059 return class_binding;
4062 /* If we are in a member template, the template parms of the member
4063 template are considered to be inside the scope of the containing
4064 class, but within G++ the class bindings are all pushed between the
4065 template parms and the function body. So if the outer binding is
4066 a template parm for the current scope, return it now rather than
4067 look for a class binding. */
4068 if (outer_scope && outer_scope->kind == sk_template_parms
4069 && binding_to_template_parms_of_scope_p (outer, scope))
4072 scope = scope->level_chain;
4078 /* Return the innermost block-scope or class-scope value binding for
4079 NAME, or NULL_TREE if there is no such binding. */
4082 innermost_non_namespace_value (tree name)
4084 cxx_binding *binding;
4085 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4086 return binding ? binding->value : NULL_TREE;
4089 /* Look up NAME in the current binding level and its superiors in the
4090 namespace of variables, functions and typedefs. Return a ..._DECL
4091 node of some kind representing its definition if there is only one
4092 such declaration, or return a TREE_LIST with all the overloaded
4093 definitions if there are many, or return 0 if it is undefined.
4094 Hidden name, either friend declaration or built-in function, are
4097 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4098 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4099 Otherwise we prefer non-TYPE_DECLs.
4101 If NONCLASS is nonzero, bindings in class scopes are ignored. If
4102 BLOCK_P is false, bindings in block scopes are ignored. */
4105 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4106 int namespaces_only, int flags)
4109 tree val = NULL_TREE;
4111 timevar_push (TV_NAME_LOOKUP);
4112 /* Conversion operators are handled specially because ordinary
4113 unqualified name lookup will not find template conversion
4115 if (IDENTIFIER_TYPENAME_P (name))
4117 struct cp_binding_level *level;
4119 for (level = current_binding_level;
4120 level && level->kind != sk_namespace;
4121 level = level->level_chain)
4126 /* A conversion operator can only be declared in a class
4128 if (level->kind != sk_class)
4131 /* Lookup the conversion operator in the class. */
4132 class_type = level->this_entity;
4133 operators = lookup_fnfields (class_type, name, /*protect=*/0);
4135 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4138 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4141 flags |= lookup_flags (prefer_type, namespaces_only);
4143 /* First, look in non-namespace scopes. */
4145 if (current_class_type == NULL_TREE)
4148 if (block_p || !nonclass)
4149 for (iter = outer_binding (name, NULL, !nonclass);
4151 iter = outer_binding (name, iter, !nonclass))
4155 /* Skip entities we don't want. */
4156 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4159 /* If this is the kind of thing we're looking for, we're done. */
4160 if (qualify_lookup (iter->value, flags))
4161 binding = iter->value;
4162 else if ((flags & LOOKUP_PREFER_TYPES)
4163 && qualify_lookup (iter->type, flags))
4164 binding = iter->type;
4166 binding = NULL_TREE;
4170 if (hidden_name_p (binding))
4172 /* A non namespace-scope binding can only be hidden in the
4173 presence of a local class, due to friend declarations.
4175 In particular, consider:
4183 B* b; // error: B is hidden
4184 C* c; // OK, finds ::C
4187 B *b; // error: B is hidden
4188 C *c; // OK, finds ::C
4193 The standard says that "B" is a local class in "f"
4194 (but not nested within "A") -- but that name lookup
4195 for "B" does not find this declaration until it is
4196 declared directly with "f".
4202 If a friend declaration appears in a local class and
4203 the name specified is an unqualified name, a prior
4204 declaration is looked up without considering scopes
4205 that are outside the innermost enclosing non-class
4206 scope. For a friend function declaration, if there is
4207 no prior declaration, the program is ill-formed. For a
4208 friend class declaration, if there is no prior
4209 declaration, the class that is specified belongs to the
4210 innermost enclosing non-class scope, but if it is
4211 subsequently referenced, its name is not found by name
4212 lookup until a matching declaration is provided in the
4213 innermost enclosing nonclass scope.
4215 So just keep looking for a non-hidden binding.
4217 gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4225 /* Now lookup in namespace scopes. */
4227 val = unqualified_namespace_lookup (name, flags);
4229 /* If we have a single function from a using decl, pull it out. */
4230 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4231 val = OVL_FUNCTION (val);
4233 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4237 lookup_name_nonclass (tree name)
4239 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4243 lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4246 lookup_arg_dependent (name,
4247 lookup_name_real (name, 0, 1, block_p, 0,
4253 lookup_name (tree name)
4255 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4259 lookup_name_prefer_type (tree name, int prefer_type)
4261 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4262 0, LOOKUP_COMPLAIN);
4265 /* Look up NAME for type used in elaborated name specifier in
4266 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4267 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4268 name, more scopes are checked if cleanup or template parameter
4269 scope is encountered.
4271 Unlike lookup_name_real, we make sure that NAME is actually
4272 declared in the desired scope, not from inheritance, nor using
4273 directive. For using declaration, there is DR138 still waiting
4274 to be resolved. Hidden name coming from an earlier friend
4275 declaration is also returned.
4277 A TYPE_DECL best matching the NAME is returned. Catching error
4278 and issuing diagnostics are caller's responsibility. */
4281 lookup_type_scope (tree name, tag_scope scope)
4283 cxx_binding *iter = NULL;
4284 tree val = NULL_TREE;
4286 timevar_push (TV_NAME_LOOKUP);
4288 /* Look in non-namespace scope first. */
4289 if (current_binding_level->kind != sk_namespace)
4290 iter = outer_binding (name, NULL, /*class_p=*/ true);
4291 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4293 /* Check if this is the kind of thing we're looking for.
4294 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4295 base class. For ITER->VALUE, we can simply use
4296 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4299 We check ITER->TYPE before ITER->VALUE in order to handle
4300 typedef struct C {} C;
4303 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4304 && (scope != ts_current
4305 || LOCAL_BINDING_P (iter)
4306 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4308 else if ((scope != ts_current
4309 || !INHERITED_VALUE_BINDING_P (iter))
4310 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4317 /* Look in namespace scope. */
4320 iter = cxx_scope_find_binding_for_name
4321 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4325 /* If this is the kind of thing we're looking for, we're done. */
4326 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4328 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4334 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4335 and template parameter scopes. */
4338 struct cp_binding_level *b = current_binding_level;
4341 if (iter->scope == b)
4342 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4344 if (b->kind == sk_cleanup || b->kind == sk_template_parms
4345 || b->kind == sk_function_parms)
4347 else if (b->kind == sk_class
4348 && scope == ts_within_enclosing_non_class)
4355 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4358 /* Similar to `lookup_name' but look only in the innermost non-class
4362 lookup_name_innermost_nonclass_level (tree name)
4364 struct cp_binding_level *b;
4367 timevar_push (TV_NAME_LOOKUP);
4368 b = innermost_nonclass_level ();
4370 if (b->kind == sk_namespace)
4372 t = IDENTIFIER_NAMESPACE_VALUE (name);
4374 /* extern "C" function() */
4375 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4378 else if (IDENTIFIER_BINDING (name)
4379 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4381 cxx_binding *binding;
4382 binding = IDENTIFIER_BINDING (name);
4385 if (binding->scope == b
4386 && !(TREE_CODE (binding->value) == VAR_DECL
4387 && DECL_DEAD_FOR_LOCAL (binding->value)))
4388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4390 if (b->kind == sk_cleanup)
4397 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4400 /* Like lookup_name_innermost_nonclass_level, but for types. */
4403 lookup_type_current_level (tree name)
4407 timevar_push (TV_NAME_LOOKUP);
4408 gcc_assert (current_binding_level->kind != sk_namespace);
4410 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4411 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4413 struct cp_binding_level *b = current_binding_level;
4416 if (purpose_member (name, b->type_shadowed))
4417 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4418 REAL_IDENTIFIER_TYPE_VALUE (name));
4419 if (b->kind == sk_cleanup)
4426 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4429 /* [basic.lookup.koenig] */
4430 /* A nonzero return value in the functions below indicates an error. */
4441 static bool arg_assoc (struct arg_lookup*, tree);
4442 static bool arg_assoc_args (struct arg_lookup*, tree);
4443 static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4444 static bool arg_assoc_type (struct arg_lookup*, tree);
4445 static bool add_function (struct arg_lookup *, tree);
4446 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4447 static bool arg_assoc_class (struct arg_lookup *, tree);
4448 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4450 /* Add a function to the lookup structure.
4451 Returns true on error. */
4454 add_function (struct arg_lookup *k, tree fn)
4456 /* We used to check here to see if the function was already in the list,
4457 but that's O(n^2), which is just too expensive for function lookup.
4458 Now we deal with the occasional duplicate in joust. In doing this, we
4459 assume that the number of duplicates will be small compared to the
4460 total number of functions being compared, which should usually be the
4463 /* We must find only functions, or exactly one non-function. */
4466 else if (fn == k->functions)
4468 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4469 k->functions = build_overload (fn, k->functions);
4472 tree f1 = OVL_CURRENT (k->functions);
4474 if (is_overloaded_fn (f1))
4476 fn = f1; f1 = f2; f2 = fn;
4478 error ("%q+D is not a function,", f1);
4479 error (" conflict with %q+D", f2);
4480 error (" in call to %qD", k->name);
4487 /* Returns true iff CURRENT has declared itself to be an associated
4488 namespace of SCOPE via a strong using-directive (or transitive chain
4489 thereof). Both are namespaces. */
4492 is_associated_namespace (tree current, tree scope)
4494 tree seen = NULL_TREE;
4495 tree todo = NULL_TREE;
4499 if (scope == current)
4501 seen = tree_cons (scope, NULL_TREE, seen);
4502 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4503 if (!purpose_member (TREE_PURPOSE (t), seen))
4504 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4507 scope = TREE_PURPOSE (todo);
4508 todo = TREE_CHAIN (todo);
4515 /* Return whether FN is a friend of an associated class of ARG. */
4518 friend_of_associated_class_p (tree arg, tree fn)
4524 else if (type_unknown_p (arg))
4527 type = TREE_TYPE (arg);
4529 /* If TYPE is a class, the class itself and all base classes are
4530 associated classes. */
4531 if (CLASS_TYPE_P (type))
4533 if (is_friend (type, fn))
4536 if (TYPE_BINFO (type))
4538 tree binfo, base_binfo;
4541 for (binfo = TYPE_BINFO (type), i = 0;
4542 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4544 if (is_friend (BINFO_TYPE (base_binfo), fn))
4549 /* If TYPE is a class member, the class of which it is a member is
4550 an associated class. */
4551 if ((CLASS_TYPE_P (type)
4552 || TREE_CODE (type) == UNION_TYPE
4553 || TREE_CODE (type) == ENUMERAL_TYPE)
4554 && TYPE_CONTEXT (type)
4555 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4556 && is_friend (TYPE_CONTEXT (type), fn))
4562 /* Add functions of a namespace to the lookup structure.
4563 Returns true on error. */
4566 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4570 if (purpose_member (scope, k->namespaces))
4572 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4574 /* Check out our super-users. */
4575 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4576 value = TREE_CHAIN (value))
4577 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4580 /* Also look down into inline namespaces. */
4581 for (value = DECL_NAMESPACE_USING (scope); value;
4582 value = TREE_CHAIN (value))
4583 if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4584 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4587 value = namespace_binding (k->name, scope);
4591 for (; value; value = OVL_NEXT (value))
4593 /* We don't want to find arbitrary hidden functions via argument
4594 dependent lookup. We only want to find friends of associated
4596 if (hidden_name_p (OVL_CURRENT (value)))
4601 for (ix = 0; VEC_iterate (tree, k->args, ix, arg); ++ix)
4602 if (friend_of_associated_class_p (arg, OVL_CURRENT (value)))
4604 if (ix >= VEC_length (tree, k->args))
4608 if (add_function (k, OVL_CURRENT (value)))
4615 /* Adds everything associated with a template argument to the lookup
4616 structure. Returns true on error. */
4619 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4621 /* [basic.lookup.koenig]
4623 If T is a template-id, its associated namespaces and classes are
4624 ... the namespaces and classes associated with the types of the
4625 template arguments provided for template type parameters
4626 (excluding template template parameters); the namespaces in which
4627 any template template arguments are defined; and the classes in
4628 which any member templates used as template template arguments
4629 are defined. [Note: non-type template arguments do not
4630 contribute to the set of associated namespaces. ] */
4632 /* Consider first template template arguments. */
4633 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4634 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4636 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4638 tree ctx = CP_DECL_CONTEXT (arg);
4640 /* It's not a member template. */
4641 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4642 return arg_assoc_namespace (k, ctx);
4643 /* Otherwise, it must be member template. */
4645 return arg_assoc_class (k, ctx);
4647 /* It's an argument pack; handle it recursively. */
4648 else if (ARGUMENT_PACK_P (arg))
4650 tree args = ARGUMENT_PACK_ARGS (arg);
4651 int i, len = TREE_VEC_LENGTH (args);
4652 for (i = 0; i < len; ++i)
4653 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4658 /* It's not a template template argument, but it is a type template
4660 else if (TYPE_P (arg))
4661 return arg_assoc_type (k, arg);
4662 /* It's a non-type template argument. */
4667 /* Adds everything associated with class to the lookup structure.
4668 Returns true on error. */
4671 arg_assoc_class (struct arg_lookup *k, tree type)
4673 tree list, friends, context;
4676 /* Backend build structures, such as __builtin_va_list, aren't
4677 affected by all this. */
4678 if (!CLASS_TYPE_P (type))
4681 if (purpose_member (type, k->classes))
4683 k->classes = tree_cons (type, NULL_TREE, k->classes);
4685 context = decl_namespace_context (type);
4686 if (arg_assoc_namespace (k, context))
4689 if (TYPE_BINFO (type))
4691 /* Process baseclasses. */
4692 tree binfo, base_binfo;
4694 for (binfo = TYPE_BINFO (type), i = 0;
4695 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4696 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4700 /* Process friends. */
4701 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4702 list = TREE_CHAIN (list))
4703 if (k->name == FRIEND_NAME (list))
4704 for (friends = FRIEND_DECLS (list); friends;
4705 friends = TREE_CHAIN (friends))
4707 tree fn = TREE_VALUE (friends);
4709 /* Only interested in global functions with potentially hidden
4710 (i.e. unqualified) declarations. */
4711 if (CP_DECL_CONTEXT (fn) != context)
4713 /* Template specializations are never found by name lookup.
4714 (Templates themselves can be found, but not template
4715 specializations.) */
4716 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4718 if (add_function (k, fn))
4722 /* Process template arguments. */
4723 if (CLASSTYPE_TEMPLATE_INFO (type)
4724 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4726 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4727 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4728 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4734 /* Adds everything associated with a given type.
4735 Returns 1 on error. */
4738 arg_assoc_type (struct arg_lookup *k, tree type)
4740 /* As we do not get the type of non-type dependent expressions
4741 right, we can end up with such things without a type. */
4745 if (TYPE_PTRMEM_P (type))
4747 /* Pointer to member: associate class type and value type. */
4748 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4750 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4752 else switch (TREE_CODE (type))
4762 case FIXED_POINT_TYPE:
4766 if (TYPE_PTRMEMFUNC_P (type))
4767 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4768 return arg_assoc_class (k, type);
4770 case REFERENCE_TYPE:
4772 return arg_assoc_type (k, TREE_TYPE (type));
4775 return arg_assoc_namespace (k, decl_namespace_context (type));
4777 /* The basetype is referenced in the first arg type, so just
4780 /* Associate the parameter types. */
4781 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4783 /* Associate the return type. */
4784 return arg_assoc_type (k, TREE_TYPE (type));
4785 case TEMPLATE_TYPE_PARM:
4786 case BOUND_TEMPLATE_TEMPLATE_PARM:
4791 gcc_assert (type == unknown_type_node
4792 || type == init_list_type_node);
4794 case TYPE_PACK_EXPANSION:
4795 return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4803 /* Adds everything associated with arguments. Returns true on error. */
4806 arg_assoc_args (struct arg_lookup *k, tree args)
4808 for (; args; args = TREE_CHAIN (args))
4809 if (arg_assoc (k, TREE_VALUE (args)))
4814 /* Adds everything associated with an argument vector. Returns true
4818 arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
4823 for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
4824 if (arg_assoc (k, arg))
4829 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4832 arg_assoc (struct arg_lookup *k, tree n)
4834 if (n == error_mark_node)
4838 return arg_assoc_type (k, n);
4840 if (! type_unknown_p (n))
4841 return arg_assoc_type (k, TREE_TYPE (n));
4843 if (TREE_CODE (n) == ADDR_EXPR)
4844 n = TREE_OPERAND (n, 0);
4845 if (TREE_CODE (n) == COMPONENT_REF)
4846 n = TREE_OPERAND (n, 1);
4847 if (TREE_CODE (n) == OFFSET_REF)
4848 n = TREE_OPERAND (n, 1);
4849 while (TREE_CODE (n) == TREE_LIST)
4851 if (TREE_CODE (n) == BASELINK)
4852 n = BASELINK_FUNCTIONS (n);
4854 if (TREE_CODE (n) == FUNCTION_DECL)
4855 return arg_assoc_type (k, TREE_TYPE (n));
4856 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4858 /* [basic.lookup.koenig]
4860 If T is a template-id, its associated namespaces and classes
4861 are the namespace in which the template is defined; for
4862 member templates, the member template's class... */
4863 tree templ = TREE_OPERAND (n, 0);
4864 tree args = TREE_OPERAND (n, 1);
4868 if (TREE_CODE (templ) == COMPONENT_REF)
4869 templ = TREE_OPERAND (templ, 1);
4871 /* First, the template. There may actually be more than one if
4872 this is an overloaded function template. But, in that case,
4873 we only need the first; all the functions will be in the same
4875 templ = OVL_CURRENT (templ);
4877 ctx = CP_DECL_CONTEXT (templ);
4879 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4881 if (arg_assoc_namespace (k, ctx) == 1)
4884 /* It must be a member template. */
4885 else if (arg_assoc_class (k, ctx) == 1)
4888 /* Now the arguments. */
4890 for (ix = TREE_VEC_LENGTH (args); ix--;)
4891 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4894 else if (TREE_CODE (n) == OVERLOAD)
4896 for (; n; n = OVL_CHAIN (n))
4897 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4904 /* Performs Koenig lookup depending on arguments, where fns
4905 are the functions found in normal lookup. */
4908 lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args)
4910 struct arg_lookup k;
4912 timevar_push (TV_NAME_LOOKUP);
4914 /* Remove any hidden friend functions from the list of functions
4915 found so far. They will be added back by arg_assoc_class as
4917 fns = remove_hidden_names (fns);
4922 k.classes = NULL_TREE;
4924 /* We previously performed an optimization here by setting
4925 NAMESPACES to the current namespace when it was safe. However, DR
4926 164 says that namespaces that were already searched in the first
4927 stage of template processing are searched again (potentially
4928 picking up later definitions) in the second stage. */
4929 k.namespaces = NULL_TREE;
4931 arg_assoc_args_vec (&k, args);
4936 && TREE_CODE (fns) != VAR_DECL
4937 && !is_overloaded_fn (fns))
4939 error ("argument dependent lookup finds %q+D", fns);
4940 error (" in call to %qD", name);
4941 fns = error_mark_node;
4944 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4947 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4948 changed (i.e. there was already a directive), or the fresh
4949 TREE_LIST otherwise. */
4952 push_using_directive (tree used)
4954 tree ud = current_binding_level->using_directives;
4955 tree iter, ancestor;
4957 timevar_push (TV_NAME_LOOKUP);
4958 /* Check if we already have this. */
4959 if (purpose_member (used, ud) != NULL_TREE)
4960 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4962 ancestor = namespace_ancestor (current_decl_namespace (), used);
4963 ud = current_binding_level->using_directives;
4964 ud = tree_cons (used, ancestor, ud);
4965 current_binding_level->using_directives = ud;
4967 /* Recursively add all namespaces used. */
4968 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4969 push_using_directive (TREE_PURPOSE (iter));
4971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4974 /* The type TYPE is being declared. If it is a class template, or a
4975 specialization of a class template, do any processing required and
4976 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4977 being declared a friend. B is the binding level at which this TYPE
4980 Returns the TYPE_DECL for TYPE, which may have been altered by this
4984 maybe_process_template_type_declaration (tree type, int is_friend,
4987 tree decl = TYPE_NAME (type);
4989 if (processing_template_parmlist)
4990 /* You can't declare a new template type in a template parameter
4991 list. But, you can declare a non-template type:
4993 template <class A*> struct S;
4995 is a forward-declaration of `A'. */
4997 else if (b->kind == sk_namespace
4998 && current_binding_level->kind != sk_namespace)
4999 /* If this new type is being injected into a containing scope,
5000 then it's not a template type. */
5004 gcc_assert (MAYBE_CLASS_TYPE_P (type)
5005 || TREE_CODE (type) == ENUMERAL_TYPE);
5007 if (processing_template_decl)
5009 /* This may change after the call to
5010 push_template_decl_real, but we want the original value. */
5011 tree name = DECL_NAME (decl);
5013 decl = push_template_decl_real (decl, is_friend);
5014 if (decl == error_mark_node)
5015 return error_mark_node;
5017 /* If the current binding level is the binding level for the
5018 template parameters (see the comment in
5019 begin_template_parm_list) and the enclosing level is a class
5020 scope, and we're not looking at a friend, push the
5021 declaration of the member class into the class scope. In the
5022 friend case, push_template_decl will already have put the
5023 friend into global scope, if appropriate. */
5024 if (TREE_CODE (type) != ENUMERAL_TYPE
5025 && !is_friend && b->kind == sk_template_parms
5026 && b->level_chain->kind == sk_class)
5028 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5030 if (!COMPLETE_TYPE_P (current_class_type))
5032 maybe_add_class_template_decl_list (current_class_type,
5033 type, /*friend_p=*/0);
5034 /* Put this UTD in the table of UTDs for the class. */
5035 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5036 CLASSTYPE_NESTED_UTDS (current_class_type) =
5037 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5039 binding_table_insert
5040 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5049 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
5050 that the NAME is a class template, the tag is processed but not pushed.
5052 The pushed scope depend on the SCOPE parameter:
5053 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5055 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5056 non-template-parameter scope. This case is needed for forward
5058 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5059 TS_GLOBAL case except that names within template-parameter scopes
5060 are not pushed at all.
5062 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
5065 pushtag (tree name, tree type, tag_scope scope)
5067 struct cp_binding_level *b;
5070 timevar_push (TV_NAME_LOOKUP);
5071 b = current_binding_level;
5072 while (/* Cleanup scopes are not scopes from the point of view of
5074 b->kind == sk_cleanup
5075 /* Neither are function parameter scopes. */
5076 || b->kind == sk_function_parms
5077 /* Neither are the scopes used to hold template parameters
5078 for an explicit specialization. For an ordinary template
5079 declaration, these scopes are not scopes from the point of
5080 view of the language. */
5081 || (b->kind == sk_template_parms
5082 && (b->explicit_spec_p || scope == ts_global))
5083 || (b->kind == sk_class
5084 && (scope != ts_current
5085 /* We may be defining a new type in the initializer
5086 of a static member variable. We allow this when
5087 not pedantic, and it is particularly useful for
5088 type punning via an anonymous union. */
5089 || COMPLETE_TYPE_P (b->this_entity))))
5092 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5094 /* Do C++ gratuitous typedefing. */
5095 if (IDENTIFIER_TYPE_VALUE (name) != type)
5099 tree context = TYPE_CONTEXT (type);
5103 tree cs = current_scope ();
5105 if (scope == ts_current)
5107 else if (cs != NULL_TREE && TYPE_P (cs))
5108 /* When declaring a friend class of a local class, we want
5109 to inject the newly named class into the scope
5110 containing the local class, not the namespace
5112 context = decl_function_context (get_type_decl (cs));
5115 context = current_namespace;
5117 if (b->kind == sk_class
5118 || (b->kind == sk_template_parms
5119 && b->level_chain->kind == sk_class))
5122 if (current_lang_name == lang_name_java)
5123 TYPE_FOR_JAVA (type) = 1;
5125 tdef = create_implicit_typedef (name, type);
5126 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5127 if (scope == ts_within_enclosing_non_class)
5129 /* This is a friend. Make this TYPE_DECL node hidden from
5130 ordinary name lookup. Its corresponding TEMPLATE_DECL
5131 will be marked in push_template_decl_real. */
5132 retrofit_lang_decl (tdef);
5133 DECL_ANTICIPATED (tdef) = 1;
5134 DECL_FRIEND_P (tdef) = 1;
5137 decl = maybe_process_template_type_declaration
5138 (type, scope == ts_within_enclosing_non_class, b);
5139 if (decl == error_mark_node)
5140 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5142 if (b->kind == sk_class)
5144 if (!TYPE_BEING_DEFINED (current_class_type))
5145 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5147 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5148 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5149 class. But if it's a member template class, we want
5150 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5152 finish_member_declaration (decl);
5154 pushdecl_class_level (decl);
5156 else if (b->kind != sk_template_parms)
5158 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5159 if (decl == error_mark_node)
5160 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5164 set_identifier_type_value_with_scope (name, tdef, b);
5166 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5168 /* If this is a local class, keep track of it. We need this
5169 information for name-mangling, and so that it is possible to
5170 find all function definitions in a translation unit in a
5171 convenient way. (It's otherwise tricky to find a member
5172 function definition it's only pointed to from within a local
5174 if (TYPE_CONTEXT (type)
5175 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5176 VEC_safe_push (tree, gc, local_classes, type);
5178 if (b->kind == sk_class
5179 && !COMPLETE_TYPE_P (current_class_type))
5181 maybe_add_class_template_decl_list (current_class_type,
5182 type, /*friend_p=*/0);
5184 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5185 CLASSTYPE_NESTED_UTDS (current_class_type)
5186 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5188 binding_table_insert
5189 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5192 decl = TYPE_NAME (type);
5193 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5194 TYPE_STUB_DECL (type) = decl;
5196 /* Set type visibility now if this is a forward declaration. */
5197 TREE_PUBLIC (decl) = 1;
5198 determine_visibility (decl);
5200 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5203 /* Subroutines for reverting temporarily to top-level for instantiation
5204 of templates and such. We actually need to clear out the class- and
5205 local-value slots of all identifiers, so that only the global values
5206 are at all visible. Simply setting current_binding_level to the global
5207 scope isn't enough, because more binding levels may be pushed. */
5208 struct saved_scope *scope_chain;
5210 /* If ID has not already been marked, add an appropriate binding to
5214 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5216 cxx_saved_binding *saved;
5218 if (!id || !IDENTIFIER_BINDING (id))
5221 if (IDENTIFIER_MARKED (id))
5224 IDENTIFIER_MARKED (id) = 1;
5226 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5227 saved->identifier = id;
5228 saved->binding = IDENTIFIER_BINDING (id);
5229 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5230 IDENTIFIER_BINDING (id) = NULL;
5234 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5238 timevar_push (TV_NAME_LOOKUP);
5239 for (t = names; t; t = TREE_CHAIN (t))
5243 if (TREE_CODE (t) == TREE_LIST)
5244 id = TREE_PURPOSE (t);
5248 store_binding (id, old_bindings);
5250 timevar_pop (TV_NAME_LOOKUP);
5253 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5254 objects, rather than a TREE_LIST. */
5257 store_class_bindings (VEC(cp_class_binding,gc) *names,
5258 VEC(cxx_saved_binding,gc) **old_bindings)
5261 cp_class_binding *cb;
5263 timevar_push (TV_NAME_LOOKUP);
5264 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5265 store_binding (cb->identifier, old_bindings);
5266 timevar_pop (TV_NAME_LOOKUP);
5270 push_to_top_level (void)
5272 struct saved_scope *s;
5273 struct cp_binding_level *b;
5274 cxx_saved_binding *sb;
5278 timevar_push (TV_NAME_LOOKUP);
5279 s = GGC_CNEW (struct saved_scope);
5281 b = scope_chain ? current_binding_level : 0;
5283 /* If we're in the middle of some function, save our state. */
5287 push_function_context ();
5292 if (scope_chain && previous_class_level)
5293 store_class_bindings (previous_class_level->class_shadowed,
5296 /* Have to include the global scope, because class-scope decls
5297 aren't listed anywhere useful. */
5298 for (; b; b = b->level_chain)
5302 /* Template IDs are inserted into the global level. If they were
5303 inserted into namespace level, finish_file wouldn't find them
5304 when doing pending instantiations. Therefore, don't stop at
5305 namespace level, but continue until :: . */
5306 if (global_scope_p (b))
5309 store_bindings (b->names, &s->old_bindings);
5310 /* We also need to check class_shadowed to save class-level type
5311 bindings, since pushclass doesn't fill in b->names. */
5312 if (b->kind == sk_class)
5313 store_class_bindings (b->class_shadowed, &s->old_bindings);
5315 /* Unwind type-value slots back to top level. */
5316 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5317 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5320 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5321 IDENTIFIER_MARKED (sb->identifier) = 0;
5323 s->prev = scope_chain;
5325 s->need_pop_function_context = need_pop;
5326 s->function_decl = current_function_decl;
5327 s->unevaluated_operand = cp_unevaluated_operand;
5328 s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5331 current_function_decl = NULL_TREE;
5332 current_lang_base = VEC_alloc (tree, gc, 10);
5333 current_lang_name = lang_name_cplusplus;
5334 current_namespace = global_namespace;
5335 push_class_stack ();
5336 cp_unevaluated_operand = 0;
5337 c_inhibit_evaluation_warnings = 0;
5338 timevar_pop (TV_NAME_LOOKUP);
5342 pop_from_top_level (void)
5344 struct saved_scope *s = scope_chain;
5345 cxx_saved_binding *saved;
5348 timevar_push (TV_NAME_LOOKUP);
5349 /* Clear out class-level bindings cache. */
5350 if (previous_class_level)
5351 invalidate_class_lookup_cache ();
5354 current_lang_base = 0;
5356 scope_chain = s->prev;
5357 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5359 tree id = saved->identifier;
5361 IDENTIFIER_BINDING (id) = saved->binding;
5362 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5365 /* If we were in the middle of compiling a function, restore our
5367 if (s->need_pop_function_context)
5368 pop_function_context ();
5369 current_function_decl = s->function_decl;
5370 cp_unevaluated_operand = s->unevaluated_operand;
5371 c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5372 timevar_pop (TV_NAME_LOOKUP);
5375 /* Pop off extraneous binding levels left over due to syntax errors.
5377 We don't pop past namespaces, as they might be valid. */
5380 pop_everything (void)
5382 if (ENABLE_SCOPE_CHECKING)
5383 verbatim ("XXX entering pop_everything ()\n");
5384 while (!toplevel_bindings_p ())
5386 if (current_binding_level->kind == sk_class)
5387 pop_nested_class ();
5391 if (ENABLE_SCOPE_CHECKING)
5392 verbatim ("XXX leaving pop_everything ()\n");
5395 /* Emit debugging information for using declarations and directives.
5396 If input tree is overloaded fn then emit debug info for all
5400 cp_emit_debug_info_for_using (tree t, tree context)
5402 /* Don't try to emit any debug information if we have errors. */
5403 if (sorrycount || errorcount)
5406 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5407 of a builtin function. */
5408 if (TREE_CODE (t) == FUNCTION_DECL
5409 && DECL_EXTERNAL (t)
5410 && DECL_BUILT_IN (t))
5413 /* Do not supply context to imported_module_or_decl, if
5414 it is a global namespace. */
5415 if (context == global_namespace)
5416 context = NULL_TREE;
5419 t = BASELINK_FUNCTIONS (t);
5421 /* FIXME: Handle TEMPLATE_DECLs. */
5422 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5423 if (TREE_CODE (t) != TEMPLATE_DECL)
5425 if (building_stmt_tree ())
5426 add_stmt (build_stmt (input_location, USING_STMT, t));
5428 (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5432 #include "gt-cp-name-lookup.h"