1 /* Definitions for C++ name lookup routines.
2 Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
3 Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
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 lookup_name_innermost_nonclass_level (tree);
47 static tree push_overloaded_decl (tree, int, bool);
48 static bool lookup_using_namespace (tree, struct scope_binding *, tree,
50 static bool qualified_lookup_using_namespace (tree, tree,
51 struct scope_binding *, int);
52 static tree lookup_type_current_level (tree);
53 static tree push_using_directive (tree);
55 /* The :: namespace. */
57 tree global_namespace;
59 /* The name of the anonymous namespace, throughout this translation
61 static GTY(()) tree anonymous_namespace_name;
63 /* Initialise 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 binding_table_s GTY(())
130 /* Array of chains of "binding_entry"s */
131 binding_entry * GTY((length ("%h.chain_count"))) chain;
133 /* The number of chains in this table. This is the length of the
134 the member "chain" considered as an array. */
137 /* Number of "binding_entry"s in this table. */
141 /* Construct TABLE with an initial CHAIN_COUNT. */
144 binding_table_construct (binding_table table, size_t chain_count)
146 table->chain_count = chain_count;
147 table->entry_count = 0;
148 table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
151 /* Make TABLE's entries ready for reuse. */
154 binding_table_free (binding_table table)
162 for (i = 0, count = table->chain_count; i < count; ++i)
164 binding_entry temp = table->chain[i];
167 binding_entry entry = temp;
169 binding_entry_free (entry);
171 table->chain[i] = NULL;
173 table->entry_count = 0;
177 /* Allocate a table with CHAIN_COUNT, assumed to be a power of two. */
179 static inline binding_table
180 binding_table_new (size_t chain_count)
182 binding_table table = GGC_NEW (struct binding_table_s);
184 binding_table_construct (table, chain_count);
188 /* Expand TABLE to twice its current chain_count. */
191 binding_table_expand (binding_table table)
193 const size_t old_chain_count = table->chain_count;
194 const size_t old_entry_count = table->entry_count;
195 const size_t new_chain_count = 2 * old_chain_count;
196 binding_entry *old_chains = table->chain;
199 binding_table_construct (table, new_chain_count);
200 for (i = 0; i < old_chain_count; ++i)
202 binding_entry entry = old_chains[i];
203 for (; entry != NULL; entry = old_chains[i])
205 const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
206 const size_t j = ENTRY_INDEX (hash, new_chain_count);
208 old_chains[i] = entry->chain;
209 entry->chain = table->chain[j];
210 table->chain[j] = entry;
213 table->entry_count = old_entry_count;
216 /* Insert a binding for NAME to TYPE into TABLE. */
219 binding_table_insert (binding_table table, tree name, tree type)
221 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
222 const size_t i = ENTRY_INDEX (hash, table->chain_count);
223 binding_entry entry = binding_entry_make (name, type);
225 entry->chain = table->chain[i];
226 table->chain[i] = entry;
227 ++table->entry_count;
229 if (3 * table->chain_count < 5 * table->entry_count)
230 binding_table_expand (table);
233 /* Return the binding_entry, if any, that maps NAME. */
236 binding_table_find (binding_table table, tree name)
238 const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
239 binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
241 while (entry != NULL && entry->name != name)
242 entry = entry->chain;
247 /* Apply PROC -- with DATA -- to all entries in TABLE. */
250 binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
252 const size_t chain_count = table->chain_count;
255 for (i = 0; i < chain_count; ++i)
257 binding_entry entry = table->chain[i];
258 for (; entry != NULL; entry = entry->chain)
263 #ifndef ENABLE_SCOPE_CHECKING
264 # define ENABLE_SCOPE_CHECKING 0
266 # define ENABLE_SCOPE_CHECKING 1
269 /* A free list of "cxx_binding"s, connected by their PREVIOUS. */
271 static GTY((deletable)) cxx_binding *free_bindings;
273 /* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
277 cxx_binding_init (cxx_binding *binding, tree value, tree type)
279 binding->value = value;
280 binding->type = type;
281 binding->previous = NULL;
284 /* (GC)-allocate a binding object with VALUE and TYPE member initialized. */
287 cxx_binding_make (tree value, tree type)
289 cxx_binding *binding;
292 binding = free_bindings;
293 free_bindings = binding->previous;
296 binding = GGC_NEW (cxx_binding);
298 cxx_binding_init (binding, value, type);
303 /* Put BINDING back on the free list. */
306 cxx_binding_free (cxx_binding *binding)
308 binding->scope = NULL;
309 binding->previous = free_bindings;
310 free_bindings = binding;
313 /* Create a new binding for NAME (with the indicated VALUE and TYPE
314 bindings) in the class scope indicated by SCOPE. */
317 new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
319 cp_class_binding *cb;
320 cxx_binding *binding;
322 if (VEC_length (cp_class_binding, scope->class_shadowed))
324 cp_class_binding *old_base;
325 old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
326 if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
328 /* Fixup the current bindings, as they might have moved. */
332 VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
336 b = &IDENTIFIER_BINDING (cb->identifier);
337 while (*b != &old_base[i].base)
338 b = &((*b)->previous);
342 cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
345 cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
347 cb->identifier = name;
349 binding->scope = scope;
350 cxx_binding_init (binding, value, type);
354 /* Make DECL the innermost binding for ID. The LEVEL is the binding
355 level at which this declaration is being bound. */
358 push_binding (tree id, tree decl, cxx_scope* level)
360 cxx_binding *binding;
362 if (level != class_binding_level)
364 binding = cxx_binding_make (decl, NULL_TREE);
365 binding->scope = level;
366 /* APPLE LOCAL blocks 6040305 (ch) */
367 binding->declared_in_block = cur_block != 0;
370 binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
372 /* Now, fill in the binding information. */
373 binding->previous = IDENTIFIER_BINDING (id);
374 INHERITED_VALUE_BINDING_P (binding) = 0;
375 LOCAL_BINDING_P (binding) = (level != class_binding_level);
377 /* And put it on the front of the list of bindings for ID. */
378 IDENTIFIER_BINDING (id) = binding;
381 /* Remove the binding for DECL which should be the innermost binding
385 pop_binding (tree id, tree decl)
387 cxx_binding *binding;
390 /* It's easiest to write the loops that call this function without
391 checking whether or not the entities involved have names. We
392 get here for such an entity. */
395 /* Get the innermost binding for ID. */
396 binding = IDENTIFIER_BINDING (id);
398 /* The name should be bound. */
399 gcc_assert (binding != NULL);
401 /* The DECL will be either the ordinary binding or the type
402 binding for this identifier. Remove that binding. */
403 if (binding->value == decl)
404 binding->value = NULL_TREE;
407 gcc_assert (binding->type == decl);
408 binding->type = NULL_TREE;
411 if (!binding->value && !binding->type)
413 /* We're completely done with the innermost binding for this
414 identifier. Unhook it from the list of bindings. */
415 IDENTIFIER_BINDING (id) = binding->previous;
417 /* Add it to the free list. */
418 cxx_binding_free (binding);
422 /* BINDING records an existing declaration for a name in the current scope.
423 But, DECL is another declaration for that same identifier in the
424 same scope. This is the `struct stat' hack whereby a non-typedef
425 class name or enum-name can be bound at the same level as some other
429 A class name (9.1) or enumeration name (7.2) can be hidden by the
430 name of an object, function, or enumerator declared in the same scope.
431 If a class or enumeration name and an object, function, or enumerator
432 are declared in the same scope (in any order) with the same name, the
433 class or enumeration name is hidden wherever the object, function, or
434 enumerator name is visible.
436 It's the responsibility of the caller to check that
437 inserting this name is valid here. Returns nonzero if the new binding
441 supplement_binding (cxx_binding *binding, tree decl)
443 tree bval = binding->value;
446 timevar_push (TV_NAME_LOOKUP);
447 if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
448 /* The new name is the type name. */
449 binding->type = decl;
450 else if (/* BVAL is null when push_class_level_binding moves an
451 inherited type-binding out of the way to make room for a
452 new value binding. */
454 /* BVAL is error_mark_node when DECL's name has been used
455 in a non-class scope prior declaration. In that case,
456 we should have already issued a diagnostic; for graceful
457 error recovery purpose, pretend this was the intended
458 declaration for that name. */
459 || bval == error_mark_node
460 /* If BVAL is anticipated but has not yet been declared,
461 pretend it is not there at all. */
462 || (TREE_CODE (bval) == FUNCTION_DECL
463 && DECL_ANTICIPATED (bval)
464 && !DECL_HIDDEN_FRIEND_P (bval)))
465 binding->value = decl;
466 else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
468 /* The old binding was a type name. It was placed in
469 VALUE field because it was thought, at the point it was
470 declared, to be the only entity with such a name. Move the
471 type name into the type slot; it is now hidden by the new
473 binding->type = bval;
474 binding->value = decl;
475 binding->value_is_inherited = false;
477 else if (TREE_CODE (bval) == TYPE_DECL
478 && TREE_CODE (decl) == TYPE_DECL
479 && DECL_NAME (decl) == DECL_NAME (bval)
480 && binding->scope->kind != sk_class
481 && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
482 /* If either type involves template parameters, we must
483 wait until instantiation. */
484 || uses_template_parms (TREE_TYPE (decl))
485 || uses_template_parms (TREE_TYPE (bval))))
486 /* We have two typedef-names, both naming the same type to have
487 the same name. In general, this is OK because of:
491 In a given scope, a typedef specifier can be used to redefine
492 the name of any type declared in that scope to refer to the
493 type to which it already refers.
495 However, in class scopes, this rule does not apply due to the
496 stricter language in [class.mem] prohibiting redeclarations of
499 /* There can be two block-scope declarations of the same variable,
500 so long as they are `extern' declarations. However, there cannot
501 be two declarations of the same static data member:
505 A member shall not be declared twice in the
506 member-specification. */
507 else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
508 && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
509 && !DECL_CLASS_SCOPE_P (decl))
511 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
514 else if (TREE_CODE (decl) == NAMESPACE_DECL
515 && TREE_CODE (bval) == NAMESPACE_DECL
516 && DECL_NAMESPACE_ALIAS (decl)
517 && DECL_NAMESPACE_ALIAS (bval)
518 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
521 In a declarative region, a namespace-alias-definition can be
522 used to redefine a namespace-alias declared in that declarative
523 region to refer only to the namespace to which it already
528 error ("declaration of %q#D", decl);
529 error ("conflicts with previous declaration %q+#D", bval);
533 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
536 /* Add DECL to the list of things declared in B. */
539 add_decl_to_level (tree decl, cxx_scope *b)
541 if (TREE_CODE (decl) == NAMESPACE_DECL
542 && !DECL_NAMESPACE_ALIAS (decl))
544 TREE_CHAIN (decl) = b->namespaces;
545 b->namespaces = decl;
547 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))
549 TREE_CHAIN (decl) = b->vtables;
554 /* We build up the list in reverse order, and reverse it later if
556 TREE_CHAIN (decl) = b->names;
560 /* If appropriate, add decl to separate list of statics. We
561 include extern variables because they might turn out to be
562 static later. It's OK for this list to contain a few false
564 if (b->kind == sk_namespace)
565 if ((TREE_CODE (decl) == VAR_DECL
566 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
567 || (TREE_CODE (decl) == FUNCTION_DECL
568 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
569 VEC_safe_push (tree, gc, b->static_decls, decl);
573 /* Record a decl-node X as belonging to the current lexical scope.
574 Check for errors (such as an incompatible declaration for the same
575 name already seen in the same scope). IS_FRIEND is true if X is
576 declared as a friend.
578 Returns either X or an old decl for the same name.
579 If an old decl is returned, it may have been smashed
580 to agree with what X says. */
583 pushdecl_maybe_friend (tree x, bool is_friend)
587 int need_new_binding;
589 timevar_push (TV_NAME_LOOKUP);
591 if (x == error_mark_node)
592 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
594 need_new_binding = 1;
596 if (DECL_TEMPLATE_PARM_P (x))
597 /* Template parameters have no context; they are not X::T even
598 when declared within a class or namespace. */
602 if (current_function_decl && x != current_function_decl
603 /* A local declaration for a function doesn't constitute
605 && TREE_CODE (x) != FUNCTION_DECL
606 /* A local declaration for an `extern' variable is in the
607 scope of the current namespace, not the current
609 && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
610 && !DECL_CONTEXT (x))
611 DECL_CONTEXT (x) = current_function_decl;
613 /* If this is the declaration for a namespace-scope function,
614 but the declaration itself is in a local scope, mark the
616 if (TREE_CODE (x) == FUNCTION_DECL
617 && DECL_NAMESPACE_SCOPE_P (x)
618 && current_function_decl
619 && x != current_function_decl)
620 DECL_LOCAL_FUNCTION_P (x) = 1;
623 name = DECL_NAME (x);
626 int different_binding_level = 0;
628 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
629 name = TREE_OPERAND (name, 0);
631 /* In case this decl was explicitly namespace-qualified, look it
632 up in its namespace context. */
633 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
634 t = namespace_binding (name, DECL_CONTEXT (x));
636 t = lookup_name_innermost_nonclass_level (name);
638 /* [basic.link] If there is a visible declaration of an entity
639 with linkage having the same name and type, ignoring entities
640 declared outside the innermost enclosing namespace scope, the
641 block scope declaration declares that same entity and
642 receives the linkage of the previous declaration. */
643 if (! t && current_function_decl && x != current_function_decl
644 && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
645 && DECL_EXTERNAL (x))
647 /* Look in block scope. */
648 t = innermost_non_namespace_value (name);
649 /* Or in the innermost namespace. */
651 t = namespace_binding (name, DECL_CONTEXT (x));
652 /* Does it have linkage? Note that if this isn't a DECL, it's an
653 OVERLOAD, which is OK. */
654 if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
657 different_binding_level = 1;
660 /* If we are declaring a function, and the result of name-lookup
661 was an OVERLOAD, look for an overloaded instance that is
662 actually the same as the function we are declaring. (If
663 there is one, we have to merge our declaration with the
664 previous declaration.) */
665 if (t && TREE_CODE (t) == OVERLOAD)
669 if (TREE_CODE (x) == FUNCTION_DECL)
670 for (match = t; match; match = OVL_NEXT (match))
672 if (decls_match (OVL_CURRENT (match), x))
676 /* Just choose one. */
680 t = OVL_CURRENT (match);
685 if (t && t != error_mark_node)
687 if (different_binding_level)
689 if (decls_match (x, t))
690 /* The standard only says that the local extern
691 inherits linkage from the previous decl; in
692 particular, default args are not shared. Add
693 the decl into a hash table to make sure only
694 the previous decl in this case is seen by the
697 struct cxx_int_tree_map *h;
700 TREE_PUBLIC (x) = TREE_PUBLIC (t);
702 if (cp_function_chain->extern_decl_map == NULL)
703 cp_function_chain->extern_decl_map
704 = htab_create_ggc (20, cxx_int_tree_map_hash,
705 cxx_int_tree_map_eq, NULL);
707 h = GGC_NEW (struct cxx_int_tree_map);
708 h->uid = DECL_UID (x);
710 loc = htab_find_slot_with_hash
711 (cp_function_chain->extern_decl_map, h,
713 *(struct cxx_int_tree_map **) loc = h;
716 else if (TREE_CODE (t) == PARM_DECL)
718 gcc_assert (DECL_CONTEXT (t));
720 /* Check for duplicate params. */
721 if (duplicate_decls (x, t, is_friend))
722 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
724 else if ((DECL_EXTERN_C_FUNCTION_P (x)
725 || DECL_FUNCTION_TEMPLATE_P (x))
726 && is_overloaded_fn (t))
727 /* Don't do anything just yet. */;
728 else if (t == wchar_decl_node)
730 if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
731 pedwarn ("redeclaration of %<wchar_t%> as %qT",
734 /* Throw away the redeclaration. */
735 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
739 tree olddecl = duplicate_decls (x, t, is_friend);
741 /* If the redeclaration failed, we can stop at this
743 if (olddecl == error_mark_node)
744 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
748 if (TREE_CODE (t) == TYPE_DECL)
749 SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
751 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
753 else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
755 /* A redeclaration of main, but not a duplicate of the
760 This function shall not be overloaded. */
761 error ("invalid redeclaration of %q+D", t);
763 /* We don't try to push this declaration since that
765 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
770 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))
771 check_default_args (x);
773 check_template_shadow (x);
775 /* If this is a function conjured up by the backend, massage it
776 so it looks friendly. */
777 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
779 retrofit_lang_decl (x);
780 SET_DECL_LANGUAGE (x, lang_c);
783 if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
785 t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
787 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
788 if (!namespace_bindings_p ())
789 /* We do not need to create a binding for this name;
790 push_overloaded_decl will have already done so if
792 need_new_binding = 0;
794 else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
796 t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
798 add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
799 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
802 /* If declaring a type as a typedef, copy the type (unless we're
803 at line 0), and install this TYPE_DECL as the new type's typedef
804 name. See the extensive comment in ../c-decl.c (pushdecl). */
805 if (TREE_CODE (x) == TYPE_DECL)
807 tree type = TREE_TYPE (x);
808 if (DECL_IS_BUILTIN (x))
810 if (TYPE_NAME (type) == 0)
811 TYPE_NAME (type) = x;
813 else if (type != error_mark_node && TYPE_NAME (type) != x
814 /* We don't want to copy the type when all we're
815 doing is making a TYPE_DECL for the purposes of
817 && (!TYPE_NAME (type)
818 || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x)))
820 DECL_ORIGINAL_TYPE (x) = type;
821 type = build_variant_type_copy (type);
822 TYPE_STUB_DECL (type) = TYPE_STUB_DECL (DECL_ORIGINAL_TYPE (x));
823 TYPE_NAME (type) = x;
824 TREE_TYPE (x) = type;
827 if (type != error_mark_node
829 && TYPE_IDENTIFIER (type))
830 set_identifier_type_value (DECL_NAME (x), x);
833 /* Multiple external decls of the same identifier ought to match.
835 We get warnings about inline functions where they are defined.
836 We get warnings about other functions from push_overloaded_decl.
838 Avoid duplicate warnings where they are used. */
839 if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
843 decl = IDENTIFIER_NAMESPACE_VALUE (name);
844 if (decl && TREE_CODE (decl) == OVERLOAD)
845 decl = OVL_FUNCTION (decl);
847 if (decl && decl != error_mark_node
848 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
849 /* If different sort of thing, we already gave an error. */
850 && TREE_CODE (decl) == TREE_CODE (x)
851 && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
853 pedwarn ("type mismatch with previous external decl of %q#D", x);
854 pedwarn ("previous external decl of %q+#D", decl);
858 if (TREE_CODE (x) == FUNCTION_DECL
860 && !flag_friend_injection)
862 /* This is a new declaration of a friend function, so hide
863 it from ordinary function lookup. */
864 DECL_ANTICIPATED (x) = 1;
865 DECL_HIDDEN_FRIEND_P (x) = 1;
868 /* This name is new in its binding level.
869 Install the new declaration and return it. */
870 if (namespace_bindings_p ())
872 /* Install a global value. */
874 /* If the first global decl has external linkage,
875 warn if we later see static one. */
876 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
877 TREE_PUBLIC (name) = 1;
879 /* Bind the name for the entity. */
880 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
882 && (TREE_CODE (x) == TYPE_DECL
883 || TREE_CODE (x) == VAR_DECL
884 || TREE_CODE (x) == NAMESPACE_DECL
885 || TREE_CODE (x) == CONST_DECL
886 || TREE_CODE (x) == TEMPLATE_DECL))
887 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
889 /* If new decl is `static' and an `extern' was seen previously,
891 if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
892 warn_extern_redeclared_static (x, t);
896 /* Here to install a non-global value. */
897 tree oldlocal = innermost_non_namespace_value (name);
898 tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
900 if (need_new_binding)
902 push_local_binding (name, x, 0);
903 /* Because push_local_binding will hook X on to the
904 current_binding_level's name list, we don't want to
905 do that again below. */
906 need_new_binding = 0;
909 /* If this is a TYPE_DECL, push it into the type value slot. */
910 if (TREE_CODE (x) == TYPE_DECL)
911 set_identifier_type_value (name, x);
913 /* Clear out any TYPE_DECL shadowed by a namespace so that
914 we won't think this is a type. The C struct hack doesn't
915 go through namespaces. */
916 if (TREE_CODE (x) == NAMESPACE_DECL)
917 set_identifier_type_value (name, NULL_TREE);
924 && TREE_CODE (oldlocal) == VAR_DECL
925 && DECL_DEAD_FOR_LOCAL (oldlocal))
926 oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
928 if (oldlocal == NULL_TREE)
929 oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
932 /* If this is an extern function declaration, see if we
933 have a global definition or declaration for the function. */
934 if (oldlocal == NULL_TREE
936 && oldglobal != NULL_TREE
937 && TREE_CODE (x) == FUNCTION_DECL
938 && TREE_CODE (oldglobal) == FUNCTION_DECL)
940 /* We have one. Their types must agree. */
941 if (decls_match (x, oldglobal))
945 warning (0, "extern declaration of %q#D doesn't match", x);
946 warning (0, "global declaration %q+#D", oldglobal);
949 /* If we have a local external declaration,
950 and no file-scope declaration has yet been seen,
951 then if we later have a file-scope decl it must not be static. */
952 if (oldlocal == NULL_TREE
953 && oldglobal == NULL_TREE
956 TREE_PUBLIC (name) = 1;
958 /* Warn if shadowing an argument at the top level of the body. */
959 if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
960 /* Inline decls shadow nothing. */
961 && !DECL_FROM_INLINE (x)
962 && TREE_CODE (oldlocal) == PARM_DECL
963 /* Don't check the `this' parameter. */
964 && !DECL_ARTIFICIAL (oldlocal))
968 /* Don't complain if it's from an enclosing function. */
969 if (DECL_CONTEXT (oldlocal) == current_function_decl
970 && TREE_CODE (x) != PARM_DECL)
972 /* Go to where the parms should be and see if we find
974 struct cp_binding_level *b = current_binding_level->level_chain;
976 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
977 /* Skip the ctor/dtor cleanup level. */
981 if (b->kind == sk_function_parms)
983 error ("declaration of %q#D shadows a parameter", x);
988 if (warn_shadow && !err)
990 warning (OPT_Wshadow, "declaration of %q#D shadows a parameter", x);
991 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
995 /* Maybe warn if shadowing something else. */
996 else if (warn_shadow && !DECL_EXTERNAL (x)
997 /* No shadow warnings for internally generated vars. */
998 && ! DECL_ARTIFICIAL (x)
999 /* No shadow warnings for vars made for inlining. */
1000 && ! DECL_FROM_INLINE (x))
1004 if (current_class_ptr)
1005 member = lookup_member (current_class_type,
1008 /*want_type=*/false);
1012 if (member && !TREE_STATIC (member))
1014 /* Location of previous decl is not useful in this case. */
1015 warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1018 else if (oldlocal != NULL_TREE
1019 && TREE_CODE (oldlocal) == VAR_DECL)
1021 warning (OPT_Wshadow, "declaration of %qD shadows a previous local", x);
1022 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldlocal);
1024 else if (oldglobal != NULL_TREE
1025 && TREE_CODE (oldglobal) == VAR_DECL)
1026 /* XXX shadow warnings in outer-more namespaces */
1028 warning (OPT_Wshadow, "declaration of %qD shadows a global declaration",
1030 warning (OPT_Wshadow, "%Jshadowed declaration is here", oldglobal);
1035 if (TREE_CODE (x) == VAR_DECL)
1036 maybe_register_incomplete_var (x);
1039 if (need_new_binding)
1040 add_decl_to_level (x,
1041 DECL_NAMESPACE_SCOPE_P (x)
1042 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1043 : current_binding_level);
1045 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1048 /* Record a decl-node X as belonging to the current lexical scope. */
1053 return pushdecl_maybe_friend (x, false);
1056 /* Enter DECL into the symbol table, if that's appropriate. Returns
1057 DECL, or a modified version thereof. */
1060 maybe_push_decl (tree decl)
1062 tree type = TREE_TYPE (decl);
1064 /* Add this decl to the current binding level, but not if it comes
1065 from another scope, e.g. a static member variable. TEM may equal
1066 DECL or it may be a previous decl of the same name. */
1067 if (decl == error_mark_node
1068 || (TREE_CODE (decl) != PARM_DECL
1069 && DECL_CONTEXT (decl) != NULL_TREE
1070 /* Definitions of namespace members outside their namespace are
1072 && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1073 || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1074 || TREE_CODE (type) == UNKNOWN_TYPE
1075 /* The declaration of a template specialization does not affect
1076 the functions available for overload resolution, so we do not
1078 || (TREE_CODE (decl) == FUNCTION_DECL
1079 && DECL_TEMPLATE_SPECIALIZATION (decl)))
1082 return pushdecl (decl);
1085 /* Bind DECL to ID in the current_binding_level, assumed to be a local
1086 binding level. If PUSH_USING is set in FLAGS, we know that DECL
1087 doesn't really belong to this binding level, that it got here
1088 through a using-declaration. */
1091 push_local_binding (tree id, tree decl, int flags)
1093 struct cp_binding_level *b;
1095 /* Skip over any local classes. This makes sense if we call
1096 push_local_binding with a friend decl of a local class. */
1097 b = innermost_nonclass_level ();
1099 if (lookup_name_innermost_nonclass_level (id))
1101 /* Supplement the existing binding. */
1102 if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1103 /* It didn't work. Something else must be bound at this
1104 level. Do not add DECL to the list of things to pop
1109 /* Create a new binding. */
1110 push_binding (id, decl, b);
1112 if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1113 /* We must put the OVERLOAD into a TREE_LIST since the
1114 TREE_CHAIN of an OVERLOAD is already used. Similarly for
1115 decls that got here through a using-declaration. */
1116 decl = build_tree_list (NULL_TREE, decl);
1118 /* And put DECL on the list of things declared by the current
1120 add_decl_to_level (decl, b);
1123 /* Check to see whether or not DECL is a variable that would have been
1124 in scope under the ARM, but is not in scope under the ANSI/ISO
1125 standard. If so, issue an error message. If name lookup would
1126 work in both cases, but return a different result, this function
1127 returns the result of ANSI/ISO lookup. Otherwise, it returns
1131 check_for_out_of_scope_variable (tree decl)
1135 /* We only care about out of scope variables. */
1136 if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1139 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1140 ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1141 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1142 && DECL_DEAD_FOR_LOCAL (shadowed))
1143 shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1144 ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1146 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1149 if (!DECL_ERROR_REPORTED (decl))
1151 warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1152 warning (0, " matches this %q+D under ISO standard rules",
1154 warning (0, " matches this %q+D under old rules", decl);
1155 DECL_ERROR_REPORTED (decl) = 1;
1160 /* If we have already complained about this declaration, there's no
1161 need to do it again. */
1162 if (DECL_ERROR_REPORTED (decl))
1165 DECL_ERROR_REPORTED (decl) = 1;
1167 if (TREE_TYPE (decl) == error_mark_node)
1170 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1172 error ("name lookup of %qD changed for new ISO %<for%> scoping",
1174 error (" cannot use obsolete binding at %q+D because "
1175 "it has a destructor", decl);
1176 return error_mark_node;
1180 pedwarn ("name lookup of %qD changed for new ISO %<for%> scoping",
1182 pedwarn (" using obsolete binding at %q+D", decl);
1188 /* true means unconditionally make a BLOCK for the next level pushed. */
1190 static bool keep_next_level_flag;
1192 static int binding_depth = 0;
1193 static int is_class_level = 0;
1200 for (i = 0; i < depth * 2; i++)
1204 /* Return a string describing the kind of SCOPE we have. */
1206 cxx_scope_descriptor (cxx_scope *scope)
1208 /* The order of this table must match the "scope_kind"
1210 static const char* scope_kind_names[] = {
1216 "function-parameter-scope",
1219 "template-parameter-scope",
1220 "template-explicit-spec-scope"
1222 const scope_kind kind = scope->explicit_spec_p
1223 ? sk_template_spec : scope->kind;
1225 return scope_kind_names[kind];
1228 /* Output a debugging information about SCOPE when performing
1231 cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1233 const char *desc = cxx_scope_descriptor (scope);
1234 if (scope->this_entity)
1235 verbatim ("%s %s(%E) %p %d\n", action, desc,
1236 scope->this_entity, (void *) scope, line);
1238 verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1241 /* Return the estimated initial size of the hashtable of a NAMESPACE
1244 static inline size_t
1245 namespace_scope_ht_size (tree ns)
1247 tree name = DECL_NAME (ns);
1249 return name == std_identifier
1250 ? NAMESPACE_STD_HT_SIZE
1251 : (name == global_scope_name
1252 ? GLOBAL_SCOPE_HT_SIZE
1253 : NAMESPACE_ORDINARY_HT_SIZE);
1256 /* A chain of binding_level structures awaiting reuse. */
1258 static GTY((deletable)) struct cp_binding_level *free_binding_level;
1260 /* Insert SCOPE as the innermost binding level. */
1263 push_binding_level (struct cp_binding_level *scope)
1265 /* Add it to the front of currently active scopes stack. */
1266 scope->level_chain = current_binding_level;
1267 current_binding_level = scope;
1268 keep_next_level_flag = false;
1270 if (ENABLE_SCOPE_CHECKING)
1272 scope->binding_depth = binding_depth;
1273 indent (binding_depth);
1274 cxx_scope_debug (scope, input_line, "push");
1280 /* Create a new KIND scope and make it the top of the active scopes stack.
1281 ENTITY is the scope of the associated C++ entity (namespace, class,
1282 function); it is NULL otherwise. */
1285 begin_scope (scope_kind kind, tree entity)
1289 /* Reuse or create a struct for this binding level. */
1290 if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1292 scope = free_binding_level;
1293 free_binding_level = scope->level_chain;
1296 scope = GGC_NEW (cxx_scope);
1297 memset (scope, 0, sizeof (cxx_scope));
1299 scope->this_entity = entity;
1300 scope->more_cleanups_ok = true;
1307 case sk_template_spec:
1308 scope->explicit_spec_p = true;
1309 kind = sk_template_parms;
1311 case sk_template_parms:
1317 case sk_function_parms:
1319 scope->keep = keep_next_level_flag;
1323 NAMESPACE_LEVEL (entity) = scope;
1324 scope->static_decls =
1325 VEC_alloc (tree, gc,
1326 DECL_NAME (entity) == std_identifier
1327 || DECL_NAME (entity) == global_scope_name
1332 /* Should not happen. */
1338 push_binding_level (scope);
1343 /* We're about to leave current scope. Pop the top of the stack of
1344 currently active scopes. Return the enclosing scope, now active. */
1349 cxx_scope *scope = current_binding_level;
1351 if (scope->kind == sk_namespace && class_binding_level)
1352 current_binding_level = class_binding_level;
1354 /* We cannot leave a scope, if there are none left. */
1355 if (NAMESPACE_LEVEL (global_namespace))
1356 gcc_assert (!global_scope_p (scope));
1358 if (ENABLE_SCOPE_CHECKING)
1360 indent (--binding_depth);
1361 cxx_scope_debug (scope, input_line, "leave");
1362 if (is_class_level != (scope == class_binding_level))
1364 indent (binding_depth);
1365 verbatim ("XXX is_class_level != (current_scope == class_scope)\n");
1370 #ifdef HANDLE_PRAGMA_VISIBILITY
1371 if (scope->has_visibility)
1375 /* Move one nesting level up. */
1376 current_binding_level = scope->level_chain;
1378 /* Namespace-scopes are left most probably temporarily, not
1379 completely; they can be reopened later, e.g. in namespace-extension
1380 or any name binding activity that requires us to resume a
1381 namespace. For classes, we cache some binding levels. For other
1382 scopes, we just make the structure available for reuse. */
1383 if (scope->kind != sk_namespace
1384 && scope->kind != sk_class)
1386 scope->level_chain = free_binding_level;
1387 gcc_assert (!ENABLE_SCOPE_CHECKING
1388 || scope->binding_depth == binding_depth);
1389 free_binding_level = scope;
1392 /* Find the innermost enclosing class scope, and reset
1393 CLASS_BINDING_LEVEL appropriately. */
1394 if (scope->kind == sk_class)
1396 class_binding_level = NULL;
1397 for (scope = current_binding_level; scope; scope = scope->level_chain)
1398 if (scope->kind == sk_class)
1400 class_binding_level = scope;
1405 return current_binding_level;
1409 resume_scope (struct cp_binding_level* b)
1411 /* Resuming binding levels is meant only for namespaces,
1412 and those cannot nest into classes. */
1413 gcc_assert (!class_binding_level);
1414 /* Also, resuming a non-directly nested namespace is a no-no. */
1415 gcc_assert (b->level_chain == current_binding_level);
1416 current_binding_level = b;
1417 if (ENABLE_SCOPE_CHECKING)
1419 b->binding_depth = binding_depth;
1420 indent (binding_depth);
1421 cxx_scope_debug (b, input_line, "resume");
1427 /* Return the innermost binding level that is not for a class scope. */
1430 innermost_nonclass_level (void)
1434 b = current_binding_level;
1435 while (b->kind == sk_class)
1441 /* We're defining an object of type TYPE. If it needs a cleanup, but
1442 we're not allowed to add any more objects with cleanups to the current
1443 scope, create a new binding level. */
1446 maybe_push_cleanup_level (tree type)
1448 if (type != error_mark_node
1449 && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1450 && current_binding_level->more_cleanups_ok == 0)
1452 begin_scope (sk_cleanup, NULL);
1453 current_binding_level->statement_list = push_stmt_list ();
1457 /* Nonzero if we are currently in the global binding level. */
1460 global_bindings_p (void)
1462 return global_scope_p (current_binding_level);
1465 /* True if we are currently in a toplevel binding level. This
1466 means either the global binding level or a namespace in a toplevel
1467 binding level. Since there are no non-toplevel namespace levels,
1468 this really means any namespace or template parameter level. We
1469 also include a class whose context is toplevel. */
1472 toplevel_bindings_p (void)
1474 struct cp_binding_level *b = innermost_nonclass_level ();
1476 return b->kind == sk_namespace || b->kind == sk_template_parms;
1479 /* True if this is a namespace scope, or if we are defining a class
1480 which is itself at namespace scope, or whose enclosing class is
1481 such a class, etc. */
1484 namespace_bindings_p (void)
1486 struct cp_binding_level *b = innermost_nonclass_level ();
1488 return b->kind == sk_namespace;
1491 /* True if the current level needs to have a BLOCK made. */
1496 return (current_binding_level->blocks != NULL_TREE
1497 || current_binding_level->keep
1498 || current_binding_level->kind == sk_cleanup
1499 || current_binding_level->names != NULL_TREE);
1502 /* Returns the kind of the innermost scope. */
1505 innermost_scope_kind (void)
1507 return current_binding_level->kind;
1510 /* Returns true if this scope was created to store template parameters. */
1513 template_parm_scope_p (void)
1515 return innermost_scope_kind () == sk_template_parms;
1518 /* If KEEP is true, make a BLOCK node for the next binding level,
1519 unconditionally. Otherwise, use the normal logic to decide whether
1520 or not to create a BLOCK. */
1523 keep_next_level (bool keep)
1525 keep_next_level_flag = keep;
1528 /* Return the list of declarations of the current level.
1529 Note that this list is in reverse order unless/until
1530 you nreverse it; and when you do nreverse it, you must
1531 store the result back using `storedecls' or you will lose. */
1536 return current_binding_level->names;
1539 /* For debugging. */
1540 static int no_print_functions = 0;
1541 static int no_print_builtins = 0;
1544 print_binding_level (struct cp_binding_level* lvl)
1548 fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1549 if (lvl->more_cleanups_ok)
1550 fprintf (stderr, " more-cleanups-ok");
1551 if (lvl->have_cleanups)
1552 fprintf (stderr, " have-cleanups");
1553 fprintf (stderr, "\n");
1556 fprintf (stderr, " names:\t");
1557 /* We can probably fit 3 names to a line? */
1558 for (t = lvl->names; t; t = TREE_CHAIN (t))
1560 if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1562 if (no_print_builtins
1563 && (TREE_CODE (t) == TYPE_DECL)
1564 && DECL_IS_BUILTIN (t))
1567 /* Function decls tend to have longer names. */
1568 if (TREE_CODE (t) == FUNCTION_DECL)
1575 fprintf (stderr, "\n\t");
1578 print_node_brief (stderr, "", t, 0);
1579 if (t == error_mark_node)
1583 fprintf (stderr, "\n");
1585 if (VEC_length (cp_class_binding, lvl->class_shadowed))
1588 cp_class_binding *b;
1589 fprintf (stderr, " class-shadowed:");
1591 VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1593 fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1594 fprintf (stderr, "\n");
1596 if (lvl->type_shadowed)
1598 fprintf (stderr, " type-shadowed:");
1599 for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1601 fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1603 fprintf (stderr, "\n");
1608 print_other_binding_stack (struct cp_binding_level *stack)
1610 struct cp_binding_level *level;
1611 for (level = stack; !global_scope_p (level); level = level->level_chain)
1613 fprintf (stderr, "binding level %p\n", (void *) level);
1614 print_binding_level (level);
1619 print_binding_stack (void)
1621 struct cp_binding_level *b;
1622 fprintf (stderr, "current_binding_level=%p\n"
1623 "class_binding_level=%p\n"
1624 "NAMESPACE_LEVEL (global_namespace)=%p\n",
1625 (void *) current_binding_level, (void *) class_binding_level,
1626 (void *) NAMESPACE_LEVEL (global_namespace));
1627 if (class_binding_level)
1629 for (b = class_binding_level; b; b = b->level_chain)
1630 if (b == current_binding_level)
1633 b = class_binding_level;
1635 b = current_binding_level;
1638 b = current_binding_level;
1639 print_other_binding_stack (b);
1640 fprintf (stderr, "global:\n");
1641 print_binding_level (NAMESPACE_LEVEL (global_namespace));
1644 /* Return the type associated with id. */
1647 identifier_type_value (tree id)
1649 timevar_push (TV_NAME_LOOKUP);
1650 /* There is no type with that name, anywhere. */
1651 if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1652 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1653 /* This is not the type marker, but the real thing. */
1654 if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1655 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1656 /* Have to search for it. It must be on the global level, now.
1657 Ask lookup_name not to return non-types. */
1658 id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1661 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1664 /* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1665 the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++. */
1668 identifier_global_value (tree t)
1670 return IDENTIFIER_GLOBAL_VALUE (t);
1673 /* Push a definition of struct, union or enum tag named ID. into
1674 binding_level B. DECL is a TYPE_DECL for the type. We assume that
1675 the tag ID is not already defined. */
1678 set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1682 if (b->kind != sk_namespace)
1684 /* Shadow the marker, not the real thing, so that the marker
1685 gets restored later. */
1686 tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1688 = tree_cons (id, old_type_value, b->type_shadowed);
1689 type = decl ? TREE_TYPE (decl) : NULL_TREE;
1690 TREE_TYPE (b->type_shadowed) = type;
1694 cxx_binding *binding =
1695 binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1698 supplement_binding (binding, decl);
1700 binding->value = decl;
1702 /* Store marker instead of real type. */
1703 type = global_type_node;
1705 SET_IDENTIFIER_TYPE_VALUE (id, type);
1708 /* As set_identifier_type_value_with_scope, but using
1709 current_binding_level. */
1712 set_identifier_type_value (tree id, tree decl)
1714 set_identifier_type_value_with_scope (id, decl, current_binding_level);
1717 /* Return the name for the constructor (or destructor) for the
1718 specified class TYPE. When given a template, this routine doesn't
1719 lose the specialization. */
1722 constructor_name_full (tree type)
1724 return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1727 /* Return the name for the constructor (or destructor) for the
1728 specified class. When given a template, return the plain
1729 unspecialized name. */
1732 constructor_name (tree type)
1735 name = constructor_name_full (type);
1736 if (IDENTIFIER_TEMPLATE (name))
1737 name = IDENTIFIER_TEMPLATE (name);
1741 /* Returns TRUE if NAME is the name for the constructor for TYPE. */
1744 constructor_name_p (tree name, tree type)
1751 if (TREE_CODE (name) != IDENTIFIER_NODE)
1754 ctor_name = constructor_name_full (type);
1755 if (name == ctor_name)
1757 if (IDENTIFIER_TEMPLATE (ctor_name)
1758 && name == IDENTIFIER_TEMPLATE (ctor_name))
1763 /* Counter used to create anonymous type names. */
1765 static GTY(()) int anon_cnt;
1767 /* Return an IDENTIFIER which can be used as a name for
1768 anonymous structs and unions. */
1771 make_anon_name (void)
1775 sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1776 return get_identifier (buf);
1779 /* Return (from the stack of) the BINDING, if any, established at SCOPE. */
1781 static inline cxx_binding *
1782 find_binding (cxx_scope *scope, cxx_binding *binding)
1784 timevar_push (TV_NAME_LOOKUP);
1786 for (; binding != NULL; binding = binding->previous)
1787 if (binding->scope == scope)
1788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1790 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1793 /* Return the binding for NAME in SCOPE, if any. Otherwise, return NULL. */
1795 static inline cxx_binding *
1796 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1798 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1801 /* Fold-in case where NAME is used only once. */
1802 if (scope == b->scope && b->previous == NULL)
1804 return find_binding (scope, b);
1809 /* Always returns a binding for name in scope. If no binding is
1810 found, make a new one. */
1812 static cxx_binding *
1813 binding_for_name (cxx_scope *scope, tree name)
1815 cxx_binding *result;
1817 result = cxx_scope_find_binding_for_name (scope, name);
1820 /* Not found, make a new one. */
1821 result = cxx_binding_make (NULL, NULL);
1822 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1823 result->scope = scope;
1824 result->is_local = false;
1825 result->value_is_inherited = false;
1826 /* APPLE LOCAL blocks 6040305 (ch) */
1827 result->declared_in_block = 0;
1828 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1832 /* Insert another USING_DECL into the current binding level, returning
1833 this declaration. If this is a redeclaration, do nothing, and
1834 return NULL_TREE if this not in namespace scope (in namespace
1835 scope, a using decl might extend any previous bindings). */
1838 push_using_decl (tree scope, tree name)
1842 timevar_push (TV_NAME_LOOKUP);
1843 gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1844 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1845 for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1846 if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1849 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1850 namespace_bindings_p () ? decl : NULL_TREE);
1851 decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1852 USING_DECL_SCOPE (decl) = scope;
1853 TREE_CHAIN (decl) = current_binding_level->usings;
1854 current_binding_level->usings = decl;
1855 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1858 /* Same as pushdecl, but define X in binding-level LEVEL. We rely on the
1859 caller to set DECL_CONTEXT properly. */
1862 pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1864 struct cp_binding_level *b;
1865 tree function_decl = current_function_decl;
1867 timevar_push (TV_NAME_LOOKUP);
1868 current_function_decl = NULL_TREE;
1869 if (level->kind == sk_class)
1871 b = class_binding_level;
1872 class_binding_level = level;
1873 pushdecl_class_level (x);
1874 class_binding_level = b;
1878 b = current_binding_level;
1879 current_binding_level = level;
1880 x = pushdecl_maybe_friend (x, is_friend);
1881 current_binding_level = b;
1883 current_function_decl = function_decl;
1884 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1887 /* DECL is a FUNCTION_DECL for a non-member function, which may have
1888 other definitions already in place. We get around this by making
1889 the value of the identifier point to a list of all the things that
1890 want to be referenced by that name. It is then up to the users of
1891 that name to decide what to do with that list.
1893 DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
1894 DECL_TEMPLATE_RESULT. It is dealt with the same way.
1896 FLAGS is a bitwise-or of the following values:
1897 PUSH_LOCAL: Bind DECL in the current scope, rather than at
1899 PUSH_USING: DECL is being pushed as the result of a using
1902 IS_FRIEND is true if this is a friend declaration.
1904 The value returned may be a previous declaration if we guessed wrong
1905 about what language DECL should belong to (C or C++). Otherwise,
1906 it's always DECL (and never something that's not a _DECL). */
1909 push_overloaded_decl (tree decl, int flags, bool is_friend)
1911 tree name = DECL_NAME (decl);
1914 int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
1916 timevar_push (TV_NAME_LOOKUP);
1918 old = namespace_binding (name, DECL_CONTEXT (decl));
1920 old = lookup_name_innermost_nonclass_level (name);
1924 if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
1926 tree t = TREE_TYPE (old);
1927 if (IS_AGGR_TYPE (t) && warn_shadow
1928 && (! DECL_IN_SYSTEM_HEADER (decl)
1929 || ! DECL_IN_SYSTEM_HEADER (old)))
1930 warning (0, "%q#D hides constructor for %q#T", decl, t);
1933 else if (is_overloaded_fn (old))
1937 for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
1939 tree fn = OVL_CURRENT (tmp);
1942 if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
1943 && !(flags & PUSH_USING)
1944 && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
1945 TYPE_ARG_TYPES (TREE_TYPE (decl)))
1946 && ! decls_match (fn, decl))
1947 error ("%q#D conflicts with previous using declaration %q#D",
1950 dup = duplicate_decls (decl, fn, is_friend);
1951 /* If DECL was a redeclaration of FN -- even an invalid
1952 one -- pass that information along to our caller. */
1953 if (dup == fn || dup == error_mark_node)
1954 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
1957 /* We don't overload implicit built-ins. duplicate_decls()
1958 may fail to merge the decls if the new decl is e.g. a
1959 template function. */
1960 if (TREE_CODE (old) == FUNCTION_DECL
1961 && DECL_ANTICIPATED (old)
1962 && !DECL_HIDDEN_FRIEND_P (old))
1965 else if (old == error_mark_node)
1966 /* Ignore the undefined symbol marker. */
1970 error ("previous non-function declaration %q+#D", old);
1971 error ("conflicts with function declaration %q#D", decl);
1972 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1976 if (old || TREE_CODE (decl) == TEMPLATE_DECL
1977 /* If it's a using declaration, we always need to build an OVERLOAD,
1978 because it's the only way to remember that the declaration comes
1979 from 'using', and have the lookup behave correctly. */
1980 || (flags & PUSH_USING))
1982 if (old && TREE_CODE (old) != OVERLOAD)
1983 new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
1985 new_binding = ovl_cons (decl, old);
1986 if (flags & PUSH_USING)
1987 OVL_USED (new_binding) = 1;
1990 /* NAME is not ambiguous. */
1994 set_namespace_binding (name, current_namespace, new_binding);
1997 /* We only create an OVERLOAD if there was a previous binding at
1998 this level, or if decl is a template. In the former case, we
1999 need to remove the old binding and replace it with the new
2000 binding. We must also run through the NAMES on the binding
2001 level where the name was bound to update the chain. */
2003 if (TREE_CODE (new_binding) == OVERLOAD && old)
2007 for (d = &IDENTIFIER_BINDING (name)->scope->names;
2009 d = &TREE_CHAIN (*d))
2011 || (TREE_CODE (*d) == TREE_LIST
2012 && TREE_VALUE (*d) == old))
2014 if (TREE_CODE (*d) == TREE_LIST)
2015 /* Just replace the old binding with the new. */
2016 TREE_VALUE (*d) = new_binding;
2018 /* Build a TREE_LIST to wrap the OVERLOAD. */
2019 *d = tree_cons (NULL_TREE, new_binding,
2022 /* And update the cxx_binding node. */
2023 IDENTIFIER_BINDING (name)->value = new_binding;
2024 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2027 /* We should always find a previous binding in this case. */
2031 /* Install the new binding. */
2032 push_local_binding (name, new_binding, flags);
2035 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2038 /* Check a non-member using-declaration. Return the name and scope
2039 being used, and the USING_DECL, or NULL_TREE on failure. */
2042 validate_nonmember_using_decl (tree decl, tree scope, tree name)
2044 /* [namespace.udecl]
2045 A using-declaration for a class member shall be a
2046 member-declaration. */
2049 error ("%qT is not a namespace", scope);
2052 else if (scope == error_mark_node)
2055 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2058 A using-declaration shall not name a template-id. */
2059 error ("a using-declaration cannot specify a template-id. "
2060 "Try %<using %D%>", name);
2064 if (TREE_CODE (decl) == NAMESPACE_DECL)
2066 error ("namespace %qD not allowed in using-declaration", decl);
2070 if (TREE_CODE (decl) == SCOPE_REF)
2072 /* It's a nested name with template parameter dependent scope.
2073 This can only be using-declaration for class member. */
2074 error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2078 if (is_overloaded_fn (decl))
2079 decl = get_first_fn (decl);
2081 gcc_assert (DECL_P (decl));
2083 /* Make a USING_DECL. */
2084 return push_using_decl (scope, name);
2087 /* Process local and global using-declarations. */
2090 do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2091 tree *newval, tree *newtype)
2093 struct scope_binding decls = EMPTY_SCOPE_BINDING;
2095 *newval = *newtype = NULL_TREE;
2096 if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2100 if (!decls.value && !decls.type)
2102 error ("%qD not declared", name);
2106 /* LLVM LOCAL begin mainline */
2107 /* Shift the old and new bindings around so we're comparing class and
2108 enumeration names to each other. */
2109 if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2115 if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2117 decls.type = decls.value;
2118 decls.value = NULL_TREE;
2120 /* LLVM LOCAL end mainline */
2122 /* It is impossible to overload a built-in function; any explicit
2123 declaration eliminates the built-in declaration. So, if OLDVAL
2124 is a built-in, then we can just pretend it isn't there. */
2126 && TREE_CODE (oldval) == FUNCTION_DECL
2127 && DECL_ANTICIPATED (oldval)
2128 && !DECL_HIDDEN_FRIEND_P (oldval))
2131 /* LLVM LOCAL begin mainline */
2134 /* Check for using functions. */
2135 if (is_overloaded_fn (decls.value))
2139 if (oldval && !is_overloaded_fn (oldval))
2141 error ("%qD is already declared in this scope", name);
2146 for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2148 tree new_fn = OVL_CURRENT (tmp);
2150 /* [namespace.udecl]
2152 If a function declaration in namespace scope or block
2153 scope has the same name and the same parameter types as a
2154 function introduced by a using declaration the program is
2156 for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2158 tree old_fn = OVL_CURRENT (tmp1);
2160 if (new_fn == old_fn)
2161 /* The function already exists in the current namespace. */
2163 else if (OVL_USED (tmp1))
2164 continue; /* this is a using decl */
2165 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2166 TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2168 gcc_assert (!DECL_ANTICIPATED (old_fn)
2169 || DECL_HIDDEN_FRIEND_P (old_fn));
2171 /* There was already a non-using declaration in
2172 this scope with the same parameter types. If both
2173 are the same extern "C" functions, that's ok. */
2174 if (decls_match (new_fn, old_fn))
2178 error ("%qD is already declared in this scope", name);
2184 /* If we broke out of the loop, there's no reason to add
2185 this function to the using declarations for this
2190 /* If we are adding to an existing OVERLOAD, then we no
2191 longer know the type of the set of functions. */
2192 if (*newval && TREE_CODE (*newval) == OVERLOAD)
2193 TREE_TYPE (*newval) = unknown_type_node;
2194 /* Add this new function to the set. */
2195 *newval = build_overload (OVL_CURRENT (tmp), *newval);
2196 /* If there is only one function, then we use its type. (A
2197 using-declaration naming a single function can be used in
2198 contexts where overload resolution cannot be
2200 if (TREE_CODE (*newval) != OVERLOAD)
2202 *newval = ovl_cons (*newval, NULL_TREE);
2203 TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2205 OVL_USED (*newval) = 1;
2210 *newval = decls.value;
2211 if (oldval && !decls_match (*newval, oldval))
2212 error ("%qD is already declared in this scope", name);
2218 if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2220 error ("reference to %qD is ambiguous", name);
2221 print_candidates (decls.type);
2225 *newtype = decls.type;
2226 if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2227 error ("%qD is already declared in this scope", name);
2230 /* If *newval is empty, shift any class or enumeration name down. */
2234 *newtype = NULL_TREE;
2236 /* LLVM LOCAL end mainline */
2239 /* Process a using-declaration at function scope. */
2242 do_local_using_decl (tree decl, tree scope, tree name)
2244 tree oldval, oldtype, newval, newtype;
2245 tree orig_decl = decl;
2247 decl = validate_nonmember_using_decl (decl, scope, name);
2248 if (decl == NULL_TREE)
2251 if (building_stmt_tree ()
2252 && at_function_scope_p ())
2253 add_decl_expr (decl);
2255 oldval = lookup_name_innermost_nonclass_level (name);
2256 oldtype = lookup_type_current_level (name);
2258 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2262 if (is_overloaded_fn (newval))
2266 /* We only need to push declarations for those functions
2267 that were not already bound in the current level.
2268 The old value might be NULL_TREE, it might be a single
2269 function, or an OVERLOAD. */
2270 if (oldval && TREE_CODE (oldval) == OVERLOAD)
2271 term = OVL_FUNCTION (oldval);
2274 for (fn = newval; fn && OVL_CURRENT (fn) != term;
2276 push_overloaded_decl (OVL_CURRENT (fn),
2277 PUSH_LOCAL | PUSH_USING,
2281 push_local_binding (name, newval, PUSH_USING);
2285 push_local_binding (name, newtype, PUSH_USING);
2286 set_identifier_type_value (name, newtype);
2289 /* Emit debug info. */
2290 if (!processing_template_decl)
2291 cp_emit_debug_info_for_using (orig_decl, current_scope());
2294 /* Returns true if ROOT (a namespace, class, or function) encloses
2295 CHILD. CHILD may be either a class type or a namespace. */
2298 is_ancestor (tree root, tree child)
2300 gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2301 || TREE_CODE (root) == FUNCTION_DECL
2302 || CLASS_TYPE_P (root)));
2303 gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2304 || CLASS_TYPE_P (child)));
2306 /* The global namespace encloses everything. */
2307 if (root == global_namespace)
2312 /* If we've run out of scopes, stop. */
2315 /* If we've reached the ROOT, it encloses CHILD. */
2318 /* Go out one level. */
2320 child = TYPE_NAME (child);
2321 child = DECL_CONTEXT (child);
2325 /* Enter the class or namespace scope indicated by T suitable for name
2326 lookup. T can be arbitrary scope, not necessary nested inside the
2327 current scope. Returns a non-null scope to pop iff pop_scope
2328 should be called later to exit this scope. */
2333 if (TREE_CODE (t) == NAMESPACE_DECL)
2334 push_decl_namespace (t);
2335 else if (CLASS_TYPE_P (t))
2337 if (!at_class_scope_p ()
2338 || !same_type_p (current_class_type, t))
2339 push_nested_class (t);
2341 /* T is the same as the current scope. There is therefore no
2342 need to re-enter the scope. Since we are not actually
2343 pushing a new scope, our caller should not call
2351 /* Leave scope pushed by push_scope. */
2356 if (TREE_CODE (t) == NAMESPACE_DECL)
2357 pop_decl_namespace ();
2358 else if CLASS_TYPE_P (t)
2359 pop_nested_class ();
2362 /* Subroutine of push_inner_scope. */
2365 push_inner_scope_r (tree outer, tree inner)
2370 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2373 prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2375 push_inner_scope_r (outer, prev);
2376 if (TREE_CODE (inner) == NAMESPACE_DECL)
2378 struct cp_binding_level *save_template_parm = 0;
2379 /* Temporary take out template parameter scopes. They are saved
2380 in reversed order in save_template_parm. */
2381 while (current_binding_level->kind == sk_template_parms)
2383 struct cp_binding_level *b = current_binding_level;
2384 current_binding_level = b->level_chain;
2385 b->level_chain = save_template_parm;
2386 save_template_parm = b;
2389 resume_scope (NAMESPACE_LEVEL (inner));
2390 current_namespace = inner;
2392 /* Restore template parameter scopes. */
2393 while (save_template_parm)
2395 struct cp_binding_level *b = save_template_parm;
2396 save_template_parm = b->level_chain;
2397 b->level_chain = current_binding_level;
2398 current_binding_level = b;
2405 /* Enter the scope INNER from current scope. INNER must be a scope
2406 nested inside current scope. This works with both name lookup and
2407 pushing name into scope. In case a template parameter scope is present,
2408 namespace is pushed under the template parameter scope according to
2409 name lookup rule in 14.6.1/6.
2411 Return the former current scope suitable for pop_inner_scope. */
2414 push_inner_scope (tree inner)
2416 tree outer = current_scope ();
2418 outer = current_namespace;
2420 push_inner_scope_r (outer, inner);
2424 /* Exit the current scope INNER back to scope OUTER. */
2427 pop_inner_scope (tree outer, tree inner)
2430 || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2433 while (outer != inner)
2435 if (TREE_CODE (inner) == NAMESPACE_DECL)
2437 struct cp_binding_level *save_template_parm = 0;
2438 /* Temporary take out template parameter scopes. They are saved
2439 in reversed order in save_template_parm. */
2440 while (current_binding_level->kind == sk_template_parms)
2442 struct cp_binding_level *b = current_binding_level;
2443 current_binding_level = b->level_chain;
2444 b->level_chain = save_template_parm;
2445 save_template_parm = b;
2450 /* Restore template parameter scopes. */
2451 while (save_template_parm)
2453 struct cp_binding_level *b = save_template_parm;
2454 save_template_parm = b->level_chain;
2455 b->level_chain = current_binding_level;
2456 current_binding_level = b;
2462 inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2466 /* Do a pushlevel for class declarations. */
2469 pushlevel_class (void)
2471 if (ENABLE_SCOPE_CHECKING)
2474 class_binding_level = begin_scope (sk_class, current_class_type);
2477 /* ...and a poplevel for class declarations. */
2480 poplevel_class (void)
2482 struct cp_binding_level *level = class_binding_level;
2483 cp_class_binding *cb;
2487 timevar_push (TV_NAME_LOOKUP);
2488 gcc_assert (level != 0);
2490 /* If we're leaving a toplevel class, cache its binding level. */
2491 if (current_class_depth == 1)
2492 previous_class_level = level;
2493 for (shadowed = level->type_shadowed;
2495 shadowed = TREE_CHAIN (shadowed))
2496 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2498 /* Remove the bindings for all of the class-level declarations. */
2499 if (level->class_shadowed)
2502 VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2504 IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2505 ggc_free (level->class_shadowed);
2506 level->class_shadowed = NULL;
2509 /* Now, pop out of the binding level which we created up in the
2510 `pushlevel_class' routine. */
2511 if (ENABLE_SCOPE_CHECKING)
2515 timevar_pop (TV_NAME_LOOKUP);
2518 /* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2519 appropriate. DECL is the value to which a name has just been
2520 bound. CLASS_TYPE is the class in which the lookup occurred. */
2523 set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2526 if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2530 if (TREE_CODE (decl) == OVERLOAD)
2531 context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2534 gcc_assert (DECL_P (decl));
2535 context = context_for_name_lookup (decl);
2538 if (is_properly_derived_from (class_type, context))
2539 INHERITED_VALUE_BINDING_P (binding) = 1;
2541 INHERITED_VALUE_BINDING_P (binding) = 0;
2543 else if (binding->value == decl)
2544 /* We only encounter a TREE_LIST when there is an ambiguity in the
2545 base classes. Such an ambiguity can be overridden by a
2546 definition in this class. */
2547 INHERITED_VALUE_BINDING_P (binding) = 1;
2549 INHERITED_VALUE_BINDING_P (binding) = 0;
2552 /* Make the declaration of X appear in CLASS scope. */
2555 pushdecl_class_level (tree x)
2558 bool is_valid = true;
2560 timevar_push (TV_NAME_LOOKUP);
2561 /* Get the name of X. */
2562 if (TREE_CODE (x) == OVERLOAD)
2563 name = DECL_NAME (get_first_fn (x));
2565 name = DECL_NAME (x);
2569 is_valid = push_class_level_binding (name, x);
2570 if (TREE_CODE (x) == TYPE_DECL)
2571 set_identifier_type_value (name, x);
2573 else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2575 /* If X is an anonymous aggregate, all of its members are
2576 treated as if they were members of the class containing the
2577 aggregate, for naming purposes. */
2580 for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2582 location_t save_location = input_location;
2583 input_location = DECL_SOURCE_LOCATION (f);
2584 if (!pushdecl_class_level (f))
2586 input_location = save_location;
2589 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2592 /* Return the BINDING (if any) for NAME in SCOPE, which is a class
2593 scope. If the value returned is non-NULL, and the PREVIOUS field
2594 is not set, callers must set the PREVIOUS field explicitly. */
2596 static cxx_binding *
2597 get_class_binding (tree name, cxx_scope *scope)
2602 cxx_binding *binding;
2604 class_type = scope->this_entity;
2606 /* Get the type binding. */
2607 type_binding = lookup_member (class_type, name,
2608 /*protect=*/2, /*want_type=*/true);
2609 /* Get the value binding. */
2610 value_binding = lookup_member (class_type, name,
2611 /*protect=*/2, /*want_type=*/false);
2614 && (TREE_CODE (value_binding) == TYPE_DECL
2615 || DECL_CLASS_TEMPLATE_P (value_binding)
2616 || (TREE_CODE (value_binding) == TREE_LIST
2617 && TREE_TYPE (value_binding) == error_mark_node
2618 && (TREE_CODE (TREE_VALUE (value_binding))
2620 /* We found a type binding, even when looking for a non-type
2621 binding. This means that we already processed this binding
2624 else if (value_binding)
2626 if (TREE_CODE (value_binding) == TREE_LIST
2627 && TREE_TYPE (value_binding) == error_mark_node)
2628 /* NAME is ambiguous. */
2630 else if (BASELINK_P (value_binding))
2631 /* NAME is some overloaded functions. */
2632 value_binding = BASELINK_FUNCTIONS (value_binding);
2635 /* If we found either a type binding or a value binding, create a
2636 new binding object. */
2637 if (type_binding || value_binding)
2639 binding = new_class_binding (name,
2643 /* This is a class-scope binding, not a block-scope binding. */
2644 LOCAL_BINDING_P (binding) = 0;
2645 set_inherited_value_binding_p (binding, value_binding, class_type);
2653 /* Make the declaration(s) of X appear in CLASS scope under the name
2654 NAME. Returns true if the binding is valid. */
2657 push_class_level_binding (tree name, tree x)
2659 cxx_binding *binding;
2663 timevar_push (TV_NAME_LOOKUP);
2664 /* The class_binding_level will be NULL if x is a template
2665 parameter name in a member template. */
2666 if (!class_binding_level)
2667 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2669 if (name == error_mark_node)
2670 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2672 /* Check for invalid member names. */
2673 gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2674 /* We could have been passed a tree list if this is an ambiguous
2675 declaration. If so, pull the declaration out because
2676 check_template_shadow will not handle a TREE_LIST. */
2677 if (TREE_CODE (decl) == TREE_LIST
2678 && TREE_TYPE (decl) == error_mark_node)
2679 decl = TREE_VALUE (decl);
2681 check_template_shadow (decl);
2685 If T is the name of a class, then each of the following shall
2686 have a name different from T:
2688 -- every static data member of class T;
2690 -- every member of class T that is itself a type;
2692 -- every enumerator of every member of class T that is an
2695 -- every member of every anonymous union that is a member of
2698 (Non-static data members were also forbidden to have the same
2699 name as T until TC1.) */
2700 if ((TREE_CODE (x) == VAR_DECL
2701 || TREE_CODE (x) == CONST_DECL
2702 || (TREE_CODE (x) == TYPE_DECL
2703 && !DECL_SELF_REFERENCE_P (x))
2704 /* A data member of an anonymous union. */
2705 || (TREE_CODE (x) == FIELD_DECL
2706 && DECL_CONTEXT (x) != current_class_type))
2707 && DECL_NAME (x) == constructor_name (current_class_type))
2709 tree scope = context_for_name_lookup (x);
2710 if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2712 error ("%qD has the same name as the class in which it is "
2715 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2719 /* Get the current binding for NAME in this class, if any. */
2720 binding = IDENTIFIER_BINDING (name);
2721 if (!binding || binding->scope != class_binding_level)
2723 binding = get_class_binding (name, class_binding_level);
2724 /* If a new binding was created, put it at the front of the
2725 IDENTIFIER_BINDING list. */
2728 binding->previous = IDENTIFIER_BINDING (name);
2729 IDENTIFIER_BINDING (name) = binding;
2733 /* If there is already a binding, then we may need to update the
2735 if (binding && binding->value)
2737 tree bval = binding->value;
2738 tree old_decl = NULL_TREE;
2740 if (INHERITED_VALUE_BINDING_P (binding))
2742 /* If the old binding was from a base class, and was for a
2743 tag name, slide it over to make room for the new binding.
2744 The old binding is still visible if explicitly qualified
2745 with a class-key. */
2746 if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2747 && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2749 old_decl = binding->type;
2750 binding->type = bval;
2751 binding->value = NULL_TREE;
2752 INHERITED_VALUE_BINDING_P (binding) = 0;
2757 /* Any inherited type declaration is hidden by the type
2758 declaration in the derived class. */
2759 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2760 binding->type = NULL_TREE;
2763 else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2765 else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2766 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2767 else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2769 else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2770 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2772 if (old_decl && binding->scope == class_binding_level)
2775 /* It is always safe to clear INHERITED_VALUE_BINDING_P
2776 here. This function is only used to register bindings
2777 from with the class definition itself. */
2778 INHERITED_VALUE_BINDING_P (binding) = 0;
2779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2783 /* Note that we declared this value so that we can issue an error if
2784 this is an invalid redeclaration of a name already used for some
2786 note_name_declared_in_class (name, decl);
2788 /* If we didn't replace an existing binding, put the binding on the
2789 stack of bindings for the identifier, and update the shadowed
2791 if (binding && binding->scope == class_binding_level)
2792 /* Supplement the existing binding. */
2793 ok = supplement_binding (binding, decl);
2796 /* Create a new binding. */
2797 push_binding (name, decl, class_binding_level);
2801 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2804 /* Process "using SCOPE::NAME" in a class scope. Return the
2805 USING_DECL created. */
2808 do_class_using_decl (tree scope, tree name)
2810 /* The USING_DECL returned by this function. */
2812 /* The declaration (or declarations) name by this using
2813 declaration. NULL if we are in a template and cannot figure out
2814 what has been named. */
2816 /* True if SCOPE is a dependent type. */
2817 bool scope_dependent_p;
2818 /* True if SCOPE::NAME is dependent. */
2819 bool name_dependent_p;
2820 /* True if any of the bases of CURRENT_CLASS_TYPE are dependent. */
2821 bool bases_dependent_p;
2826 if (name == error_mark_node)
2829 if (!scope || !TYPE_P (scope))
2831 error ("using-declaration for non-member at class scope");
2835 /* Make sure the name is not invalid */
2836 if (TREE_CODE (name) == BIT_NOT_EXPR)
2838 error ("%<%T::%D%> names destructor", scope, name);
2841 if (constructor_name_p (name, scope))
2843 error ("%<%T::%D%> names constructor", scope, name);
2846 if (constructor_name_p (name, current_class_type))
2848 error ("%<%T::%D%> names constructor in %qT",
2849 scope, name, current_class_type);
2853 scope_dependent_p = dependent_type_p (scope);
2854 name_dependent_p = (scope_dependent_p
2855 || (IDENTIFIER_TYPENAME_P (name)
2856 && dependent_type_p (TREE_TYPE (name))));
2858 bases_dependent_p = false;
2859 if (processing_template_decl)
2860 for (binfo = TYPE_BINFO (current_class_type), i = 0;
2861 BINFO_BASE_ITERATE (binfo, i, base_binfo);
2863 if (dependent_type_p (TREE_TYPE (base_binfo)))
2865 bases_dependent_p = true;
2871 /* From [namespace.udecl]:
2873 A using-declaration used as a member-declaration shall refer to a
2874 member of a base class of the class being defined.
2876 In general, we cannot check this constraint in a template because
2877 we do not know the entire set of base classes of the current
2878 class type. However, if all of the base classes are
2879 non-dependent, then we can avoid delaying the check until
2881 if (!scope_dependent_p)
2884 binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2885 if (b_kind < bk_proper_base)
2887 if (!bases_dependent_p)
2889 error_not_base_type (scope, current_class_type);
2893 else if (!name_dependent_p)
2895 decl = lookup_member (binfo, name, 0, false);
2898 error ("no members matching %<%T::%D%> in %q#T", scope, name,
2902 /* The binfo from which the functions came does not matter. */
2903 if (BASELINK_P (decl))
2904 decl = BASELINK_FUNCTIONS (decl);
2908 value = build_lang_decl (USING_DECL, name, NULL_TREE);
2909 USING_DECL_DECLS (value) = decl;
2910 USING_DECL_SCOPE (value) = scope;
2911 DECL_DEPENDENT_P (value) = !decl;
2917 /* Return the binding value for name in scope. */
2920 namespace_binding (tree name, tree scope)
2922 cxx_binding *binding;
2925 scope = global_namespace;
2927 /* Unnecessary for the global namespace because it can't be an alias. */
2928 scope = ORIGINAL_NAMESPACE (scope);
2930 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
2932 return binding ? binding->value : NULL_TREE;
2935 /* Set the binding value for name in scope. */
2938 set_namespace_binding (tree name, tree scope, tree val)
2942 timevar_push (TV_NAME_LOOKUP);
2943 if (scope == NULL_TREE)
2944 scope = global_namespace;
2945 b = binding_for_name (NAMESPACE_LEVEL (scope), name);
2946 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
2949 supplement_binding (b, val);
2950 timevar_pop (TV_NAME_LOOKUP);
2953 /* Set the context of a declaration to scope. Complain if we are not
2957 set_decl_namespace (tree decl, tree scope, bool friendp)
2961 /* Get rid of namespace aliases. */
2962 scope = ORIGINAL_NAMESPACE (scope);
2964 /* It is ok for friends to be qualified in parallel space. */
2965 if (!friendp && !is_ancestor (current_namespace, scope))
2966 error ("declaration of %qD not in a namespace surrounding %qD",
2968 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
2970 /* Writing "int N::i" to declare a variable within "N" is invalid. */
2971 if (scope == current_namespace)
2973 if (at_namespace_scope_p ())
2974 error ("explicit qualification in declaration of %qD",
2979 /* See whether this has been declared in the namespace. */
2980 old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
2981 if (old == error_mark_node)
2982 /* No old declaration at all. */
2984 if (!is_overloaded_fn (decl))
2985 /* Don't compare non-function decls with decls_match here, since
2986 it can't check for the correct constness at this
2987 point. pushdecl will find those errors later. */
2989 /* Since decl is a function, old should contain a function decl. */
2990 if (!is_overloaded_fn (old))
2992 fn = OVL_CURRENT (old);
2993 if (!is_associated_namespace (scope, CP_DECL_CONTEXT (fn)))
2995 /* A template can be explicitly specialized in any namespace. */
2996 if (processing_explicit_instantiation)
2998 if (processing_template_decl || processing_specialization)
2999 /* We have not yet called push_template_decl to turn a
3000 FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3001 match. But, we'll check later, when we construct the
3004 /* Instantiations or specializations of templates may be declared as
3005 friends in any namespace. */
3006 if (friendp && DECL_USE_TEMPLATE (decl))
3008 if (is_overloaded_fn (old))
3010 for (; old; old = OVL_NEXT (old))
3011 if (decls_match (decl, OVL_CURRENT (old)))
3014 else if (decls_match (decl, old))
3017 error ("%qD should have been declared inside %qD", decl, scope);
3020 /* Return the namespace where the current declaration is declared. */
3023 current_decl_namespace (void)
3026 /* If we have been pushed into a different namespace, use it. */
3027 if (decl_namespace_list)
3028 return TREE_PURPOSE (decl_namespace_list);
3030 if (current_class_type)
3031 result = decl_namespace_context (current_class_type);
3032 else if (current_function_decl)
3033 result = decl_namespace_context (current_function_decl);
3035 result = current_namespace;
3039 /* Push into the scope of the NAME namespace. If NAME is NULL_TREE, then we
3040 select a name that is unique to this compilation unit. */
3043 push_namespace (tree name)
3045 push_namespace_with_attribs (name, NULL_TREE);
3048 /* Same, but specify attributes to apply to the namespace. The attributes
3049 only apply to the current namespace-body, not to any later extensions. */
3052 push_namespace_with_attribs (tree name, tree attributes)
3056 int implicit_use = 0;
3059 timevar_push (TV_NAME_LOOKUP);
3061 /* We should not get here if the global_namespace is not yet constructed
3062 nor if NAME designates the global namespace: The global scope is
3063 constructed elsewhere. */
3064 gcc_assert (global_namespace != NULL && name != global_scope_name);
3068 name = get_anonymous_namespace_name();
3069 d = IDENTIFIER_NAMESPACE_VALUE (name);
3071 /* Reopening anonymous namespace. */
3077 /* Check whether this is an extended namespace definition. */
3078 d = IDENTIFIER_NAMESPACE_VALUE (name);
3079 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3082 if (DECL_NAMESPACE_ALIAS (d))
3084 error ("namespace alias %qD not allowed here, assuming %qD",
3085 d, DECL_NAMESPACE_ALIAS (d));
3086 d = DECL_NAMESPACE_ALIAS (d);
3093 /* Make a new namespace, binding the name to it. */
3094 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3095 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3096 /* The name of this namespace is not visible to other translation
3097 units if it is an anonymous namespace or member thereof. */
3098 if (anon || decl_anon_ns_mem_p (current_namespace))
3099 TREE_PUBLIC (d) = 0;
3101 TREE_PUBLIC (d) = 1;
3105 /* Clear DECL_NAME for the benefit of debugging back ends. */
3106 SET_DECL_ASSEMBLER_NAME (d, name);
3107 DECL_NAME (d) = NULL_TREE;
3109 begin_scope (sk_namespace, d);
3112 resume_scope (NAMESPACE_LEVEL (d));
3115 do_using_directive (d);
3116 /* Enter the name space. */
3117 current_namespace = d;
3119 #ifdef HANDLE_PRAGMA_VISIBILITY
3120 /* Clear has_visibility in case a previous namespace-definition had a
3121 visibility attribute and this one doesn't. */
3122 current_binding_level->has_visibility = 0;
3123 for (d = attributes; d; d = TREE_CHAIN (d))
3125 tree name = TREE_PURPOSE (d);
3126 tree args = TREE_VALUE (d);
3129 if (! is_attribute_p ("visibility", name))
3131 warning (OPT_Wattributes, "%qs attribute directive ignored",
3132 IDENTIFIER_POINTER (name));
3136 x = args ? TREE_VALUE (args) : NULL_TREE;
3137 if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3139 warning (OPT_Wattributes, "%qs attribute requires a single NTBS argument",
3140 IDENTIFIER_POINTER (name));
3144 current_binding_level->has_visibility = 1;
3145 push_visibility (TREE_STRING_POINTER (x));
3151 timevar_pop (TV_NAME_LOOKUP);
3154 /* Pop from the scope of the current namespace. */
3157 pop_namespace (void)
3159 gcc_assert (current_namespace != global_namespace);
3160 current_namespace = CP_DECL_CONTEXT (current_namespace);
3161 /* The binding level is not popped, as it might be re-opened later. */
3165 /* Push into the scope of the namespace NS, even if it is deeply
3166 nested within another namespace. */
3169 push_nested_namespace (tree ns)
3171 if (ns == global_namespace)
3172 push_to_top_level ();
3175 push_nested_namespace (CP_DECL_CONTEXT (ns));
3176 push_namespace (DECL_NAME (ns));
3180 /* Pop back from the scope of the namespace NS, which was previously
3181 entered with push_nested_namespace. */
3184 pop_nested_namespace (tree ns)
3186 timevar_push (TV_NAME_LOOKUP);
3187 while (ns != global_namespace)
3190 ns = CP_DECL_CONTEXT (ns);
3193 pop_from_top_level ();
3194 timevar_pop (TV_NAME_LOOKUP);
3197 /* Temporarily set the namespace for the current declaration. */
3200 push_decl_namespace (tree decl)
3202 if (TREE_CODE (decl) != NAMESPACE_DECL)
3203 decl = decl_namespace_context (decl);
3204 decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3205 NULL_TREE, decl_namespace_list);
3208 /* [namespace.memdef]/2 */
3211 pop_decl_namespace (void)
3213 decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3216 /* Return the namespace that is the common ancestor
3217 of two given namespaces. */
3220 namespace_ancestor (tree ns1, tree ns2)
3222 timevar_push (TV_NAME_LOOKUP);
3223 if (is_ancestor (ns1, ns2))
3224 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3225 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3226 namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3229 /* Process a namespace-alias declaration. */
3232 do_namespace_alias (tree alias, tree namespace)
3234 if (namespace == error_mark_node)
3237 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3239 namespace = ORIGINAL_NAMESPACE (namespace);
3241 /* Build the alias. */
3242 alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3243 DECL_NAMESPACE_ALIAS (alias) = namespace;
3244 DECL_EXTERNAL (alias) = 1;
3245 DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3248 /* Emit debug info for namespace alias. */
3249 (*debug_hooks->global_decl) (alias);
3252 /* Like pushdecl, only it places X in the current namespace,
3256 pushdecl_namespace_level (tree x, bool is_friend)
3258 struct cp_binding_level *b = current_binding_level;
3261 timevar_push (TV_NAME_LOOKUP);
3262 t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3264 /* Now, the type_shadowed stack may screw us. Munge it so it does
3266 if (TREE_CODE (t) == TYPE_DECL)
3268 tree name = DECL_NAME (t);
3270 tree *ptr = (tree *)0;
3271 for (; !global_scope_p (b); b = b->level_chain)
3273 tree shadowed = b->type_shadowed;
3274 for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3275 if (TREE_PURPOSE (shadowed) == name)
3277 ptr = &TREE_VALUE (shadowed);
3278 /* Can't break out of the loop here because sometimes
3279 a binding level will have duplicate bindings for
3280 PT names. It's gross, but I haven't time to fix it. */
3283 newval = TREE_TYPE (t);
3284 if (ptr == (tree *)0)
3286 /* @@ This shouldn't be needed. My test case "zstring.cc" trips
3287 up here if this is changed to an assertion. --KR */
3288 SET_IDENTIFIER_TYPE_VALUE (name, t);
3295 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3298 /* Insert USED into the using list of USER. Set INDIRECT_flag if this
3299 directive is not directly from the source. Also find the common
3300 ancestor and let our users know about the new namespace */
3302 add_using_namespace (tree user, tree used, bool indirect)
3305 timevar_push (TV_NAME_LOOKUP);
3306 /* Using oneself is a no-op. */
3309 timevar_pop (TV_NAME_LOOKUP);
3312 gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3313 gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3314 /* Check if we already have this. */
3315 t = purpose_member (used, DECL_NAMESPACE_USING (user));
3319 /* Promote to direct usage. */
3320 TREE_INDIRECT_USING (t) = 0;
3321 timevar_pop (TV_NAME_LOOKUP);
3325 /* Add used to the user's using list. */
3326 DECL_NAMESPACE_USING (user)
3327 = tree_cons (used, namespace_ancestor (user, used),
3328 DECL_NAMESPACE_USING (user));
3330 TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3332 /* Add user to the used's users list. */
3333 DECL_NAMESPACE_USERS (used)
3334 = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3336 /* Recursively add all namespaces used. */
3337 for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3338 /* indirect usage */
3339 add_using_namespace (user, TREE_PURPOSE (t), 1);
3341 /* Tell everyone using us about the new used namespaces. */
3342 for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3343 add_using_namespace (TREE_PURPOSE (t), used, 1);
3344 timevar_pop (TV_NAME_LOOKUP);
3347 /* Process a using-declaration not appearing in class or local scope. */
3350 do_toplevel_using_decl (tree decl, tree scope, tree name)
3352 tree oldval, oldtype, newval, newtype;
3353 tree orig_decl = decl;
3354 cxx_binding *binding;
3356 decl = validate_nonmember_using_decl (decl, scope, name);
3357 if (decl == NULL_TREE)
3360 binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3362 oldval = binding->value;
3363 oldtype = binding->type;
3365 do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3367 /* Emit debug info. */
3368 if (!processing_template_decl)
3369 cp_emit_debug_info_for_using (orig_decl, current_namespace);
3371 /* Copy declarations found. */
3373 binding->value = newval;
3375 binding->type = newtype;
3378 /* Process a using-directive. */
3381 do_using_directive (tree namespace)
3383 tree context = NULL_TREE;
3385 if (namespace == error_mark_node)
3388 gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
3390 if (building_stmt_tree ())
3391 add_stmt (build_stmt (USING_STMT, namespace));
3392 namespace = ORIGINAL_NAMESPACE (namespace);
3394 if (!toplevel_bindings_p ())
3396 push_using_directive (namespace);
3397 context = current_scope ();
3402 add_using_namespace (current_namespace, namespace, 0);
3403 if (current_namespace != global_namespace)
3404 context = current_namespace;
3407 /* Emit debugging info. */
3408 if (!processing_template_decl)
3409 (*debug_hooks->imported_module_or_decl) (namespace, context);
3412 /* Deal with a using-directive seen by the parser. Currently we only
3413 handle attributes here, since they cannot appear inside a template. */
3416 parse_using_directive (tree namespace, tree attribs)
3420 do_using_directive (namespace);
3422 for (a = attribs; a; a = TREE_CHAIN (a))
3424 tree name = TREE_PURPOSE (a);
3425 if (is_attribute_p ("strong", name))
3427 if (!toplevel_bindings_p ())
3428 error ("strong using only meaningful at namespace scope");
3429 else if (namespace != error_mark_node)
3431 if (!is_ancestor (current_namespace, namespace))
3432 error ("current namespace %qD does not enclose strongly used namespace %qD",
3433 current_namespace, namespace);
3434 DECL_NAMESPACE_ASSOCIATIONS (namespace)
3435 = tree_cons (current_namespace, 0,
3436 DECL_NAMESPACE_ASSOCIATIONS (namespace));
3440 warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3444 /* Like pushdecl, only it places X in the global scope if appropriate.
3445 Calls cp_finish_decl to register the variable, initializing it with
3446 *INIT, if INIT is non-NULL. */
3449 pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3451 timevar_push (TV_NAME_LOOKUP);
3452 push_to_top_level ();
3453 x = pushdecl_namespace_level (x, is_friend);
3455 finish_decl (x, *init, NULL_TREE);
3456 pop_from_top_level ();
3457 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3460 /* Like pushdecl, only it places X in the global scope if appropriate. */
3463 pushdecl_top_level (tree x)
3465 return pushdecl_top_level_1 (x, NULL, false);
3468 /* Like pushdecl_top_level, but adding the IS_FRIEND parameter. */
3471 pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3473 return pushdecl_top_level_1 (x, NULL, is_friend);
3476 /* Like pushdecl, only it places X in the global scope if
3477 appropriate. Calls cp_finish_decl to register the variable,
3478 initializing it with INIT. */
3481 pushdecl_top_level_and_finish (tree x, tree init)
3483 return pushdecl_top_level_1 (x, &init, false);
3486 /* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3487 duplicates. The first list becomes the tail of the result.
3489 The algorithm is O(n^2). We could get this down to O(n log n) by
3490 doing a sort on the addresses of the functions, if that becomes
3494 merge_functions (tree s1, tree s2)
3496 for (; s2; s2 = OVL_NEXT (s2))
3498 tree fn2 = OVL_CURRENT (s2);
3501 for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3503 tree fn1 = OVL_CURRENT (fns1);
3505 /* If the function from S2 is already in S1, there is no
3506 need to add it again. For `extern "C"' functions, we
3507 might have two FUNCTION_DECLs for the same function, in
3508 different namespaces; again, we only need one of them. */
3510 || (DECL_EXTERN_C_P (fn1) && DECL_EXTERN_C_P (fn2)
3511 && DECL_NAME (fn1) == DECL_NAME (fn2)))
3515 /* If we exhausted all of the functions in S1, FN2 is new. */
3517 s1 = build_overload (fn2, s1);
3522 /* This should return an error not all definitions define functions.
3523 It is not an error if we find two functions with exactly the
3524 same signature, only if these are selected in overload resolution.
3525 old is the current set of bindings, new the freshly-found binding.
3526 XXX Do we want to give *all* candidates in case of ambiguity?
3527 XXX In what way should I treat extern declarations?
3528 XXX I don't want to repeat the entire duplicate_decls here */
3530 /* LLVM LOCAL begin mainline */
3532 ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
3535 gcc_assert (old != NULL);
3537 /* Copy the type. */
3539 if (LOOKUP_NAMESPACES_ONLY (flags)
3540 || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3543 /* Copy the value. */
3547 if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3550 switch (TREE_CODE (val))
3553 /* If we expect types or namespaces, and not templates,
3554 or this is not a template class. */
3555 if ((LOOKUP_QUALIFIERS_ONLY (flags)
3556 && !DECL_CLASS_TEMPLATE_P (val)))
3560 if (LOOKUP_NAMESPACES_ONLY (flags)
3561 || (type && (flags & LOOKUP_PREFER_TYPES)))
3564 case NAMESPACE_DECL:
3565 if (LOOKUP_TYPES_ONLY (flags))
3569 /* Ignore built-in functions that are still anticipated. */
3570 if (LOOKUP_QUALIFIERS_ONLY (flags))
3574 if (LOOKUP_QUALIFIERS_ONLY (flags))
3579 /* If val is hidden, shift down any class or enumeration name. */
3586 /* LLVM LOCAL end mainline */
3589 else if (val && val != old->value)
3591 if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3592 old->value = merge_functions (old->value, val);
3595 old->value = tree_cons (NULL_TREE, old->value,
3596 build_tree_list (NULL_TREE, val));
3597 TREE_TYPE (old->value) = error_mark_node;
3601 /* LLVM LOCAL begin mainline */
3604 else if (type && old->type != type)
3606 old->type = tree_cons (NULL_TREE, old->type,
3607 build_tree_list (NULL_TREE, type));
3608 TREE_TYPE (old->type) = error_mark_node;
3610 /* LLVM LOCAL end mainline */
3613 /* Return the declarations that are members of the namespace NS. */
3616 cp_namespace_decls (tree ns)
3618 return NAMESPACE_LEVEL (ns)->names;
3621 /* Combine prefer_type and namespaces_only into flags. */
3624 lookup_flags (int prefer_type, int namespaces_only)
3626 if (namespaces_only)
3627 return LOOKUP_PREFER_NAMESPACES;
3628 if (prefer_type > 1)
3629 return LOOKUP_PREFER_TYPES;
3630 if (prefer_type > 0)
3631 return LOOKUP_PREFER_BOTH;
3635 /* Given a lookup that returned VAL, use FLAGS to decide if we want to
3636 ignore it or not. Subroutine of lookup_name_real and
3637 lookup_type_scope. */
3640 qualify_lookup (tree val, int flags)
3642 if (val == NULL_TREE)
3644 if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3646 if ((flags & LOOKUP_PREFER_TYPES)
3647 && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3649 if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3654 /* Given a lookup that returned VAL, decide if we want to ignore it or
3655 not based on DECL_ANTICIPATED. */
3658 hidden_name_p (tree val)
3661 && DECL_LANG_SPECIFIC (val)
3662 && DECL_ANTICIPATED (val))
3667 /* Remove any hidden friend functions from a possibly overloaded set
3671 remove_hidden_names (tree fns)
3676 if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3678 else if (TREE_CODE (fns) == OVERLOAD)
3682 for (o = fns; o; o = OVL_NEXT (o))
3683 if (hidden_name_p (OVL_CURRENT (o)))
3689 for (o = fns; o; o = OVL_NEXT (o))
3690 if (!hidden_name_p (OVL_CURRENT (o)))
3691 n = build_overload (OVL_CURRENT (o), n);
3699 /* Unscoped lookup of a global: iterate over current namespaces,
3700 considering using-directives. */
3703 unqualified_namespace_lookup (tree name, int flags)
3705 tree initial = current_decl_namespace ();
3706 tree scope = initial;
3708 struct cp_binding_level *level;
3709 tree val = NULL_TREE;
3711 timevar_push (TV_NAME_LOOKUP);
3713 for (; !val; scope = CP_DECL_CONTEXT (scope))
3715 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3717 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3720 /* LLVM LOCAL mainline */
3721 ambiguous_decl (&binding, b, flags);
3723 /* Add all _DECLs seen through local using-directives. */
3724 for (level = current_binding_level;
3725 level->kind != sk_namespace;
3726 level = level->level_chain)
3727 if (!lookup_using_namespace (name, &binding, level->using_directives,
3729 /* Give up because of error. */
3730 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3732 /* Add all _DECLs seen through global using-directives. */
3733 /* XXX local and global using lists should work equally. */
3737 if (!lookup_using_namespace (name, &binding,
3738 DECL_NAMESPACE_USING (siter),
3740 /* Give up because of error. */
3741 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3742 if (siter == scope) break;
3743 siter = CP_DECL_CONTEXT (siter);
3746 val = binding.value;
3747 if (scope == global_namespace)
3750 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3753 /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3754 or a class TYPE). If IS_TYPE_P is TRUE, then ignore non-type
3757 Returns a DECL (or OVERLOAD, or BASELINK) representing the
3758 declaration found. If no suitable declaration can be found,
3759 ERROR_MARK_NODE is returned. If COMPLAIN is true and SCOPE is
3760 neither a class-type nor a namespace a diagnostic is issued. */
3763 lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3768 if (TREE_CODE (scope) == NAMESPACE_DECL)
3770 struct scope_binding binding = EMPTY_SCOPE_BINDING;
3772 flags |= LOOKUP_COMPLAIN;
3774 flags |= LOOKUP_PREFER_TYPES;
3775 if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3778 else if (is_aggr_type (scope, complain))
3779 t = lookup_member (scope, name, 2, is_type_p);
3782 return error_mark_node;
3786 /* Subroutine of unqualified_namespace_lookup:
3787 Add the bindings of NAME in used namespaces to VAL.
3788 We are currently looking for names in namespace SCOPE, so we
3789 look through USINGS for using-directives of namespaces
3790 which have SCOPE as a common ancestor with the current scope.
3791 Returns false on errors. */
3794 lookup_using_namespace (tree name, struct scope_binding *val,
3795 tree usings, tree scope, int flags)
3798 timevar_push (TV_NAME_LOOKUP);
3799 /* Iterate over all used namespaces in current, searching for using
3800 directives of scope. */
3801 for (iter = usings; iter; iter = TREE_CHAIN (iter))
3802 if (TREE_VALUE (iter) == scope)
3804 tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3806 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3807 /* Resolve ambiguities. */
3809 /* LLVM LOCAL mainline */
3810 ambiguous_decl (val, val1, flags);
3812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3816 Accepts the NAME to lookup and its qualifying SCOPE.
3817 Returns the name/type pair found into the cxx_binding *RESULT,
3818 or false on error. */
3821 qualified_lookup_using_namespace (tree name, tree scope,
3822 struct scope_binding *result, int flags)
3824 /* Maintain a list of namespaces visited... */
3825 tree seen = NULL_TREE;
3826 /* ... and a list of namespace yet to see. */
3827 tree todo = NULL_TREE;
3828 tree todo_maybe = NULL_TREE;
3830 timevar_push (TV_NAME_LOOKUP);
3831 /* Look through namespace aliases. */
3832 scope = ORIGINAL_NAMESPACE (scope);
3833 while (scope && result->value != error_mark_node)
3835 cxx_binding *binding =
3836 cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3837 seen = tree_cons (scope, NULL_TREE, seen);
3839 /* LLVM LOCAL mainline */
3840 ambiguous_decl (result, binding, flags);
3842 /* Consider strong using directives always, and non-strong ones
3843 if we haven't found a binding yet. ??? Shouldn't we consider
3844 non-strong ones if the initial RESULT is non-NULL, but the
3845 binding in the given namespace is? */
3846 for (usings = DECL_NAMESPACE_USING (scope); usings;
3847 usings = TREE_CHAIN (usings))
3848 /* If this was a real directive, and we have not seen it. */
3849 if (!TREE_INDIRECT_USING (usings))
3851 /* Try to avoid queuing the same namespace more than once,
3852 the exception being when a namespace was already
3853 enqueued for todo_maybe and then a strong using is
3854 found for it. We could try to remove it from
3855 todo_maybe, but it's probably not worth the effort. */
3856 if (is_associated_namespace (scope, TREE_PURPOSE (usings))
3857 && !purpose_member (TREE_PURPOSE (usings), seen)
3858 && !purpose_member (TREE_PURPOSE (usings), todo))
3859 todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
3860 else if ((!result->value && !result->type)
3861 && !purpose_member (TREE_PURPOSE (usings), seen)
3862 && !purpose_member (TREE_PURPOSE (usings), todo)
3863 && !purpose_member (TREE_PURPOSE (usings), todo_maybe))
3864 todo_maybe = tree_cons (TREE_PURPOSE (usings), NULL_TREE,
3869 scope = TREE_PURPOSE (todo);
3870 todo = TREE_CHAIN (todo);
3873 && (!result->value && !result->type))
3875 scope = TREE_PURPOSE (todo_maybe);
3876 todo = TREE_CHAIN (todo_maybe);
3877 todo_maybe = NULL_TREE;
3880 scope = NULL_TREE; /* If there never was a todo list. */
3882 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
3885 /* Return the innermost non-namespace binding for NAME from a scope
3886 containing BINDING, or, if BINDING is NULL, the current scope. If
3887 CLASS_P is false, then class bindings are ignored. */
3890 outer_binding (tree name,
3891 cxx_binding *binding,
3896 cxx_scope *outer_scope;
3900 scope = binding->scope->level_chain;
3901 outer = binding->previous;
3905 scope = current_binding_level;
3906 outer = IDENTIFIER_BINDING (name);
3908 outer_scope = outer ? outer->scope : NULL;
3910 /* Because we create class bindings lazily, we might be missing a
3911 class binding for NAME. If there are any class binding levels
3912 between the LAST_BINDING_LEVEL and the scope in which OUTER was
3913 declared, we must lookup NAME in those class scopes. */
3915 while (scope && scope != outer_scope && scope->kind != sk_namespace)
3917 if (scope->kind == sk_class)
3919 cxx_binding *class_binding;
3921 class_binding = get_class_binding (name, scope);
3924 /* Thread this new class-scope binding onto the
3925 IDENTIFIER_BINDING list so that future lookups
3927 class_binding->previous = outer;
3929 binding->previous = class_binding;
3931 IDENTIFIER_BINDING (name) = class_binding;
3932 return class_binding;
3935 scope = scope->level_chain;
3941 /* Return the innermost block-scope or class-scope value binding for
3942 NAME, or NULL_TREE if there is no such binding. */
3945 innermost_non_namespace_value (tree name)
3947 cxx_binding *binding;
3948 binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
3949 return binding ? binding->value : NULL_TREE;
3952 /* Look up NAME in the current binding level and its superiors in the
3953 namespace of variables, functions and typedefs. Return a ..._DECL
3954 node of some kind representing its definition if there is only one
3955 such declaration, or return a TREE_LIST with all the overloaded
3956 definitions if there are many, or return 0 if it is undefined.
3957 Hidden name, either friend declaration or built-in function, are
3960 If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
3961 If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
3962 Otherwise we prefer non-TYPE_DECLs.
3964 If NONCLASS is nonzero, bindings in class scopes are ignored. If
3965 BLOCK_P is false, bindings in block scopes are ignored. */
3968 lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
3969 int namespaces_only, int flags)
3972 tree val = NULL_TREE;
3974 timevar_push (TV_NAME_LOOKUP);
3975 /* Conversion operators are handled specially because ordinary
3976 unqualified name lookup will not find template conversion
3978 if (IDENTIFIER_TYPENAME_P (name))
3980 struct cp_binding_level *level;
3982 for (level = current_binding_level;
3983 level && level->kind != sk_namespace;
3984 level = level->level_chain)
3989 /* A conversion operator can only be declared in a class
3991 if (level->kind != sk_class)
3994 /* Lookup the conversion operator in the class. */
3995 class_type = level->this_entity;
3996 operators = lookup_fnfields (class_type, name, /*protect=*/0);
3998 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4001 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4004 flags |= lookup_flags (prefer_type, namespaces_only);
4006 /* First, look in non-namespace scopes. */
4008 if (current_class_type == NULL_TREE)
4011 if (block_p || !nonclass)
4012 for (iter = outer_binding (name, NULL, !nonclass);
4014 iter = outer_binding (name, iter, !nonclass))
4018 /* Skip entities we don't want. */
4019 if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4022 /* If this is the kind of thing we're looking for, we're done. */
4023 if (qualify_lookup (iter->value, flags))
4024 binding = iter->value;
4025 else if ((flags & LOOKUP_PREFER_TYPES)
4026 && qualify_lookup (iter->type, flags))
4027 binding = iter->type;
4029 binding = NULL_TREE;
4033 if (hidden_name_p (binding))
4035 /* A non namespace-scope binding can only be hidden if
4036 we are in a local class, due to friend declarations.
4037 In particular, consider:
4042 void g() { B* b; } // error: B is hidden
4047 The standard says that "B" is a local class in "f"
4048 (but not nested within "A") -- but that name lookup
4049 for "B" does not find this declaration until it is
4050 declared directly with "f".
4056 If a friend declaration appears in a local class and
4057 the name specified is an unqualified name, a prior
4058 declaration is looked up without considering scopes
4059 that are outside the innermost enclosing non-class
4060 scope. For a friend class declaration, if there is no
4061 prior declaration, the class that is specified
4062 belongs to the innermost enclosing non-class scope,
4063 but if it is subsequently referenced, its name is not
4064 found by name lookup until a matching declaration is
4065 provided in the innermost enclosing nonclass scope.
4067 gcc_assert (current_class_type &&
4068 LOCAL_CLASS_P (current_class_type));
4070 /* This binding comes from a friend declaration in the local
4071 class. The standard (11.4.8) states that the lookup can
4072 only succeed if there is a non-hidden declaration in the
4073 current scope, which is not the case here. */
4074 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4081 /* Now lookup in namespace scopes. */
4083 val = unqualified_namespace_lookup (name, flags);
4085 /* If we have a single function from a using decl, pull it out. */
4086 if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4087 val = OVL_FUNCTION (val);
4089 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4093 lookup_name_nonclass (tree name)
4095 return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4099 lookup_function_nonclass (tree name, tree args, bool block_p)
4102 lookup_arg_dependent (name,
4103 lookup_name_real (name, 0, 1, block_p, 0,
4109 lookup_name (tree name)
4111 return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4115 lookup_name_prefer_type (tree name, int prefer_type)
4117 return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4118 0, LOOKUP_COMPLAIN);
4121 /* Look up NAME for type used in elaborated name specifier in
4122 the scopes given by SCOPE. SCOPE can be either TS_CURRENT or
4123 TS_WITHIN_ENCLOSING_NON_CLASS. Although not implied by the
4124 name, more scopes are checked if cleanup or template parameter
4125 scope is encountered.
4127 Unlike lookup_name_real, we make sure that NAME is actually
4128 declared in the desired scope, not from inheritance, nor using
4129 directive. For using declaration, there is DR138 still waiting
4130 to be resolved. Hidden name coming from an earlier friend
4131 declaration is also returned.
4133 A TYPE_DECL best matching the NAME is returned. Catching error
4134 and issuing diagnostics are caller's responsibility. */
4137 lookup_type_scope (tree name, tag_scope scope)
4139 cxx_binding *iter = NULL;
4140 tree val = NULL_TREE;
4142 timevar_push (TV_NAME_LOOKUP);
4144 /* Look in non-namespace scope first. */
4145 if (current_binding_level->kind != sk_namespace)
4146 iter = outer_binding (name, NULL, /*class_p=*/ true);
4147 for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4149 /* Check if this is the kind of thing we're looking for.
4150 If SCOPE is TS_CURRENT, also make sure it doesn't come from
4151 base class. For ITER->VALUE, we can simply use
4152 INHERITED_VALUE_BINDING_P. For ITER->TYPE, we have to use
4155 We check ITER->TYPE before ITER->VALUE in order to handle
4156 typedef struct C {} C;
4159 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4160 && (scope != ts_current
4161 || LOCAL_BINDING_P (iter)
4162 || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4164 else if ((scope != ts_current
4165 || !INHERITED_VALUE_BINDING_P (iter))
4166 && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4173 /* Look in namespace scope. */
4176 iter = cxx_scope_find_binding_for_name
4177 (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4181 /* If this is the kind of thing we're looking for, we're done. */
4182 if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4184 else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4190 /* Type found, check if it is in the allowed scopes, ignoring cleanup
4191 and template parameter scopes. */
4194 struct cp_binding_level *b = current_binding_level;
4197 if (iter->scope == b)
4198 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4200 if (b->kind == sk_cleanup || b->kind == sk_template_parms)
4202 else if (b->kind == sk_class
4203 && scope == ts_within_enclosing_non_class)
4210 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4213 /* Similar to `lookup_name' but look only in the innermost non-class
4217 lookup_name_innermost_nonclass_level (tree name)
4219 struct cp_binding_level *b;
4222 timevar_push (TV_NAME_LOOKUP);
4223 b = innermost_nonclass_level ();
4225 if (b->kind == sk_namespace)
4227 t = IDENTIFIER_NAMESPACE_VALUE (name);
4229 /* extern "C" function() */
4230 if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4233 else if (IDENTIFIER_BINDING (name)
4234 && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4236 cxx_binding *binding;
4237 binding = IDENTIFIER_BINDING (name);
4240 if (binding->scope == b
4241 && !(TREE_CODE (binding->value) == VAR_DECL
4242 && DECL_DEAD_FOR_LOCAL (binding->value)))
4243 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4245 if (b->kind == sk_cleanup)
4252 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4255 /* Like lookup_name_innermost_nonclass_level, but for types. */
4258 lookup_type_current_level (tree name)
4262 timevar_push (TV_NAME_LOOKUP);
4263 gcc_assert (current_binding_level->kind != sk_namespace);
4265 if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4266 && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4268 struct cp_binding_level *b = current_binding_level;
4271 if (purpose_member (name, b->type_shadowed))
4272 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4273 REAL_IDENTIFIER_TYPE_VALUE (name));
4274 if (b->kind == sk_cleanup)
4281 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4284 /* [basic.lookup.koenig] */
4285 /* A nonzero return value in the functions below indicates an error. */
4296 static bool arg_assoc (struct arg_lookup*, tree);
4297 static bool arg_assoc_args (struct arg_lookup*, tree);
4298 static bool arg_assoc_type (struct arg_lookup*, tree);
4299 static bool add_function (struct arg_lookup *, tree);
4300 static bool arg_assoc_namespace (struct arg_lookup *, tree);
4301 static bool arg_assoc_class (struct arg_lookup *, tree);
4302 static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4304 /* Add a function to the lookup structure.
4305 Returns true on error. */
4308 add_function (struct arg_lookup *k, tree fn)
4310 /* We used to check here to see if the function was already in the list,
4311 but that's O(n^2), which is just too expensive for function lookup.
4312 Now we deal with the occasional duplicate in joust. In doing this, we
4313 assume that the number of duplicates will be small compared to the
4314 total number of functions being compared, which should usually be the
4317 /* We must find only functions, or exactly one non-function. */
4320 else if (fn == k->functions)
4322 else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
4323 k->functions = build_overload (fn, k->functions);
4326 tree f1 = OVL_CURRENT (k->functions);
4328 if (is_overloaded_fn (f1))
4330 fn = f1; f1 = f2; f2 = fn;
4332 error ("%q+D is not a function,", f1);
4333 error (" conflict with %q+D", f2);
4334 error (" in call to %qD", k->name);
4341 /* Returns true iff CURRENT has declared itself to be an associated
4342 namespace of SCOPE via a strong using-directive (or transitive chain
4343 thereof). Both are namespaces. */
4346 is_associated_namespace (tree current, tree scope)
4348 tree seen = NULL_TREE;
4349 tree todo = NULL_TREE;
4353 if (scope == current)
4355 seen = tree_cons (scope, NULL_TREE, seen);
4356 for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4357 if (!purpose_member (TREE_PURPOSE (t), seen))
4358 todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4361 scope = TREE_PURPOSE (todo);
4362 todo = TREE_CHAIN (todo);
4369 /* Return whether FN is a friend of an associated class of ARG. */
4372 friend_of_associated_class_p (tree arg, tree fn)
4378 else if (type_unknown_p (arg))
4381 type = TREE_TYPE (arg);
4383 /* If TYPE is a class, the class itself and all base classes are
4384 associated classes. */
4385 if (CLASS_TYPE_P (type))
4387 if (is_friend (type, fn))
4390 if (TYPE_BINFO (type))
4392 tree binfo, base_binfo;
4395 for (binfo = TYPE_BINFO (type), i = 0;
4396 BINFO_BASE_ITERATE (binfo, i, base_binfo);
4398 if (is_friend (BINFO_TYPE (base_binfo), fn))
4403 /* If TYPE is a class member, the class of which it is a member is
4404 an associated class. */
4405 if ((CLASS_TYPE_P (type)
4406 || TREE_CODE (type) == UNION_TYPE
4407 || TREE_CODE (type) == ENUMERAL_TYPE)
4408 && TYPE_CONTEXT (type)
4409 && CLASS_TYPE_P (TYPE_CONTEXT (type))
4410 && is_friend (TYPE_CONTEXT (type), fn))
4416 /* Add functions of a namespace to the lookup structure.
4417 Returns true on error. */
4420 arg_assoc_namespace (struct arg_lookup *k, tree scope)
4424 if (purpose_member (scope, k->namespaces))
4426 k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4428 /* Check out our super-users. */
4429 for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4430 value = TREE_CHAIN (value))
4431 if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4434 value = namespace_binding (k->name, scope);
4438 for (; value; value = OVL_NEXT (value))
4440 /* We don't want to find arbitrary hidden functions via argument
4441 dependent lookup. We only want to find friends of associated
4443 if (hidden_name_p (OVL_CURRENT (value)))
4447 for (args = k->args; args; args = TREE_CHAIN (args))
4448 if (friend_of_associated_class_p (TREE_VALUE (args),
4449 OVL_CURRENT (value)))
4455 if (add_function (k, OVL_CURRENT (value)))
4462 /* Adds everything associated with a template argument to the lookup
4463 structure. Returns true on error. */
4466 arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4468 /* [basic.lookup.koenig]
4470 If T is a template-id, its associated namespaces and classes are
4471 ... the namespaces and classes associated with the types of the
4472 template arguments provided for template type parameters
4473 (excluding template template parameters); the namespaces in which
4474 any template template arguments are defined; and the classes in
4475 which any member templates used as template template arguments
4476 are defined. [Note: non-type template arguments do not
4477 contribute to the set of associated namespaces. ] */
4479 /* Consider first template template arguments. */
4480 if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4481 || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4483 else if (TREE_CODE (arg) == TEMPLATE_DECL)
4485 tree ctx = CP_DECL_CONTEXT (arg);
4487 /* It's not a member template. */
4488 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4489 return arg_assoc_namespace (k, ctx);
4490 /* Otherwise, it must be member template. */
4492 return arg_assoc_class (k, ctx);
4494 /* It's not a template template argument, but it is a type template
4496 else if (TYPE_P (arg))
4497 return arg_assoc_type (k, arg);
4498 /* It's a non-type template argument. */
4503 /* Adds everything associated with class to the lookup structure.
4504 Returns true on error. */
4507 arg_assoc_class (struct arg_lookup *k, tree type)
4509 tree list, friends, context;
4512 /* Backend build structures, such as __builtin_va_list, aren't
4513 affected by all this. */
4514 if (!CLASS_TYPE_P (type))
4517 if (purpose_member (type, k->classes))
4519 k->classes = tree_cons (type, NULL_TREE, k->classes);
4521 context = decl_namespace_context (type);
4522 if (arg_assoc_namespace (k, context))
4525 if (TYPE_BINFO (type))
4527 /* Process baseclasses. */
4528 tree binfo, base_binfo;
4530 for (binfo = TYPE_BINFO (type), i = 0;
4531 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4532 if (arg_assoc_class (k, BINFO_TYPE (base_binfo)))
4536 /* Process friends. */
4537 for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4538 list = TREE_CHAIN (list))
4539 if (k->name == FRIEND_NAME (list))
4540 for (friends = FRIEND_DECLS (list); friends;
4541 friends = TREE_CHAIN (friends))
4543 tree fn = TREE_VALUE (friends);
4545 /* Only interested in global functions with potentially hidden
4546 (i.e. unqualified) declarations. */
4547 if (CP_DECL_CONTEXT (fn) != context)
4549 /* Template specializations are never found by name lookup.
4550 (Templates themselves can be found, but not template
4551 specializations.) */
4552 if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4554 if (add_function (k, fn))
4558 /* Process template arguments. */
4559 if (CLASSTYPE_TEMPLATE_INFO (type)
4560 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4562 list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4563 for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4564 arg_assoc_template_arg (k, TREE_VEC_ELT (list, i));
4570 /* Adds everything associated with a given type.
4571 Returns 1 on error. */
4574 arg_assoc_type (struct arg_lookup *k, tree type)
4576 /* As we do not get the type of non-type dependent expressions
4577 right, we can end up with such things without a type. */
4581 if (TYPE_PTRMEM_P (type))
4583 /* Pointer to member: associate class type and value type. */
4584 if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4586 return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4588 else switch (TREE_CODE (type))
4600 if (TYPE_PTRMEMFUNC_P (type))
4601 return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4602 return arg_assoc_class (k, type);
4604 /* APPLE LOCAL blocks 6040305 */
4605 case BLOCK_POINTER_TYPE:
4606 case REFERENCE_TYPE:
4608 return arg_assoc_type (k, TREE_TYPE (type));
4611 return arg_assoc_namespace (k, decl_namespace_context (type));
4613 /* The basetype is referenced in the first arg type, so just
4616 /* Associate the parameter types. */
4617 if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4619 /* Associate the return type. */
4620 return arg_assoc_type (k, TREE_TYPE (type));
4621 case TEMPLATE_TYPE_PARM:
4622 case BOUND_TEMPLATE_TEMPLATE_PARM:
4627 gcc_assert (type == unknown_type_node);
4635 /* Adds everything associated with arguments. Returns true on error. */
4638 arg_assoc_args (struct arg_lookup *k, tree args)
4640 for (; args; args = TREE_CHAIN (args))
4641 if (arg_assoc (k, TREE_VALUE (args)))
4646 /* Adds everything associated with a given tree_node. Returns 1 on error. */
4649 arg_assoc (struct arg_lookup *k, tree n)
4651 if (n == error_mark_node)
4655 return arg_assoc_type (k, n);
4657 if (! type_unknown_p (n))
4658 return arg_assoc_type (k, TREE_TYPE (n));
4660 if (TREE_CODE (n) == ADDR_EXPR)
4661 n = TREE_OPERAND (n, 0);
4662 if (TREE_CODE (n) == COMPONENT_REF)
4663 n = TREE_OPERAND (n, 1);
4664 if (TREE_CODE (n) == OFFSET_REF)
4665 n = TREE_OPERAND (n, 1);
4666 while (TREE_CODE (n) == TREE_LIST)
4668 if (TREE_CODE (n) == BASELINK)
4669 n = BASELINK_FUNCTIONS (n);
4671 if (TREE_CODE (n) == FUNCTION_DECL)
4672 return arg_assoc_type (k, TREE_TYPE (n));
4673 if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4675 /* [basic.lookup.koenig]
4677 If T is a template-id, its associated namespaces and classes
4678 are the namespace in which the template is defined; for
4679 member templates, the member template's class... */
4680 tree template = TREE_OPERAND (n, 0);
4681 tree args = TREE_OPERAND (n, 1);
4685 if (TREE_CODE (template) == COMPONENT_REF)
4686 template = TREE_OPERAND (template, 1);
4688 /* First, the template. There may actually be more than one if
4689 this is an overloaded function template. But, in that case,
4690 we only need the first; all the functions will be in the same
4692 template = OVL_CURRENT (template);
4694 ctx = CP_DECL_CONTEXT (template);
4696 if (TREE_CODE (ctx) == NAMESPACE_DECL)
4698 if (arg_assoc_namespace (k, ctx) == 1)
4701 /* It must be a member template. */
4702 else if (arg_assoc_class (k, ctx) == 1)
4705 /* Now the arguments. */
4707 for (ix = TREE_VEC_LENGTH (args); ix--;)
4708 if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4711 else if (TREE_CODE (n) == OVERLOAD)
4713 for (; n; n = OVL_CHAIN (n))
4714 if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4721 /* Performs Koenig lookup depending on arguments, where fns
4722 are the functions found in normal lookup. */
4725 lookup_arg_dependent (tree name, tree fns, tree args)
4727 struct arg_lookup k;
4729 timevar_push (TV_NAME_LOOKUP);
4731 /* Remove any hidden friend functions from the list of functions
4732 found so far. They will be added back by arg_assoc_class as
4734 fns = remove_hidden_names (fns);
4739 k.classes = NULL_TREE;
4741 /* We previously performed an optimization here by setting
4742 NAMESPACES to the current namespace when it was safe. However, DR
4743 164 says that namespaces that were already searched in the first
4744 stage of template processing are searched again (potentially
4745 picking up later definitions) in the second stage. */
4746 k.namespaces = NULL_TREE;
4748 arg_assoc_args (&k, args);
4753 && TREE_CODE (fns) != VAR_DECL
4754 && !is_overloaded_fn (fns))
4756 error ("argument dependent lookup finds %q+D", fns);
4757 error (" in call to %qD", name);
4758 fns = error_mark_node;
4761 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
4764 /* Add namespace to using_directives. Return NULL_TREE if nothing was
4765 changed (i.e. there was already a directive), or the fresh
4766 TREE_LIST otherwise. */
4769 push_using_directive (tree used)
4771 tree ud = current_binding_level->using_directives;
4772 tree iter, ancestor;
4774 timevar_push (TV_NAME_LOOKUP);
4775 /* Check if we already have this. */
4776 if (purpose_member (used, ud) != NULL_TREE)
4777 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4779 ancestor = namespace_ancestor (current_decl_namespace (), used);
4780 ud = current_binding_level->using_directives;
4781 ud = tree_cons (used, ancestor, ud);
4782 current_binding_level->using_directives = ud;
4784 /* Recursively add all namespaces used. */
4785 for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
4786 push_using_directive (TREE_PURPOSE (iter));
4788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
4791 /* The type TYPE is being declared. If it is a class template, or a
4792 specialization of a class template, do any processing required and
4793 perform error-checking. If IS_FRIEND is nonzero, this TYPE is
4794 being declared a friend. B is the binding level at which this TYPE
4797 Returns the TYPE_DECL for TYPE, which may have been altered by this
4801 maybe_process_template_type_declaration (tree type, int is_friend,
4804 tree decl = TYPE_NAME (type);
4806 if (processing_template_parmlist)
4807 /* You can't declare a new template type in a template parameter
4808 list. But, you can declare a non-template type:
4810 template <class A*> struct S;
4812 is a forward-declaration of `A'. */
4814 else if (b->kind == sk_namespace
4815 && current_binding_level->kind != sk_namespace)
4816 /* If this new type is being injected into a containing scope,
4817 then it's not a template type. */
4821 gcc_assert (IS_AGGR_TYPE (type) || TREE_CODE (type) == ENUMERAL_TYPE);
4823 if (processing_template_decl)
4825 /* This may change after the call to
4826 push_template_decl_real, but we want the original value. */
4827 tree name = DECL_NAME (decl);
4829 decl = push_template_decl_real (decl, is_friend);
4830 /* If the current binding level is the binding level for the
4831 template parameters (see the comment in
4832 begin_template_parm_list) and the enclosing level is a class
4833 scope, and we're not looking at a friend, push the
4834 declaration of the member class into the class scope. In the
4835 friend case, push_template_decl will already have put the
4836 friend into global scope, if appropriate. */
4837 if (TREE_CODE (type) != ENUMERAL_TYPE
4838 && !is_friend && b->kind == sk_template_parms
4839 && b->level_chain->kind == sk_class)
4841 finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
4843 if (!COMPLETE_TYPE_P (current_class_type))
4845 maybe_add_class_template_decl_list (current_class_type,
4846 type, /*friend_p=*/0);
4847 /* Put this UTD in the table of UTDs for the class. */
4848 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4849 CLASSTYPE_NESTED_UTDS (current_class_type) =
4850 binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4852 binding_table_insert
4853 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
4862 /* Push a tag name NAME for struct/class/union/enum type TYPE. In case
4863 that the NAME is a class template, the tag is processed but not pushed.
4865 The pushed scope depend on the SCOPE parameter:
4866 - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
4868 - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
4869 non-template-parameter scope. This case is needed for forward
4871 - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
4872 TS_GLOBAL case except that names within template-parameter scopes
4873 are not pushed at all.
4875 Returns TYPE upon success and ERROR_MARK_NODE otherwise. */
4878 pushtag (tree name, tree type, tag_scope scope)
4880 struct cp_binding_level *b;
4883 timevar_push (TV_NAME_LOOKUP);
4884 b = current_binding_level;
4885 while (/* Cleanup scopes are not scopes from the point of view of
4887 b->kind == sk_cleanup
4888 /* Neither are the scopes used to hold template parameters
4889 for an explicit specialization. For an ordinary template
4890 declaration, these scopes are not scopes from the point of
4891 view of the language. */
4892 || (b->kind == sk_template_parms
4893 && (b->explicit_spec_p || scope == ts_global))
4894 || (b->kind == sk_class
4895 && (scope != ts_current
4896 /* We may be defining a new type in the initializer
4897 of a static member variable. We allow this when
4898 not pedantic, and it is particularly useful for
4899 type punning via an anonymous union. */
4900 || COMPLETE_TYPE_P (b->this_entity))))
4903 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
4905 /* Do C++ gratuitous typedefing. */
4906 if (IDENTIFIER_TYPE_VALUE (name) != type)
4910 tree context = TYPE_CONTEXT (type);
4914 tree cs = current_scope ();
4916 if (scope == ts_current)
4918 else if (cs != NULL_TREE && TYPE_P (cs))
4919 /* When declaring a friend class of a local class, we want
4920 to inject the newly named class into the scope
4921 containing the local class, not the namespace
4923 context = decl_function_context (get_type_decl (cs));
4926 context = current_namespace;
4928 if (b->kind == sk_class
4929 || (b->kind == sk_template_parms
4930 && b->level_chain->kind == sk_class))
4933 if (current_lang_name == lang_name_java)
4934 TYPE_FOR_JAVA (type) = 1;
4936 tdef = create_implicit_typedef (name, type);
4937 DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
4938 if (scope == ts_within_enclosing_non_class)
4940 /* This is a friend. Make this TYPE_DECL node hidden from
4941 ordinary name lookup. Its corresponding TEMPLATE_DECL
4942 will be marked in push_template_decl_real. */
4943 retrofit_lang_decl (tdef);
4944 DECL_ANTICIPATED (tdef) = 1;
4945 DECL_FRIEND_P (tdef) = 1;
4948 decl = maybe_process_template_type_declaration
4949 (type, scope == ts_within_enclosing_non_class, b);
4950 if (decl == error_mark_node)
4951 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4954 set_identifier_type_value_with_scope (name, tdef, b);
4956 if (b->kind == sk_class)
4958 if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
4959 /* Put this TYPE_DECL on the TYPE_FIELDS list for the
4960 class. But if it's a member template class, we want
4961 the TEMPLATE_DECL, not the TYPE_DECL, so this is done
4963 finish_member_declaration (decl);
4965 pushdecl_class_level (decl);
4967 else if (b->kind != sk_template_parms)
4969 decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
4970 if (decl == error_mark_node)
4971 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
4974 TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
4976 /* If this is a local class, keep track of it. We need this
4977 information for name-mangling, and so that it is possible to
4978 find all function definitions in a translation unit in a
4979 convenient way. (It's otherwise tricky to find a member
4980 function definition it's only pointed to from within a local
4982 if (TYPE_CONTEXT (type)
4983 && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
4984 VEC_safe_push (tree, gc, local_classes, type);
4986 if (b->kind == sk_class
4987 && !COMPLETE_TYPE_P (current_class_type))
4989 maybe_add_class_template_decl_list (current_class_type,
4990 type, /*friend_p=*/0);
4992 if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
4993 CLASSTYPE_NESTED_UTDS (current_class_type)
4994 = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
4996 binding_table_insert
4997 (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5000 decl = TYPE_NAME (type);
5001 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5002 TYPE_STUB_DECL (type) = decl;
5004 /* Set type visibility now if this is a forward declaration. */
5005 TREE_PUBLIC (decl) = 1;
5006 determine_visibility (decl);
5008 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5011 /* Subroutines for reverting temporarily to top-level for instantiation
5012 of templates and such. We actually need to clear out the class- and
5013 local-value slots of all identifiers, so that only the global values
5014 are at all visible. Simply setting current_binding_level to the global
5015 scope isn't enough, because more binding levels may be pushed. */
5016 struct saved_scope *scope_chain;
5018 /* If ID has not already been marked, add an appropriate binding to
5022 store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5024 cxx_saved_binding *saved;
5026 if (!id || !IDENTIFIER_BINDING (id))
5029 if (IDENTIFIER_MARKED (id))
5032 IDENTIFIER_MARKED (id) = 1;
5034 saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5035 saved->identifier = id;
5036 saved->binding = IDENTIFIER_BINDING (id);
5037 saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5038 IDENTIFIER_BINDING (id) = NULL;
5042 store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5046 timevar_push (TV_NAME_LOOKUP);
5047 for (t = names; t; t = TREE_CHAIN (t))
5051 if (TREE_CODE (t) == TREE_LIST)
5052 id = TREE_PURPOSE (t);
5056 store_binding (id, old_bindings);
5058 timevar_pop (TV_NAME_LOOKUP);
5061 /* Like store_bindings, but NAMES is a vector of cp_class_binding
5062 objects, rather than a TREE_LIST. */
5065 store_class_bindings (VEC(cp_class_binding,gc) *names,
5066 VEC(cxx_saved_binding,gc) **old_bindings)
5069 cp_class_binding *cb;
5071 timevar_push (TV_NAME_LOOKUP);
5072 for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5073 store_binding (cb->identifier, old_bindings);
5074 timevar_pop (TV_NAME_LOOKUP);
5078 push_to_top_level (void)
5080 struct saved_scope *s;
5081 struct cp_binding_level *b;
5082 cxx_saved_binding *sb;
5086 timevar_push (TV_NAME_LOOKUP);
5087 s = GGC_CNEW (struct saved_scope);
5089 b = scope_chain ? current_binding_level : 0;
5091 /* If we're in the middle of some function, save our state. */
5095 push_function_context_to (NULL_TREE);
5100 if (scope_chain && previous_class_level)
5101 store_class_bindings (previous_class_level->class_shadowed,
5104 /* Have to include the global scope, because class-scope decls
5105 aren't listed anywhere useful. */
5106 for (; b; b = b->level_chain)
5110 /* Template IDs are inserted into the global level. If they were
5111 inserted into namespace level, finish_file wouldn't find them
5112 when doing pending instantiations. Therefore, don't stop at
5113 namespace level, but continue until :: . */
5114 if (global_scope_p (b))
5117 store_bindings (b->names, &s->old_bindings);
5118 /* We also need to check class_shadowed to save class-level type
5119 bindings, since pushclass doesn't fill in b->names. */
5120 if (b->kind == sk_class)
5121 store_class_bindings (b->class_shadowed, &s->old_bindings);
5123 /* Unwind type-value slots back to top level. */
5124 for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5125 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5128 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5129 IDENTIFIER_MARKED (sb->identifier) = 0;
5131 s->prev = scope_chain;
5133 s->need_pop_function_context = need_pop;
5134 s->function_decl = current_function_decl;
5135 s->skip_evaluation = skip_evaluation;
5138 current_function_decl = NULL_TREE;
5139 current_lang_base = VEC_alloc (tree, gc, 10);
5140 current_lang_name = lang_name_cplusplus;
5141 current_namespace = global_namespace;
5142 push_class_stack ();
5143 skip_evaluation = 0;
5144 timevar_pop (TV_NAME_LOOKUP);
5148 pop_from_top_level (void)
5150 struct saved_scope *s = scope_chain;
5151 cxx_saved_binding *saved;
5154 timevar_push (TV_NAME_LOOKUP);
5155 /* Clear out class-level bindings cache. */
5156 if (previous_class_level)
5157 invalidate_class_lookup_cache ();
5160 current_lang_base = 0;
5162 scope_chain = s->prev;
5163 for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5165 tree id = saved->identifier;
5167 IDENTIFIER_BINDING (id) = saved->binding;
5168 SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5171 /* If we were in the middle of compiling a function, restore our
5173 if (s->need_pop_function_context)
5174 pop_function_context_from (NULL_TREE);
5175 current_function_decl = s->function_decl;
5176 skip_evaluation = s->skip_evaluation;
5177 timevar_pop (TV_NAME_LOOKUP);
5180 /* Pop off extraneous binding levels left over due to syntax errors.
5182 We don't pop past namespaces, as they might be valid. */
5185 pop_everything (void)
5187 if (ENABLE_SCOPE_CHECKING)
5188 verbatim ("XXX entering pop_everything ()\n");
5189 while (!toplevel_bindings_p ())
5191 if (current_binding_level->kind == sk_class)
5192 pop_nested_class ();
5196 if (ENABLE_SCOPE_CHECKING)
5197 verbatim ("XXX leaving pop_everything ()\n");
5200 /* Emit debugging information for using declarations and directives.
5201 If input tree is overloaded fn then emit debug info for all
5205 cp_emit_debug_info_for_using (tree t, tree context)
5207 /* Don't try to emit any debug information if we have errors. */
5208 if (sorrycount || errorcount)
5211 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5212 of a builtin function. */
5213 if (TREE_CODE (t) == FUNCTION_DECL
5214 && DECL_EXTERNAL (t)
5215 && DECL_BUILT_IN (t))
5218 /* Do not supply context to imported_module_or_decl, if
5219 it is a global namespace. */
5220 if (context == global_namespace)
5221 context = NULL_TREE;
5224 t = BASELINK_FUNCTIONS (t);
5226 /* FIXME: Handle TEMPLATE_DECLs. */
5227 for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5228 if (TREE_CODE (t) != TEMPLATE_DECL)
5229 (*debug_hooks->imported_module_or_decl) (t, context);
5232 #include "gt-cp-name-lookup.h"